--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/webengine/osswebengine/WebKit/s60/webview/WebPolicyManager.cpp	Mon Mar 30 12:54:55 2009 +0300
@@ -0,0 +1,200 @@
+/*
+* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:   Implementation of WebPolicyManager
+*
+*/
+
+#include "config.h"
+#include <../bidi.h>
+#include "WebPolicyManager.h"
+#include "WebFrameLoaderClient.h"
+#include "WebFrame.h"
+#include "WebFrameView.h"
+#include "WebView.h"
+#include "Frame.h"
+#include "FrameLoader.h"
+#include "DocumentLoader.h"
+#include "BrCtl.h"
+#include "WebUtil.h"
+#include "StaticObjectsContainer.h"
+#include "PlugInInfoStore.h"
+#include "MIMETypeRegistry.h"
+#include <Uri8.h>
+#include <badesca.h>
+
+using namespace WebCore;
+
+// CONSTANTS
+const char* typeTextHtml = "text/html";
+const char* typeApplicationXhtml = "application/xhtml+xml";
+const char* typeTextPlain = "text/plain";
+const char* typeApplicationWapXhtml = "application/vnd.wap.xhtml+xml";
+const char* typeMultipartMixed = "multipart/mixed";
+const char* typeApplicationOctetStream = "application/octet-stream";
+const char* typeImageSlash = "image/";
+const char* typeSvg = "svg";
+_LIT(KPathBegin,"<!--framePathBegin ");
+_LIT(KPathEnd," framePathEnd --!>");
+
+WebPolicyManager::WebPolicyManager(WebFrameLoaderClient* webFrameLoaderClient) :
+m_webFrameLoaderClient(webFrameLoaderClient)
+{
+    m_newWindowUserGesture = false;
+    m_newWindowTargetName = NULL;
+}
+
+WebPolicyManager::~WebPolicyManager()
+{
+    delete m_newWindowTargetName;
+}
+
+void WebPolicyManager::dispatchDecidePolicyForMIMEType(WebCore::FramePolicyFunction function,
+                                                       const WebCore::String& MIMEType,
+                                                       const WebCore::ResourceRequest& /*request*/)
+{
+    if ( m_webFrameLoaderClient->isWMLContent(MIMEType) ) {
+        // check for wml limitations
+        const Vector<CBrCtl*>& ctrls = StaticObjectsContainer::instance()->activeBrowserControls();
+        for (int i=0; i<ctrls.size(); ++i) {
+            // check non-current BrCtls to see if wml engine is loaded
+            // if it is then we need to ignore this url since only one BrCtl can load the wml engine
+            if (ctrls[i]->wmlEngineInterface() &&
+                ctrls[i] != control(m_webFrameLoaderClient->webFrame())) {
+                m_webFrameLoaderClient->ignore(function);
+                return;
+            }
+        }
+        m_webFrameLoaderClient->use(function);
+    }
+    else if ( canShowMIMEType(MIMEType) || 
+              ((m_webFrameLoaderClient->webFrame()->parentFrame()) && (PlugInInfoStore::supportsMIMEType(MIMEType)) && 
+              !(MIMEType.startsWith("audio/", false)) && !(MIMEType.startsWith("video/", false)))) {
+        m_webFrameLoaderClient->use(function);
+    }
+    else {
+        m_webFrameLoaderClient->download(function);
+    }
+}
+
+void WebPolicyManager::dispatchDecidePolicyForNewWindowAction(WebCore::FramePolicyFunction function, const WebCore::NavigationAction& action, const WebCore::ResourceRequest& request, const WebCore::String& frameName)
+{
+    switch (action.type())
+    {
+        case NavigationTypeLinkClicked:
+        case NavigationTypeFormSubmitted:
+        case NavigationTypeBackForward:
+        case NavigationTypeReload:
+        case NavigationTypeFormResubmitted:
+            m_newWindowUserGesture = true;
+            break;
+        case NavigationTypeOther:
+        default:
+            m_newWindowUserGesture = false;
+            break;
+    }
+    delete m_newWindowTargetName;
+    m_newWindowTargetName = NULL;
+    if (frameName.des().Length()) {
+        if (frameName == "_blank" || frameName == "_new") {
+            m_newWindowTargetName = generateFrameName();
+        }
+        else { // frame has a name
+            m_newWindowTargetName = frameName.des().Alloc();
+        }
+    }
+    if (m_newWindowTargetName) {
+            m_webFrameLoaderClient->use(function);
+    }
+    else {
+        m_webFrameLoaderClient->ignore(function);
+    }
+}
+
+void WebPolicyManager::dispatchDecidePolicyForNavigationAction(WebCore::FramePolicyFunction function, const WebCore::NavigationAction&, const WebCore::ResourceRequest& request)
+{
+    // ResourceLoadDelegate does all the checks now.
+    m_webFrameLoaderClient->use(function);
+}
+
+void WebPolicyManager::cancelPolicyCheck()
+{
+}
+
+void WebPolicyManager::dispatchUnableToImplementPolicy(const WebCore::ResourceError&)
+{
+}
+
+void WebPolicyManager::dispatchWillSubmitForm(WebCore::FramePolicyFunction function, PassRefPtr<WebCore::FormState>)
+{
+    m_webFrameLoaderClient->use(function);
+}
+
+WebCore::ResourceError WebPolicyManager::interruptForPolicyChangeError(const WebCore::ResourceRequest& request)
+{
+    return ResourceError(); 
+}
+
+bool WebPolicyManager::canShowMIMEType(const String& MIMEType) const 
+{
+    bool found = false;
+    
+    //RFC 2183: "Content-Disposition: attachment" means downloaded by DM
+    FrameLoader* frameLoader = m_webFrameLoaderClient->webFrame()->frameLoader();
+    if(frameLoader && frameLoader->activeDocumentLoader()) {
+    	ResourceResponse r = frameLoader->activeDocumentLoader()->response();
+    	if (r.isAttachment())
+    		return found;
+    }
+
+    if (MIMEType == typeTextHtml ||
+        MIMEType == typeApplicationXhtml ||
+        MIMEType == typeApplicationWapXhtml ||
+        MIMEType == typeMultipartMixed) {
+        found = true;
+    }
+    //Check if the image type can be handled by the browser. If not
+    //forward download manager downloads the content
+    else if (MIMETypeRegistry::isSupportedImageMIMEType(MIMEType)){
+        found = true;
+    }
+
+    // special case for application/octet-stream. some web servers
+    // are miscofigured and send application/octet-stream even for html
+    // page so we need to pass it to webcore as if it was text/html. however
+    // some binary content also comes as application/octet-stream (such as
+    // sisx files ). so here we che(ha)ck if the response url has .html .htm .asp
+    // extension. though luck for the rest. feel free to extend the list.
+    // some text/plain is actually not (example: cacert.org DER root certificate)
+    else if( MIMEType == typeTextPlain ||
+             MIMEType == typeApplicationOctetStream ) {
+        TPtrC8 url = (core(m_webFrameLoaderClient->webFrame()))->loader()->activeDocumentLoader()->responseURL().des();
+        TUriParser8 parser;
+        if( parser.Parse(url) == KErrNone ) {
+            TPtrC8 path = parser.Extract( EUriPath );
+            // path == 1 means only / (no filename)
+            if( path.Length() > 1 ) {
+                found = (path.Find(_L8(".html")) != KErrNotFound ||
+                         path.Find(_L8(".htm"))  != KErrNotFound ||
+                         path.Find(_L8(".asp"))  != KErrNotFound ||
+                         path.Find(_L8(".php"))  != KErrNotFound ||
+                         path.Find(_L8(".jsp"))  != KErrNotFound ||
+                         path.Find(_L8(".txt"))  != KErrNotFound);
+            }
+        }
+    }
+    // tot:fixme defaultcontenthandler is only for selfdownloadable, go through the list
+    return found;
+}
+
+