| Index: webkit/api/src/FrameLoaderClientImpl.cpp
|
| ===================================================================
|
| --- webkit/api/src/FrameLoaderClientImpl.cpp (revision 30320)
|
| +++ webkit/api/src/FrameLoaderClientImpl.cpp (working copy)
|
| @@ -1,8 +1,35 @@
|
| -// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
|
| -// Use of this source code is governed by a BSD-style license that can be
|
| -// found in the LICENSE file.
|
| +/*
|
| + * Copyright (C) 2009 Google Inc. All rights reserved.
|
| + *
|
| + * Redistribution and use in source and binary forms, with or without
|
| + * modification, are permitted provided that the following conditions are
|
| + * met:
|
| + *
|
| + * * Redistributions of source code must retain the above copyright
|
| + * notice, this list of conditions and the following disclaimer.
|
| + * * Redistributions in binary form must reproduce the above
|
| + * copyright notice, this list of conditions and the following disclaimer
|
| + * in the documentation and/or other materials provided with the
|
| + * distribution.
|
| + * * Neither the name of Google Inc. nor the names of its
|
| + * contributors may be used to endorse or promote products derived from
|
| + * this software without specific prior written permission.
|
| + *
|
| + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
| + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
| + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
| + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
| + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
| + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
| + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
| + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
| + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
| + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
| + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
| + */
|
|
|
| #include "config.h"
|
| +#include "FrameLoaderClientImpl.h"
|
|
|
| #include "Chrome.h"
|
| #include "CString.h"
|
| @@ -21,182 +48,178 @@
|
| #include "PlatformString.h"
|
| #include "PluginData.h"
|
| #include "StringExtras.h"
|
| +#include "WebForm.h"
|
| +#include "WebFrameClient.h"
|
| +#include "WebFrameImpl.h"
|
| +#include "WebNode.h"
|
| +#include "WebPlugin.h"
|
| +#include "WebPluginParams.h"
|
| +#include "WebSecurityOrigin.h"
|
| +#include "WebURL.h"
|
| +#include "WebURLError.h"
|
| +#include "WebVector.h"
|
| +#include "WebViewClient.h"
|
| +#include "WebViewImpl.h"
|
| +#include "WebDataSourceImpl.h"
|
| +#include "WebPluginContainerImpl.h"
|
| +#include "WebPluginLoadObserver.h"
|
| #include "WindowFeatures.h"
|
| -#undef LOG
|
| +#include "WrappedResourceRequest.h"
|
| +#include "WrappedResourceResponse.h"
|
|
|
| +// FIXME: remove these
|
| +#include "googleurl/src/gurl.h"
|
| #include "net/base/mime_util.h"
|
| -#include "webkit/api/public/WebForm.h"
|
| -#include "webkit/api/public/WebFrameClient.h"
|
| -#include "webkit/api/public/WebNode.h"
|
| -#include "webkit/api/public/WebPlugin.h"
|
| -#include "webkit/api/public/WebPluginParams.h"
|
| -#include "webkit/api/public/WebSecurityOrigin.h"
|
| -#include "webkit/api/public/WebURL.h"
|
| -#include "webkit/api/public/WebURLError.h"
|
| -#include "webkit/api/public/WebVector.h"
|
| -#include "webkit/api/public/WebViewClient.h"
|
| -#include "webkit/api/src/WebDataSourceImpl.h"
|
| -#include "webkit/api/src/WebPluginContainerImpl.h"
|
| -#include "webkit/api/src/WebPluginLoadObserver.h"
|
| -#include "webkit/api/src/WrappedResourceRequest.h"
|
| -#include "webkit/api/src/WrappedResourceResponse.h"
|
| #include "webkit/glue/glue_util.h"
|
| #include "webkit/glue/webdevtoolsagent_impl.h"
|
| -#include "webkit/glue/webframe_impl.h"
|
| -#include "webkit/glue/webframeloaderclient_impl.h"
|
| #include "webkit/glue/webkit_glue.h"
|
| -#include "webkit/glue/webview_impl.h"
|
|
|
| using namespace WebCore;
|
|
|
| -using WebKit::WebData;
|
| -using WebKit::WebDataSourceImpl;
|
| -using WebKit::WebNavigationType;
|
| -using WebKit::WebNavigationPolicy;
|
| -using WebKit::WebNode;
|
| -using WebKit::WebPlugin;
|
| -using WebKit::WebPluginContainerImpl;
|
| -using WebKit::WebPluginLoadObserver;
|
| -using WebKit::WebPluginParams;
|
| -using WebKit::WebString;
|
| -using WebKit::WebURL;
|
| -using WebKit::WebURLError;
|
| -using WebKit::WebURLRequest;
|
| -using WebKit::WebVector;
|
| -using WebKit::WrappedResourceRequest;
|
| -using WebKit::WrappedResourceResponse;
|
| +namespace WebKit {
|
|
|
| // Domain for internal error codes.
|
| -static const char kInternalErrorDomain[] = "WebKit";
|
| +static const char internalErrorDomain[] = "WebKit";
|
|
|
| // An internal error code. Used to note a policy change error resulting from
|
| // dispatchDecidePolicyForMIMEType not passing the PolicyUse option.
|
| enum {
|
| - ERR_POLICY_CHANGE = -10000,
|
| + PolicyChangeError = -10000,
|
| };
|
|
|
| -static void CopyStringVector(
|
| - const Vector<String>& input, WebVector<WebString>* output) {
|
| - WebVector<WebString> result(input.size());
|
| - for (size_t i = 0; i < input.size(); ++i)
|
| - result[i] = webkit_glue::StringToWebString(input[i]);
|
| - output->swap(result);
|
| +FrameLoaderClientImpl::FrameLoaderClientImpl(WebFrameImpl* frame)
|
| + : m_webFrame(frame)
|
| + , m_hasRepresentation(false)
|
| + , m_sentInitialResponseToPlugin(false)
|
| + , m_nextNavigationPolicy(WebNavigationPolicyIgnore) {
|
| }
|
|
|
| -WebFrameLoaderClient::WebFrameLoaderClient(WebFrameImpl* frame)
|
| - : webframe_(frame),
|
| - has_representation_(false),
|
| - sent_initial_response_to_plugin_(false),
|
| - next_navigation_policy_(WebKit::WebNavigationPolicyIgnore) {
|
| +FrameLoaderClientImpl::~FrameLoaderClientImpl() {
|
| }
|
|
|
| -WebFrameLoaderClient::~WebFrameLoaderClient() {
|
| +void FrameLoaderClientImpl::frameLoaderDestroyed()
|
| +{
|
| + // When the WebFrame was created, it had an extra reference given to it on
|
| + // behalf of the Frame. Since the WebFrame owns us, this extra ref also
|
| + // serves to keep us alive until the FrameLoader is done with us. The
|
| + // FrameLoader calls this method when it's going away. Therefore, we balance
|
| + // out that extra reference, which may cause 'this' to be deleted.
|
| + m_webFrame->closing();
|
| + m_webFrame->deref();
|
| }
|
|
|
| -void WebFrameLoaderClient::frameLoaderDestroyed() {
|
| - // When the WebFrame was created, it had an extra reference given to it on
|
| - // behalf of the Frame. Since the WebFrame owns us, this extra ref also
|
| - // serves to keep us alive until the FrameLoader is done with us. The
|
| - // FrameLoader calls this method when it's going away. Therefore, we balance
|
| - // out that extra reference, which may cause 'this' to be deleted.
|
| - webframe_->Closing();
|
| - webframe_->deref();
|
| +void FrameLoaderClientImpl::windowObjectCleared()
|
| +{
|
| + if (m_webFrame->client())
|
| + m_webFrame->client()->didClearWindowObject(m_webFrame);
|
| +
|
| + WebViewImpl* webview = m_webFrame->viewImpl();
|
| + if (webview) {
|
| + WebDevToolsAgentImpl* toolsAgent = webview->devToolsAgentImpl();
|
| + if (toolsAgent)
|
| + toolsAgent->WindowObjectCleared(m_webFrame);
|
| + }
|
| }
|
|
|
| -void WebFrameLoaderClient::windowObjectCleared() {
|
| - if (webframe_->client())
|
| - webframe_->client()->didClearWindowObject(webframe_);
|
| -
|
| - WebViewImpl* webview = webframe_->GetWebViewImpl();
|
| - if (webview) {
|
| - WebDevToolsAgentImpl* tools_agent = webview->GetWebDevToolsAgentImpl();
|
| - if (tools_agent)
|
| - tools_agent->WindowObjectCleared(webframe_);
|
| - }
|
| +void FrameLoaderClientImpl::documentElementAvailable()
|
| +{
|
| + if (m_webFrame->client())
|
| + m_webFrame->client()->didCreateDocumentElement(m_webFrame);
|
| }
|
|
|
| -void WebFrameLoaderClient::documentElementAvailable() {
|
| - if (webframe_->client())
|
| - webframe_->client()->didCreateDocumentElement(webframe_);
|
| +void FrameLoaderClientImpl::didCreateScriptContextForFrame()
|
| +{
|
| + if (m_webFrame->client())
|
| + m_webFrame->client()->didCreateScriptContext(m_webFrame);
|
| }
|
|
|
| -void WebFrameLoaderClient::didCreateScriptContextForFrame() {
|
| - if (webframe_->client())
|
| - webframe_->client()->didCreateScriptContext(webframe_);
|
| +void FrameLoaderClientImpl::didDestroyScriptContextForFrame()
|
| +{
|
| + if (m_webFrame->client())
|
| + m_webFrame->client()->didDestroyScriptContext(m_webFrame);
|
| }
|
|
|
| -void WebFrameLoaderClient::didDestroyScriptContextForFrame() {
|
| - if (webframe_->client())
|
| - webframe_->client()->didDestroyScriptContext(webframe_);
|
| +void FrameLoaderClientImpl::didCreateIsolatedScriptContext()
|
| +{
|
| + if (m_webFrame->client())
|
| + m_webFrame->client()->didCreateIsolatedScriptContext(m_webFrame);
|
| }
|
|
|
| -void WebFrameLoaderClient::didCreateIsolatedScriptContext() {
|
| - if (webframe_->client())
|
| - webframe_->client()->didCreateIsolatedScriptContext(webframe_);
|
| +void FrameLoaderClientImpl::didPerformFirstNavigation() const
|
| +{
|
| }
|
|
|
| -void WebFrameLoaderClient::didPerformFirstNavigation() const {
|
| +void FrameLoaderClientImpl::registerForIconNotification(bool)
|
| +{
|
| }
|
|
|
| -void WebFrameLoaderClient::registerForIconNotification(bool listen){
|
| +bool FrameLoaderClientImpl::hasWebView() const
|
| +{
|
| + return m_webFrame->viewImpl() != 0;
|
| }
|
|
|
| -bool WebFrameLoaderClient::hasWebView() const {
|
| - return webframe_->GetWebViewImpl() != NULL;
|
| +bool FrameLoaderClientImpl::hasFrameView() const
|
| +{
|
| + // The Mac port has this notion of a WebFrameView, which seems to be
|
| + // some wrapper around an NSView. Since our equivalent is HWND, I guess
|
| + // we have a "frameview" whenever we have the toplevel HWND.
|
| + return m_webFrame->viewImpl() != 0;
|
| }
|
|
|
| -bool WebFrameLoaderClient::hasFrameView() const {
|
| - // The Mac port has this notion of a WebFrameView, which seems to be
|
| - // some wrapper around an NSView. Since our equivalent is HWND, I guess
|
| - // we have a "frameview" whenever we have the toplevel HWND.
|
| - return webframe_->GetWebViewImpl() != NULL;
|
| +void FrameLoaderClientImpl::makeDocumentView()
|
| +{
|
| + m_webFrame->createFrameView();
|
| }
|
|
|
| -void WebFrameLoaderClient::makeDocumentView() {
|
| - webframe_->CreateFrameView();
|
| +void FrameLoaderClientImpl::makeRepresentation(DocumentLoader*)
|
| +{
|
| + m_hasRepresentation = true;
|
| }
|
|
|
| -void WebFrameLoaderClient::makeRepresentation(DocumentLoader*) {
|
| - has_representation_ = true;
|
| +void FrameLoaderClientImpl::forceLayout()
|
| +{
|
| + // FIXME
|
| }
|
|
|
| -void WebFrameLoaderClient::forceLayout() {
|
| - // FIXME
|
| +void FrameLoaderClientImpl::forceLayoutForNonHTML()
|
| +{
|
| + // FIXME
|
| }
|
| -void WebFrameLoaderClient::forceLayoutForNonHTML() {
|
| - // FIXME
|
| -}
|
|
|
| -void WebFrameLoaderClient::setCopiesOnScroll() {
|
| - // FIXME
|
| +void FrameLoaderClientImpl::setCopiesOnScroll()
|
| +{
|
| + // FIXME
|
| }
|
|
|
| -void WebFrameLoaderClient::detachedFromParent2() {
|
| - // Nothing to do here.
|
| +void FrameLoaderClientImpl::detachedFromParent2()
|
| +{
|
| + // Nothing to do here.
|
| }
|
|
|
| -void WebFrameLoaderClient::detachedFromParent3() {
|
| - // Close down the proxy. The purpose of this change is to make the
|
| - // call to ScriptController::clearWindowShell a no-op when called from
|
| - // Frame::pageDestroyed. Without this change, this call to clearWindowShell
|
| - // will cause a crash. If you remove/modify this, just ensure that you can
|
| - // go to a page and then navigate to a new page without getting any asserts
|
| - // or crashes.
|
| - webframe_->frame()->script()->proxy()->clearForClose();
|
| +void FrameLoaderClientImpl::detachedFromParent3()
|
| +{
|
| + // Close down the proxy. The purpose of this change is to make the
|
| + // call to ScriptController::clearWindowShell a no-op when called from
|
| + // Frame::pageDestroyed. Without this change, this call to clearWindowShell
|
| + // will cause a crash. If you remove/modify this, just ensure that you can
|
| + // go to a page and then navigate to a new page without getting any asserts
|
| + // or crashes.
|
| + m_webFrame->frame()->script()->proxy()->clearForClose();
|
| }
|
|
|
| // This function is responsible for associating the |identifier| with a given
|
| // subresource load. The following functions that accept an |identifier| are
|
| // called for each subresource, so they should not be dispatched to the
|
| // WebFrame.
|
| -void WebFrameLoaderClient::assignIdentifierToInitialRequest(
|
| +void FrameLoaderClientImpl::assignIdentifierToInitialRequest(
|
| unsigned long identifier, DocumentLoader* loader,
|
| - const ResourceRequest& request) {
|
| - if (webframe_->client()) {
|
| - WrappedResourceRequest webreq(request);
|
| - webframe_->client()->assignIdentifierToRequest(
|
| - webframe_, identifier, webreq);
|
| - }
|
| + const ResourceRequest& request)
|
| +{
|
| + if (m_webFrame->client()) {
|
| + WrappedResourceRequest webreq(request);
|
| + m_webFrame->client()->assignIdentifierToRequest(
|
| + m_webFrame, identifier, webreq);
|
| + }
|
| }
|
|
|
| // Determines whether the request being loaded by |loader| is a frame or a
|
| @@ -208,131 +231,140 @@
|
| //
|
| // The important edge cases to consider when modifying this function are
|
| // how synchronous resource loads are treated during load/unload threshold.
|
| -static ResourceRequest::TargetType DetermineTargetTypeFromLoader(
|
| - DocumentLoader* loader) {
|
| - if (loader == loader->frameLoader()->provisionalDocumentLoader()) {
|
| - if (loader->frameLoader()->isLoadingMainFrame()) {
|
| - return ResourceRequest::TargetIsMainFrame;
|
| - } else {
|
| - return ResourceRequest::TargetIsSubFrame;
|
| +static ResourceRequest::TargetType determineTargetTypeFromLoader(
|
| + DocumentLoader* loader)
|
| +{
|
| + if (loader == loader->frameLoader()->provisionalDocumentLoader()) {
|
| + if (loader->frameLoader()->isLoadingMainFrame())
|
| + return ResourceRequest::TargetIsMainFrame;
|
| + else
|
| + return ResourceRequest::TargetIsSubFrame;
|
| }
|
| - }
|
| - return ResourceRequest::TargetIsSubResource;
|
| + return ResourceRequest::TargetIsSubResource;
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchWillSendRequest(
|
| +void FrameLoaderClientImpl::dispatchWillSendRequest(
|
| DocumentLoader* loader, unsigned long identifier, ResourceRequest& request,
|
| - const ResourceResponse& redirect_response) {
|
| + const ResourceResponse& redirectResponse)
|
| +{
|
| + if (loader) {
|
| + // We want to distinguish between a request for a document to be loaded into
|
| + // the main frame, a sub-frame, or the sub-objects in that document.
|
| + request.setTargetType(determineTargetTypeFromLoader(loader));
|
| + }
|
|
|
| - if (loader) {
|
| - // We want to distinguish between a request for a document to be loaded into
|
| - // the main frame, a sub-frame, or the sub-objects in that document.
|
| - request.setTargetType(DetermineTargetTypeFromLoader(loader));
|
| - }
|
| + // FrameLoader::loadEmptyDocumentSynchronously() creates an empty document
|
| + // with no URL. We don't like that, so we'll rename it to about:blank.
|
| + if (request.url().isEmpty())
|
| + request.setURL(KURL(ParsedURLString, "about:blank"));
|
| + if (request.firstPartyForCookies().isEmpty())
|
| + request.setFirstPartyForCookies(KURL(ParsedURLString, "about:blank"));
|
|
|
| - // FrameLoader::loadEmptyDocumentSynchronously() creates an empty document
|
| - // with no URL. We don't like that, so we'll rename it to about:blank.
|
| - if (request.url().isEmpty())
|
| - request.setURL(KURL(ParsedURLString, "about:blank"));
|
| - if (request.firstPartyForCookies().isEmpty())
|
| - request.setFirstPartyForCookies(KURL(ParsedURLString, "about:blank"));
|
| -
|
| - // Give the WebFrameClient a crack at the request.
|
| - if (webframe_->client()) {
|
| - WrappedResourceRequest webreq(request);
|
| - WrappedResourceResponse webresp(redirect_response);
|
| - webframe_->client()->willSendRequest(
|
| - webframe_, identifier, webreq, webresp);
|
| - }
|
| + // Give the WebFrameClient a crack at the request.
|
| + if (m_webFrame->client()) {
|
| + WrappedResourceRequest webreq(request);
|
| + WrappedResourceResponse webresp(redirectResponse);
|
| + m_webFrame->client()->willSendRequest(
|
| + m_webFrame, identifier, webreq, webresp);
|
| + }
|
| }
|
|
|
| -bool WebFrameLoaderClient::shouldUseCredentialStorage(DocumentLoader*,
|
| - unsigned long identifier) {
|
| - // FIXME
|
| - // Intended to pass through to a method on the resource load delegate.
|
| - // If implemented, that method controls whether the browser should ask the
|
| - // networking layer for a stored default credential for the page (say from
|
| - // the Mac OS keychain). If the method returns false, the user should be
|
| - // presented with an authentication challenge whether or not the networking
|
| - // layer has a credential stored.
|
| - // This returns true for backward compatibility: the ability to override the
|
| - // system credential store is new. (Actually, not yet fully implemented in
|
| - // WebKit, as of this writing.)
|
| - return true;
|
| +bool FrameLoaderClientImpl::shouldUseCredentialStorage(
|
| + DocumentLoader*, unsigned long identifier)
|
| +{
|
| + // FIXME
|
| + // Intended to pass through to a method on the resource load delegate.
|
| + // If implemented, that method controls whether the browser should ask the
|
| + // networking layer for a stored default credential for the page (say from
|
| + // the Mac OS keychain). If the method returns false, the user should be
|
| + // presented with an authentication challenge whether or not the networking
|
| + // layer has a credential stored.
|
| + // This returns true for backward compatibility: the ability to override the
|
| + // system credential store is new. (Actually, not yet fully implemented in
|
| + // WebKit, as of this writing.)
|
| + return true;
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchDidReceiveAuthenticationChallenge(
|
| - DocumentLoader*, unsigned long identifier, const AuthenticationChallenge&) {
|
| - // FIXME
|
| +void FrameLoaderClientImpl::dispatchDidReceiveAuthenticationChallenge(
|
| + DocumentLoader*, unsigned long identifier, const AuthenticationChallenge&)
|
| +{
|
| + // FIXME
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchDidCancelAuthenticationChallenge(
|
| - DocumentLoader*, unsigned long identifier, const AuthenticationChallenge&) {
|
| - // FIXME
|
| +void FrameLoaderClientImpl::dispatchDidCancelAuthenticationChallenge(
|
| + DocumentLoader*, unsigned long identifier, const AuthenticationChallenge&)
|
| +{
|
| + // FIXME
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchDidReceiveResponse(DocumentLoader* loader,
|
| - unsigned long identifier,
|
| - const ResourceResponse& response) {
|
| - if (webframe_->client()) {
|
| - WrappedResourceResponse webresp(response);
|
| - webframe_->client()->didReceiveResponse(webframe_, identifier, webresp);
|
| - }
|
| +void FrameLoaderClientImpl::dispatchDidReceiveResponse(DocumentLoader* loader,
|
| + unsigned long identifier,
|
| + const ResourceResponse& response)
|
| +{
|
| + if (m_webFrame->client()) {
|
| + WrappedResourceResponse webresp(response);
|
| + m_webFrame->client()->didReceiveResponse(m_webFrame, identifier, webresp);
|
| + }
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchDidReceiveContentLength(
|
| +void FrameLoaderClientImpl::dispatchDidReceiveContentLength(
|
| DocumentLoader* loader,
|
| unsigned long identifier,
|
| - int length_received) {
|
| + int lengthReceived)
|
| +{
|
| }
|
|
|
| // Called when a particular resource load completes
|
| -void WebFrameLoaderClient::dispatchDidFinishLoading(DocumentLoader* loader,
|
| - unsigned long identifier) {
|
| - if (webframe_->client())
|
| - webframe_->client()->didFinishResourceLoad(webframe_, identifier);
|
| +void FrameLoaderClientImpl::dispatchDidFinishLoading(DocumentLoader* loader,
|
| + unsigned long identifier)
|
| +{
|
| + if (m_webFrame->client())
|
| + m_webFrame->client()->didFinishResourceLoad(m_webFrame, identifier);
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchDidFailLoading(DocumentLoader* loader,
|
| +void FrameLoaderClientImpl::dispatchDidFailLoading(DocumentLoader* loader,
|
| unsigned long identifier,
|
| - const ResourceError& error) {
|
| - if (webframe_->client()) {
|
| - webframe_->client()->didFailResourceLoad(
|
| - webframe_, identifier, webkit_glue::ResourceErrorToWebURLError(error));
|
| - }
|
| + const ResourceError& error)
|
| +{
|
| + if (m_webFrame->client())
|
| + m_webFrame->client()->didFailResourceLoad(m_webFrame, identifier, error);
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchDidFinishDocumentLoad() {
|
| - // A frame may be reused. This call ensures we don't hold on to our password
|
| - // listeners and their associated HTMLInputElements.
|
| - webframe_->ClearPasswordListeners();
|
| +void FrameLoaderClientImpl::dispatchDidFinishDocumentLoad()
|
| +{
|
| + // A frame may be reused. This call ensures we don't hold on to our password
|
| + // listeners and their associated HTMLInputElements.
|
| + m_webFrame->clearPasswordListeners();
|
|
|
| - if (webframe_->client())
|
| - webframe_->client()->didFinishDocumentLoad(webframe_);
|
| + if (m_webFrame->client())
|
| + m_webFrame->client()->didFinishDocumentLoad(m_webFrame);
|
| }
|
|
|
| -bool WebFrameLoaderClient::dispatchDidLoadResourceFromMemoryCache(
|
| +bool FrameLoaderClientImpl::dispatchDidLoadResourceFromMemoryCache(
|
| DocumentLoader* loader,
|
| const ResourceRequest& request,
|
| const ResourceResponse& response,
|
| - int length) {
|
| - if (webframe_->client()) {
|
| - WrappedResourceRequest webreq(request);
|
| - WrappedResourceResponse webresp(response);
|
| - webframe_->client()->didLoadResourceFromMemoryCache(
|
| - webframe_, webreq, webresp);
|
| - }
|
| - return false; // Do not suppress remaining notifications
|
| + int length)
|
| +{
|
| + if (m_webFrame->client()) {
|
| + WrappedResourceRequest webreq(request);
|
| + WrappedResourceResponse webresp(response);
|
| + m_webFrame->client()->didLoadResourceFromMemoryCache(
|
| + m_webFrame, webreq, webresp);
|
| + }
|
| + return false; // Do not suppress remaining notifications
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchDidLoadResourceByXMLHttpRequest(
|
| +void FrameLoaderClientImpl::dispatchDidLoadResourceByXMLHttpRequest(
|
| unsigned long identifier,
|
| - const ScriptString& source) {
|
| + const ScriptString& source)
|
| +{
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchDidHandleOnloadEvents() {
|
| - if (webframe_->client())
|
| - webframe_->client()->didHandleOnloadEvents(webframe_);
|
| +void FrameLoaderClientImpl::dispatchDidHandleOnloadEvents()
|
| +{
|
| + if (m_webFrame->client())
|
| + m_webFrame->client()->didHandleOnloadEvents(m_webFrame);
|
| }
|
|
|
| // Redirect Tracking
|
| @@ -415,922 +447,959 @@
|
| // dispatchDidCancelClientRedirect() -> clears expected redirect
|
| // dispatchDidCommitLoad() -> DISPATCHES 1#anchor + 1
|
| //
|
| -void WebFrameLoaderClient::dispatchDidReceiveServerRedirectForProvisionalLoad() {
|
| - WebDataSourceImpl* ds = webframe_->GetProvisionalDataSourceImpl();
|
| - if (!ds) {
|
| - // Got a server redirect when there is no provisional DS!
|
| - ASSERT_NOT_REACHED();
|
| - return;
|
| - }
|
| +void FrameLoaderClientImpl::dispatchDidReceiveServerRedirectForProvisionalLoad()
|
| +{
|
| + WebDataSourceImpl* ds = m_webFrame->provisionalDataSourceImpl();
|
| + if (!ds) {
|
| + // Got a server redirect when there is no provisional DS!
|
| + ASSERT_NOT_REACHED();
|
| + return;
|
| + }
|
|
|
| - // The server redirect may have been blocked.
|
| - if (ds->request().isNull())
|
| - return;
|
| + // The server redirect may have been blocked.
|
| + if (ds->request().isNull())
|
| + return;
|
|
|
| - // A provisional load should have started already, which should have put an
|
| - // entry in our redirect chain.
|
| - ASSERT(ds->hasRedirectChain());
|
| + // A provisional load should have started already, which should have put an
|
| + // entry in our redirect chain.
|
| + ASSERT(ds->hasRedirectChain());
|
|
|
| - // The URL of the destination is on the provisional data source. We also need
|
| - // to update the redirect chain to account for this addition (we do this
|
| - // before the callback so the callback can look at the redirect chain to see
|
| - // what happened).
|
| - ds->appendRedirect(webkit_glue::WebURLToKURL(ds->request().url()));
|
| + // The URL of the destination is on the provisional data source. We also need
|
| + // to update the redirect chain to account for this addition (we do this
|
| + // before the callback so the callback can look at the redirect chain to see
|
| + // what happened).
|
| + ds->appendRedirect(ds->request().url());
|
|
|
| - if (webframe_->client())
|
| - webframe_->client()->didReceiveServerRedirectForProvisionalLoad(webframe_);
|
| + if (m_webFrame->client())
|
| + m_webFrame->client()->didReceiveServerRedirectForProvisionalLoad(m_webFrame);
|
| }
|
|
|
| // Called on both success and failure of a client redirect.
|
| -void WebFrameLoaderClient::dispatchDidCancelClientRedirect() {
|
| - // No longer expecting a client redirect.
|
| - if (webframe_->client()) {
|
| - expected_client_redirect_src_ = KURL();
|
| - expected_client_redirect_dest_ = KURL();
|
| - webframe_->client()->didCancelClientRedirect(webframe_);
|
| - }
|
| +void FrameLoaderClientImpl::dispatchDidCancelClientRedirect()
|
| +{
|
| + // No longer expecting a client redirect.
|
| + if (m_webFrame->client()) {
|
| + m_expectedClientRedirectSrc = KURL();
|
| + m_expectedClientRedirectDest = KURL();
|
| + m_webFrame->client()->didCancelClientRedirect(m_webFrame);
|
| + }
|
|
|
| - // No need to clear the redirect chain, since that data source has already
|
| - // been deleted by the time this function is called.
|
| + // No need to clear the redirect chain, since that data source has already
|
| + // been deleted by the time this function is called.
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchWillPerformClientRedirect(
|
| +void FrameLoaderClientImpl::dispatchWillPerformClientRedirect(
|
| const KURL& url,
|
| double interval,
|
| - double fire_date) {
|
| - // Tells dispatchDidStartProvisionalLoad that if it sees this item it is a
|
| - // redirect and the source item should be added as the start of the chain.
|
| - expected_client_redirect_src_ = webkit_glue::WebURLToKURL(webframe_->url());
|
| - expected_client_redirect_dest_ = url;
|
| + double fireDate)
|
| +{
|
| + // Tells dispatchDidStartProvisionalLoad that if it sees this item it is a
|
| + // redirect and the source item should be added as the start of the chain.
|
| + m_expectedClientRedirectSrc = m_webFrame->url();
|
| + m_expectedClientRedirectDest = url;
|
|
|
| - // TODO(timsteele): bug 1135512. Webkit does not properly notify us of
|
| - // cancelling http > file client redirects. Since the FrameLoader's policy
|
| - // is to never carry out such a navigation anyway, the best thing we can do
|
| - // for now to not get confused is ignore this notification.
|
| - if (expected_client_redirect_dest_.isLocalFile() &&
|
| - expected_client_redirect_src_.protocolInHTTPFamily()) {
|
| - expected_client_redirect_src_ = KURL();
|
| - expected_client_redirect_dest_ = KURL();
|
| - return;
|
| - }
|
| + // FIXME: bug 1135512. Webkit does not properly notify us of cancelling
|
| + // http > file client redirects. Since the FrameLoader's policy is to never
|
| + // carry out such a navigation anyway, the best thing we can do for now to
|
| + // not get confused is ignore this notification.
|
| + if (m_expectedClientRedirectDest.isLocalFile()
|
| + && m_expectedClientRedirectSrc.protocolInHTTPFamily()) {
|
| + m_expectedClientRedirectSrc = KURL();
|
| + m_expectedClientRedirectDest = KURL();
|
| + return;
|
| + }
|
|
|
| - if (webframe_->client()) {
|
| - webframe_->client()->willPerformClientRedirect(
|
| - webframe_,
|
| - webkit_glue::KURLToWebURL(expected_client_redirect_src_),
|
| - webkit_glue::KURLToWebURL(expected_client_redirect_dest_),
|
| - static_cast<unsigned int>(interval),
|
| - static_cast<unsigned int>(fire_date));
|
| - }
|
| + if (m_webFrame->client()) {
|
| + m_webFrame->client()->willPerformClientRedirect(
|
| + m_webFrame,
|
| + m_expectedClientRedirectSrc,
|
| + m_expectedClientRedirectDest,
|
| + static_cast<unsigned int>(interval),
|
| + static_cast<unsigned int>(fireDate));
|
| + }
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchDidChangeLocationWithinPage() {
|
| - // Anchor fragment navigations are not normal loads, so we need to synthesize
|
| - // some events for our delegate.
|
| - WebViewImpl* webview = webframe_->GetWebViewImpl();
|
| - if (webview->client())
|
| - webview->client()->didStartLoading();
|
| +void FrameLoaderClientImpl::dispatchDidChangeLocationWithinPage()
|
| +{
|
| + // Anchor fragment navigations are not normal loads, so we need to synthesize
|
| + // some events for our delegate.
|
| + WebViewImpl* webView = m_webFrame->viewImpl();
|
| + if (webView->client())
|
| + webView->client()->didStartLoading();
|
|
|
| - WebDataSourceImpl* ds = webframe_->GetDataSourceImpl();
|
| - ASSERT(ds); // Should not be null when navigating to a reference fragment!
|
| - if (ds) {
|
| - KURL url = webkit_glue::WebURLToKURL(ds->request().url());
|
| - KURL chain_end = ds->endOfRedirectChain();
|
| - ds->clearRedirectChain();
|
| + WebDataSourceImpl* ds = m_webFrame->dataSourceImpl();
|
| + ASSERT(ds); // Should not be null when navigating to a reference fragment!
|
| + if (ds) {
|
| + KURL url = ds->request().url();
|
| + KURL chainEnd;
|
| + if (ds->hasRedirectChain()) {
|
| + chainEnd = ds->endOfRedirectChain();
|
| + ds->clearRedirectChain();
|
| + }
|
|
|
| - // Figure out if this location change is because of a JS-initiated client
|
| - // redirect (e.g onload/setTimeout document.location.href=).
|
| - // TODO(timsteele): (bugs 1085325, 1046841) We don't get proper redirect
|
| - // performed/cancelled notifications across anchor navigations, so the
|
| - // other redirect-tracking code in this class (see dispatch*ClientRedirect()
|
| - // and dispatchDidStartProvisionalLoad) is insufficient to catch and
|
| - // properly flag these transitions. Once a proper fix for this bug is
|
| - // identified and applied the following block may no longer be required.
|
| - bool was_client_redirect =
|
| - (url == expected_client_redirect_dest_ &&
|
| - chain_end == expected_client_redirect_src_) ||
|
| - !webframe_->isProcessingUserGesture();
|
| + // Figure out if this location change is because of a JS-initiated
|
| + // client redirect (e.g onload/setTimeout document.location.href=).
|
| + // FIXME: (bugs 1085325, 1046841) We don't get proper redirect
|
| + // performed/cancelled notifications across anchor navigations, so the
|
| + // other redirect-tracking code in this class (see
|
| + // dispatch*ClientRedirect() and dispatchDidStartProvisionalLoad) is
|
| + // insufficient to catch and properly flag these transitions. Once a
|
| + // proper fix for this bug is identified and applied the following
|
| + // block may no longer be required.
|
| + bool wasClientRedirect =
|
| + (url == m_expectedClientRedirectDest && chainEnd == m_expectedClientRedirectSrc)
|
| + || !m_webFrame->isProcessingUserGesture();
|
|
|
| - if (was_client_redirect) {
|
| - if (webframe_->client()) {
|
| - webframe_->client()->didCompleteClientRedirect(
|
| - webframe_, webkit_glue::KURLToWebURL(chain_end));
|
| - }
|
| - ds->appendRedirect(chain_end);
|
| - // Make sure we clear the expected redirect since we just effectively
|
| - // completed it.
|
| - expected_client_redirect_src_ = KURL();
|
| - expected_client_redirect_dest_ = KURL();
|
| - }
|
| + if (wasClientRedirect) {
|
| + if (m_webFrame->client())
|
| + m_webFrame->client()->didCompleteClientRedirect(m_webFrame, chainEnd);
|
| + ds->appendRedirect(chainEnd);
|
| + // Make sure we clear the expected redirect since we just effectively
|
| + // completed it.
|
| + m_expectedClientRedirectSrc = KURL();
|
| + m_expectedClientRedirectDest = KURL();
|
| + }
|
|
|
| - // Regardless of how we got here, we are navigating to a URL so we need to
|
| - // add it to the redirect chain.
|
| - ds->appendRedirect(url);
|
| - }
|
| + // Regardless of how we got here, we are navigating to a URL so we need to
|
| + // add it to the redirect chain.
|
| + ds->appendRedirect(url);
|
| + }
|
|
|
| - bool is_new_navigation;
|
| - webview->DidCommitLoad(&is_new_navigation);
|
| - if (webframe_->client()) {
|
| - webframe_->client()->didChangeLocationWithinPage(
|
| - webframe_, is_new_navigation);
|
| - }
|
| + bool isNewNavigation;
|
| + webView->didCommitLoad(&isNewNavigation);
|
| + if (m_webFrame->client())
|
| + m_webFrame->client()->didChangeLocationWithinPage(m_webFrame, isNewNavigation);
|
|
|
| - if (webview->client())
|
| - webview->client()->didStopLoading();
|
| + if (webView->client())
|
| + webView->client()->didStopLoading();
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchWillClose() {
|
| - if (webframe_->client())
|
| - webframe_->client()->willClose(webframe_);
|
| +void FrameLoaderClientImpl::dispatchWillClose()
|
| +{
|
| + if (m_webFrame->client())
|
| + m_webFrame->client()->willClose(m_webFrame);
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchDidReceiveIcon() {
|
| - // The icon database is disabled, so this should never be called.
|
| - ASSERT_NOT_REACHED();
|
| +void FrameLoaderClientImpl::dispatchDidReceiveIcon()
|
| +{
|
| + // The icon database is disabled, so this should never be called.
|
| + ASSERT_NOT_REACHED();
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchDidStartProvisionalLoad() {
|
| - // In case a redirect occurs, we need this to be set so that the redirect
|
| - // handling code can tell where the redirect came from. Server redirects
|
| - // will occur on the provisional load, so we need to keep track of the most
|
| - // recent provisional load URL.
|
| - // See dispatchDidReceiveServerRedirectForProvisionalLoad.
|
| - WebDataSourceImpl* ds = webframe_->GetProvisionalDataSourceImpl();
|
| - if (!ds) {
|
| - ASSERT_NOT_REACHED();
|
| - return;
|
| - }
|
| - KURL url = webkit_glue::WebURLToKURL(ds->request().url());
|
| +void FrameLoaderClientImpl::dispatchDidStartProvisionalLoad() {
|
| + // In case a redirect occurs, we need this to be set so that the redirect
|
| + // handling code can tell where the redirect came from. Server redirects
|
| + // will occur on the provisional load, so we need to keep track of the most
|
| + // recent provisional load URL.
|
| + // See dispatchDidReceiveServerRedirectForProvisionalLoad.
|
| + WebDataSourceImpl* ds = m_webFrame->provisionalDataSourceImpl();
|
| + if (!ds) {
|
| + ASSERT_NOT_REACHED();
|
| + return;
|
| + }
|
| + KURL url = ds->request().url();
|
|
|
| - // Since the provisional load just started, we should have not gotten
|
| - // any redirects yet.
|
| - ASSERT(!ds->hasRedirectChain());
|
| + // Since the provisional load just started, we should have not gotten
|
| + // any redirects yet.
|
| + ASSERT(!ds->hasRedirectChain());
|
|
|
| - // If this load is what we expected from a client redirect, treat it as a
|
| - // redirect from that original page. The expected redirect urls will be
|
| - // cleared by DidCancelClientRedirect.
|
| - bool completing_client_redirect = false;
|
| - if (expected_client_redirect_src_.isValid()) {
|
| - // expected_client_redirect_dest_ could be something like
|
| - // "javascript:history.go(-1)" thus we need to exclude url starts with
|
| - // "javascript:". See bug: 1080873
|
| - ASSERT(expected_client_redirect_dest_.protocolIs("javascript") ||
|
| - expected_client_redirect_dest_ == url);
|
| - ds->appendRedirect(expected_client_redirect_src_);
|
| - completing_client_redirect = true;
|
| - }
|
| - ds->appendRedirect(url);
|
| + // If this load is what we expected from a client redirect, treat it as a
|
| + // redirect from that original page. The expected redirect urls will be
|
| + // cleared by DidCancelClientRedirect.
|
| + bool completingClientRedirect = false;
|
| + if (m_expectedClientRedirectSrc.isValid()) {
|
| + // m_expectedClientRedirectDest could be something like
|
| + // "javascript:history.go(-1)" thus we need to exclude url starts with
|
| + // "javascript:". See bug: 1080873
|
| + ASSERT(m_expectedClientRedirectDest.protocolIs("javascript")
|
| + || m_expectedClientRedirectDest == url);
|
| + ds->appendRedirect(m_expectedClientRedirectSrc);
|
| + completingClientRedirect = true;
|
| + }
|
| + ds->appendRedirect(url);
|
|
|
| - if (webframe_->client()) {
|
| - // As the comment for DidCompleteClientRedirect in webview_delegate.h
|
| - // points out, whatever information its invocation contains should only
|
| - // be considered relevant until the next provisional load has started.
|
| - // So we first tell the delegate that the load started, and then tell it
|
| - // about the client redirect the load is responsible for completing.
|
| - webframe_->client()->didStartProvisionalLoad(webframe_);
|
| - if (completing_client_redirect)
|
| - webframe_->client()->didCompleteClientRedirect(
|
| - webframe_, webkit_glue::KURLToWebURL(expected_client_redirect_src_));
|
| - }
|
| + if (m_webFrame->client()) {
|
| + // Whatever information didCompleteClientRedirect contains should only
|
| + // be considered relevant until the next provisional load has started.
|
| + // So we first tell the client that the load started, and then tell it
|
| + // about the client redirect the load is responsible for completing.
|
| + m_webFrame->client()->didStartProvisionalLoad(m_webFrame);
|
| + if (completingClientRedirect) {
|
| + m_webFrame->client()->didCompleteClientRedirect(
|
| + m_webFrame, m_expectedClientRedirectSrc);
|
| + }
|
| + }
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchDidReceiveTitle(const String& title) {
|
| - if (webframe_->client()) {
|
| - webframe_->client()->didReceiveTitle(
|
| - webframe_, webkit_glue::StringToWebString(title));
|
| - }
|
| +void FrameLoaderClientImpl::dispatchDidReceiveTitle(const String& title)
|
| +{
|
| + if (m_webFrame->client())
|
| + m_webFrame->client()->didReceiveTitle(m_webFrame, title);
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchDidCommitLoad() {
|
| - WebViewImpl* webview = webframe_->GetWebViewImpl();
|
| - bool is_new_navigation;
|
| - webview->DidCommitLoad(&is_new_navigation);
|
| +void FrameLoaderClientImpl::dispatchDidCommitLoad()
|
| +{
|
| + WebViewImpl* webview = m_webFrame->viewImpl();
|
| + bool isNewNavigation;
|
| + webview->didCommitLoad(&isNewNavigation);
|
|
|
| - if (webframe_->client()) {
|
| - webframe_->client()->didCommitProvisionalLoad(
|
| - webframe_, is_new_navigation);
|
| - }
|
| + if (m_webFrame->client())
|
| + m_webFrame->client()->didCommitProvisionalLoad(m_webFrame, isNewNavigation);
|
|
|
| - WebDevToolsAgentImpl* tools_agent = webview->GetWebDevToolsAgentImpl();
|
| - if (tools_agent) {
|
| - tools_agent->DidCommitLoadForFrame(webview, webframe_, is_new_navigation);
|
| - }
|
| + WebDevToolsAgentImpl* toolsAgent = webview->devToolsAgentImpl();
|
| + if (toolsAgent)
|
| + toolsAgent->DidCommitLoadForFrame(webview, m_webFrame, isNewNavigation);
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchDidFailProvisionalLoad(
|
| - const ResourceError& error) {
|
| - // If a policy change occured, then we do not want to inform the plugin
|
| - // delegate. See bug 907789 for details.
|
| - // TODO(darin): This means the plugin won't receive NPP_URLNotify, which
|
| - // seems like it could result in a memory leak in the plugin!!
|
| - if (error.domain() == kInternalErrorDomain &&
|
| - error.errorCode() == ERR_POLICY_CHANGE) {
|
| - webframe_->DidFail(cancelledError(error.failingURL()), true);
|
| - return;
|
| - }
|
| +void FrameLoaderClientImpl::dispatchDidFailProvisionalLoad(
|
| + const ResourceError& error)
|
| +{
|
|
|
| - OwnPtr<WebPluginLoadObserver> plugin_load_observer = GetPluginLoadObserver();
|
| - webframe_->DidFail(error, true);
|
| - if (plugin_load_observer)
|
| - plugin_load_observer->didFailLoading(error);
|
| + // If a policy change occured, then we do not want to inform the plugin
|
| + // delegate. See http://b/907789 for details. FIXME: This means the
|
| + // plugin won't receive NPP_URLNotify, which seems like it could result in
|
| + // a memory leak in the plugin!!
|
| + if (error.domain() == internalErrorDomain
|
| + && error.errorCode() == PolicyChangeError) {
|
| + m_webFrame->didFail(cancelledError(error.failingURL()), true);
|
| + return;
|
| + }
|
| +
|
| + OwnPtr<WebPluginLoadObserver> observer = pluginLoadObserver();
|
| + m_webFrame->didFail(error, true);
|
| + if (observer)
|
| + observer->didFailLoading(error);
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchDidFailLoad(const ResourceError& error) {
|
| - OwnPtr<WebPluginLoadObserver> plugin_load_observer = GetPluginLoadObserver();
|
| - webframe_->DidFail(error, false);
|
| - if (plugin_load_observer)
|
| - plugin_load_observer->didFailLoading(error);
|
| +void FrameLoaderClientImpl::dispatchDidFailLoad(const ResourceError& error)
|
| +{
|
| + OwnPtr<WebPluginLoadObserver> observer = pluginLoadObserver();
|
| + m_webFrame->didFail(error, false);
|
| + if (observer)
|
| + observer->didFailLoading(error);
|
|
|
| - // Don't clear the redirect chain, this will happen in the middle of client
|
| - // redirects, and we need the context. The chain will be cleared when the
|
| - // provisional load succeeds or fails, not the "real" one.
|
| + // Don't clear the redirect chain, this will happen in the middle of client
|
| + // redirects, and we need the context. The chain will be cleared when the
|
| + // provisional load succeeds or fails, not the "real" one.
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchDidFinishLoad() {
|
| - OwnPtr<WebPluginLoadObserver> plugin_load_observer = GetPluginLoadObserver();
|
| +void FrameLoaderClientImpl::dispatchDidFinishLoad()
|
| +{
|
| + OwnPtr<WebPluginLoadObserver> observer = pluginLoadObserver();
|
|
|
| - if (webframe_->client())
|
| - webframe_->client()->didFinishLoad(webframe_);
|
| + if (m_webFrame->client())
|
| + m_webFrame->client()->didFinishLoad(m_webFrame);
|
|
|
| - if (plugin_load_observer)
|
| - plugin_load_observer->didFinishLoading();
|
| + if (observer)
|
| + observer->didFinishLoading();
|
|
|
| - // Don't clear the redirect chain, this will happen in the middle of client
|
| - // redirects, and we need the context. The chain will be cleared when the
|
| - // provisional load succeeds or fails, not the "real" one.
|
| + // Don't clear the redirect chain, this will happen in the middle of client
|
| + // redirects, and we need the context. The chain will be cleared when the
|
| + // provisional load succeeds or fails, not the "real" one.
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchDidFirstLayout() {
|
| +void FrameLoaderClientImpl::dispatchDidFirstLayout()
|
| +{
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchDidFirstVisuallyNonEmptyLayout() {
|
| +void FrameLoaderClientImpl::dispatchDidFirstVisuallyNonEmptyLayout()
|
| +{
|
| // FIXME: called when webkit finished layout of a page that was visually
|
| // non-empty.
|
| // All resources have not necessarily finished loading.
|
| }
|
|
|
| -Frame* WebFrameLoaderClient::dispatchCreatePage() {
|
| - struct WebCore::WindowFeatures features;
|
| - Page* new_page = webframe_->frame()->page()->chrome()->createWindow(
|
| - webframe_->frame(), FrameLoadRequest(), features);
|
| +Frame* FrameLoaderClientImpl::dispatchCreatePage()
|
| +{
|
| + struct WindowFeatures features;
|
| + Page* newPage = m_webFrame->frame()->page()->chrome()->createWindow(
|
| + m_webFrame->frame(), FrameLoadRequest(), features);
|
|
|
| - // Make sure that we have a valid disposition. This should have been set in
|
| - // the preceeding call to dispatchDecidePolicyForNewWindowAction.
|
| - ASSERT(next_navigation_policy_ != WebKit::WebNavigationPolicyIgnore);
|
| - WebNavigationPolicy policy = next_navigation_policy_;
|
| - next_navigation_policy_ = WebKit::WebNavigationPolicyIgnore;
|
| + // Make sure that we have a valid disposition. This should have been set in
|
| + // the preceeding call to dispatchDecidePolicyForNewWindowAction.
|
| + ASSERT(m_nextNavigationPolicy != WebNavigationPolicyIgnore);
|
| + WebNavigationPolicy policy = m_nextNavigationPolicy;
|
| + m_nextNavigationPolicy = WebNavigationPolicyIgnore;
|
|
|
| - // createWindow can return NULL (e.g., popup blocker denies the window).
|
| - if (!new_page)
|
| - return NULL;
|
| + // createWindow can return null (e.g., popup blocker denies the window).
|
| + if (!newPage)
|
| + return 0;
|
|
|
| - WebViewImpl::FromPage(new_page)->set_initial_navigation_policy(policy);
|
| - return new_page->mainFrame();
|
| + WebViewImpl::fromPage(newPage)->setInitialNavigationPolicy(policy);
|
| + return newPage->mainFrame();
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchShow() {
|
| - WebViewImpl* webview = webframe_->GetWebViewImpl();
|
| - if (webview && webview->client())
|
| - webview->client()->show(webview->initial_navigation_policy());
|
| +void FrameLoaderClientImpl::dispatchShow()
|
| +{
|
| + WebViewImpl* webView = m_webFrame->viewImpl();
|
| + if (webView && webView->client())
|
| + webView->client()->show(webView->initialNavigationPolicy());
|
| }
|
|
|
| -static bool TreatAsAttachment(const ResourceResponse& response) {
|
| - const String& content_disposition =
|
| - response.httpHeaderField("Content-Disposition");
|
| - if (content_disposition.isEmpty())
|
| - return false;
|
| +static bool shouldTreatAsAttachment(const ResourceResponse& response)
|
| +{
|
| + const String& contentDisposition =
|
| + response.httpHeaderField("Content-Disposition");
|
| + if (contentDisposition.isEmpty())
|
| + return false;
|
|
|
| - // Some broken sites just send
|
| - // Content-Disposition: ; filename="file"
|
| - // screen those out here.
|
| - if (content_disposition.startsWith(";"))
|
| - return false;
|
| + // Some broken sites just send
|
| + // Content-Disposition: ; filename="file"
|
| + // screen those out here.
|
| + if (contentDisposition.startsWith(";"))
|
| + return false;
|
|
|
| - if (content_disposition.startsWith("inline", false))
|
| - return false;
|
| + if (contentDisposition.startsWith("inline", false))
|
| + return false;
|
|
|
| - // Some broken sites just send
|
| - // Content-Disposition: filename="file"
|
| - // without a disposition token... screen those out.
|
| - if (content_disposition.startsWith("filename", false))
|
| - return false;
|
| + // Some broken sites just send
|
| + // Content-Disposition: filename="file"
|
| + // without a disposition token... screen those out.
|
| + if (contentDisposition.startsWith("filename", false))
|
| + return false;
|
|
|
| - // Also in use is Content-Disposition: name="file"
|
| - if (content_disposition.startsWith("name", false))
|
| - return false;
|
| + // Also in use is Content-Disposition: name="file"
|
| + if (contentDisposition.startsWith("name", false))
|
| + return false;
|
|
|
| - // We have a content-disposition of "attachment" or unknown.
|
| - // RFC 2183, section 2.8 says that an unknown disposition
|
| - // value should be treated as "attachment"
|
| - return true;
|
| + // We have a content-disposition of "attachment" or unknown.
|
| + // RFC 2183, section 2.8 says that an unknown disposition
|
| + // value should be treated as "attachment"
|
| + return true;
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchDecidePolicyForMIMEType(
|
| +void FrameLoaderClientImpl::dispatchDecidePolicyForMIMEType(
|
| FramePolicyFunction function,
|
| - const String& mime_type,
|
| - const ResourceRequest&) {
|
| - const ResourceResponse& response =
|
| - webframe_->frame()->loader()->activeDocumentLoader()->response();
|
| + const String& mimeType,
|
| + const ResourceRequest&)
|
| +{
|
| + const ResourceResponse& response =
|
| + m_webFrame->frame()->loader()->activeDocumentLoader()->response();
|
|
|
| - PolicyAction action;
|
| + PolicyAction action;
|
|
|
| - int status_code = response.httpStatusCode();
|
| - if (status_code == 204 || status_code == 205) {
|
| - // The server does not want us to replace the page contents.
|
| - action = PolicyIgnore;
|
| - } else if (TreatAsAttachment(response)) {
|
| - // The server wants us to download instead of replacing the page contents.
|
| - // Downloading is handled by the embedder, but we still get the initial
|
| - // response so that we can ignore it and clean up properly.
|
| - action = PolicyIgnore;
|
| - } else if (!canShowMIMEType(mime_type)) {
|
| - // Make sure that we can actually handle this type internally.
|
| - action = PolicyIgnore;
|
| - } else {
|
| - // OK, we will render this page.
|
| - action = PolicyUse;
|
| - }
|
| + int statusCode = response.httpStatusCode();
|
| + if (statusCode == 204 || statusCode == 205) {
|
| + // The server does not want us to replace the page contents.
|
| + action = PolicyIgnore;
|
| + } else if (shouldTreatAsAttachment(response)) {
|
| + // The server wants us to download instead of replacing the page contents.
|
| + // Downloading is handled by the embedder, but we still get the initial
|
| + // response so that we can ignore it and clean up properly.
|
| + action = PolicyIgnore;
|
| + } else if (!canShowMIMEType(mimeType)) {
|
| + // Make sure that we can actually handle this type internally.
|
| + action = PolicyIgnore;
|
| + } else {
|
| + // OK, we will render this page.
|
| + action = PolicyUse;
|
| + }
|
|
|
| - // NOTE: ERR_POLICY_CHANGE will be generated when action is not PolicyUse.
|
| - (webframe_->frame()->loader()->policyChecker()->*function)(action);
|
| + // NOTE: PolicyChangeError will be generated when action is not PolicyUse.
|
| + (m_webFrame->frame()->loader()->policyChecker()->*function)(action);
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchDecidePolicyForNewWindowAction(
|
| - WebCore::FramePolicyFunction function,
|
| - const WebCore::NavigationAction& action,
|
| - const WebCore::ResourceRequest& request,
|
| - PassRefPtr<WebCore::FormState> form_state,
|
| - const WebCore::String& frame_name) {
|
| - WebNavigationPolicy navigation_policy;
|
| - if (!ActionSpecifiesNavigationPolicy(action, &navigation_policy))
|
| - navigation_policy = WebKit::WebNavigationPolicyNewForegroundTab;
|
| +void FrameLoaderClientImpl::dispatchDecidePolicyForNewWindowAction(
|
| + FramePolicyFunction function,
|
| + const NavigationAction& action,
|
| + const ResourceRequest& request,
|
| + PassRefPtr<FormState> formState,
|
| + const String& frameName)
|
| +{
|
| + WebNavigationPolicy navigationPolicy;
|
| + if (!actionSpecifiesNavigationPolicy(action, &navigationPolicy))
|
| + navigationPolicy = WebNavigationPolicyNewForegroundTab;
|
|
|
| - PolicyAction policy_action;
|
| - if (navigation_policy == WebKit::WebNavigationPolicyDownload) {
|
| - policy_action = PolicyDownload;
|
| - } else {
|
| - policy_action = PolicyUse;
|
| + PolicyAction policyAction;
|
| + if (navigationPolicy == WebNavigationPolicyDownload)
|
| + policyAction = PolicyDownload;
|
| + else {
|
| + policyAction = PolicyUse;
|
|
|
| - // Remember the disposition for when dispatchCreatePage is called. It is
|
| - // unfortunate that WebCore does not provide us with any context when
|
| - // creating or showing the new window that would allow us to avoid having
|
| - // to keep this state.
|
| - next_navigation_policy_ = navigation_policy;
|
| - }
|
| - (webframe_->frame()->loader()->policyChecker()->*function)(policy_action);
|
| + // Remember the disposition for when dispatchCreatePage is called. It is
|
| + // unfortunate that WebCore does not provide us with any context when
|
| + // creating or showing the new window that would allow us to avoid having
|
| + // to keep this state.
|
| + m_nextNavigationPolicy = navigationPolicy;
|
| + }
|
| + (m_webFrame->frame()->loader()->policyChecker()->*function)(policyAction);
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchDecidePolicyForNavigationAction(
|
| - WebCore::FramePolicyFunction function,
|
| - const WebCore::NavigationAction& action,
|
| - const WebCore::ResourceRequest& request,
|
| - PassRefPtr<WebCore::FormState> form_state) {
|
| - PolicyAction policy_action = PolicyIgnore;
|
| +void FrameLoaderClientImpl::dispatchDecidePolicyForNavigationAction(
|
| + FramePolicyFunction function,
|
| + const NavigationAction& action,
|
| + const ResourceRequest& request,
|
| + PassRefPtr<FormState> formState) {
|
| + PolicyAction policyAction = PolicyIgnore;
|
|
|
| - // It is valid for this function to be invoked in code paths where the
|
| - // the webview is closed.
|
| - // The NULL check here is to fix a crash that seems strange
|
| - // (see - https://bugs.webkit.org/show_bug.cgi?id=23554).
|
| - if (webframe_->client() && !request.url().isNull()) {
|
| - WebNavigationPolicy navigation_policy =
|
| - WebKit::WebNavigationPolicyCurrentTab;
|
| - ActionSpecifiesNavigationPolicy(action, &navigation_policy);
|
| + // It is valid for this function to be invoked in code paths where the
|
| + // the webview is closed.
|
| + // The null check here is to fix a crash that seems strange
|
| + // (see - https://bugs.webkit.org/show_bug.cgi?id=23554).
|
| + if (m_webFrame->client() && !request.url().isNull()) {
|
| + WebNavigationPolicy navigationPolicy = WebNavigationPolicyCurrentTab;
|
| + actionSpecifiesNavigationPolicy(action, &navigationPolicy);
|
|
|
| - // Give the delegate a chance to change the navigation policy.
|
| - const WebDataSourceImpl* ds = webframe_->GetProvisionalDataSourceImpl();
|
| - if (ds) {
|
| - KURL url = webkit_glue::WebURLToKURL(ds->request().url());
|
| - if (url.protocolIs(WebKit::backForwardNavigationScheme)) {
|
| - HandleBackForwardNavigation(url);
|
| - navigation_policy = WebKit::WebNavigationPolicyIgnore;
|
| - } else {
|
| - bool is_redirect = ds->hasRedirectChain();
|
| + // Give the delegate a chance to change the navigation policy.
|
| + const WebDataSourceImpl* ds = m_webFrame->provisionalDataSourceImpl();
|
| + if (ds) {
|
| + KURL url = ds->request().url();
|
| + if (url.protocolIs(backForwardNavigationScheme)) {
|
| + handleBackForwardNavigation(url);
|
| + navigationPolicy = WebNavigationPolicyIgnore;
|
| + } else {
|
| + bool isRedirect = ds->hasRedirectChain();
|
|
|
| - WebNavigationType webnav_type =
|
| - WebDataSourceImpl::toWebNavigationType(action.type());
|
| + WebNavigationType webnavType =
|
| + WebDataSourceImpl::toWebNavigationType(action.type());
|
|
|
| - RefPtr<WebCore::Node> node;
|
| - for (const Event* event = action.event(); event;
|
| - event = event->underlyingEvent()) {
|
| - if (event->isMouseEvent()) {
|
| - const MouseEvent* mouse_event =
|
| - static_cast<const MouseEvent*>(event);
|
| - node = webframe_->frame()->eventHandler()->hitTestResultAtPoint(
|
| - mouse_event->absoluteLocation(), false).innerNonSharedNode();
|
| - break;
|
| + RefPtr<Node> node;
|
| + for (const Event* event = action.event(); event; event = event->underlyingEvent()) {
|
| + if (event->isMouseEvent()) {
|
| + const MouseEvent* mouseEvent =
|
| + static_cast<const MouseEvent*>(event);
|
| + node = m_webFrame->frame()->eventHandler()->hitTestResultAtPoint(
|
| + mouseEvent->absoluteLocation(), false).innerNonSharedNode();
|
| + break;
|
| + }
|
| + }
|
| + WebNode originatingNode(node);
|
| +
|
| + navigationPolicy = m_webFrame->client()->decidePolicyForNavigation(
|
| + m_webFrame, ds->request(), webnavType, originatingNode,
|
| + navigationPolicy, isRedirect);
|
| }
|
| - }
|
| - WebNode originating_node = webkit_glue::NodeToWebNode(node);
|
| -
|
| - navigation_policy = webframe_->client()->decidePolicyForNavigation(
|
| - webframe_, ds->request(), webnav_type, originating_node,
|
| - navigation_policy, is_redirect);
|
| }
|
| - }
|
|
|
| - if (navigation_policy == WebKit::WebNavigationPolicyCurrentTab) {
|
| - policy_action = PolicyUse;
|
| - } else if (navigation_policy == WebKit::WebNavigationPolicyDownload) {
|
| - policy_action = PolicyDownload;
|
| - } else {
|
| - if (navigation_policy != WebKit::WebNavigationPolicyIgnore) {
|
| - WrappedResourceRequest webreq(request);
|
| - webframe_->client()->loadURLExternally(
|
| - webframe_, webreq, navigation_policy);
|
| + if (navigationPolicy == WebNavigationPolicyCurrentTab)
|
| + policyAction = PolicyUse;
|
| + else if (navigationPolicy == WebNavigationPolicyDownload)
|
| + policyAction = PolicyDownload;
|
| + else {
|
| + if (navigationPolicy != WebNavigationPolicyIgnore) {
|
| + WrappedResourceRequest webreq(request);
|
| + m_webFrame->client()->loadURLExternally(m_webFrame, webreq, navigationPolicy);
|
| + }
|
| + policyAction = PolicyIgnore;
|
| }
|
| - policy_action = PolicyIgnore;
|
| }
|
| - }
|
|
|
| - (webframe_->frame()->loader()->policyChecker()->*function)(policy_action);
|
| + (m_webFrame->frame()->loader()->policyChecker()->*function)(policyAction);
|
| }
|
|
|
| -void WebFrameLoaderClient::cancelPolicyCheck() {
|
| - // FIXME
|
| +void FrameLoaderClientImpl::cancelPolicyCheck()
|
| +{
|
| + // FIXME
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchUnableToImplementPolicy(
|
| - const ResourceError& error) {
|
| - WebKit::WebURLError url_error =
|
| - webkit_glue::ResourceErrorToWebURLError(error);
|
| - webframe_->client()->unableToImplementPolicyWithError(webframe_, url_error);
|
| +void FrameLoaderClientImpl::dispatchUnableToImplementPolicy(const ResourceError& error)
|
| +{
|
| + m_webFrame->client()->unableToImplementPolicyWithError(m_webFrame, error);
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchWillSubmitForm(FramePolicyFunction function,
|
| - PassRefPtr<FormState> form_ref) {
|
| - if (webframe_->client()) {
|
| - webframe_->client()->willSubmitForm(
|
| - webframe_, webkit_glue::HTMLFormElementToWebForm(form_ref->form()));
|
| - }
|
| - (webframe_->frame()->loader()->policyChecker()->*function)(PolicyUse);
|
| +void FrameLoaderClientImpl::dispatchWillSubmitForm(FramePolicyFunction function,
|
| + PassRefPtr<FormState> formState)
|
| +{
|
| + if (m_webFrame->client())
|
| + m_webFrame->client()->willSubmitForm(m_webFrame, WebForm(formState->form()));
|
| + (m_webFrame->frame()->loader()->policyChecker()->*function)(PolicyUse);
|
| }
|
|
|
| -void WebFrameLoaderClient::dispatchDidLoadMainResource(DocumentLoader*) {
|
| - // FIXME
|
| +void FrameLoaderClientImpl::dispatchDidLoadMainResource(DocumentLoader*)
|
| +{
|
| + // FIXME
|
| }
|
|
|
| -void WebFrameLoaderClient::revertToProvisionalState(DocumentLoader*) {
|
| - has_representation_ = true;
|
| +void FrameLoaderClientImpl::revertToProvisionalState(DocumentLoader*)
|
| +{
|
| + m_hasRepresentation = true;
|
| }
|
|
|
| -void WebFrameLoaderClient::setMainDocumentError(DocumentLoader*,
|
| - const ResourceError& error) {
|
| - if (plugin_widget_.get()) {
|
| - if (sent_initial_response_to_plugin_) {
|
| - plugin_widget_->didFailLoading(error);
|
| - sent_initial_response_to_plugin_ = false;
|
| +void FrameLoaderClientImpl::setMainDocumentError(DocumentLoader*,
|
| + const ResourceError& error)
|
| +{
|
| + if (m_pluginWidget.get()) {
|
| + if (m_sentInitialResponseToPlugin) {
|
| + m_pluginWidget->didFailLoading(error);
|
| + m_sentInitialResponseToPlugin = false;
|
| + }
|
| + m_pluginWidget = 0;
|
| }
|
| - plugin_widget_ = NULL;
|
| - }
|
| }
|
|
|
| -void WebFrameLoaderClient::postProgressStartedNotification() {
|
| - WebViewImpl* webview = webframe_->GetWebViewImpl();
|
| - if (webview && webview->client())
|
| - webview->client()->didStartLoading();
|
| +void FrameLoaderClientImpl::postProgressStartedNotification()
|
| +{
|
| + WebViewImpl* webview = m_webFrame->viewImpl();
|
| + if (webview && webview->client())
|
| + webview->client()->didStartLoading();
|
| }
|
|
|
| -void WebFrameLoaderClient::postProgressEstimateChangedNotification() {
|
| - // FIXME
|
| +void FrameLoaderClientImpl::postProgressEstimateChangedNotification()
|
| +{
|
| + // FIXME
|
| }
|
|
|
| -void WebFrameLoaderClient::postProgressFinishedNotification() {
|
| - // TODO(ericroman): why might the webview be null?
|
| - // http://b/1234461
|
| - WebViewImpl* webview = webframe_->GetWebViewImpl();
|
| - if (webview && webview->client())
|
| - webview->client()->didStopLoading();
|
| +void FrameLoaderClientImpl::postProgressFinishedNotification()
|
| +{
|
| + // FIXME: why might the webview be null? http://b/1234461
|
| + WebViewImpl* webview = m_webFrame->viewImpl();
|
| + if (webview && webview->client())
|
| + webview->client()->didStopLoading();
|
| }
|
|
|
| -void WebFrameLoaderClient::setMainFrameDocumentReady(bool ready) {
|
| - // FIXME
|
| +void FrameLoaderClientImpl::setMainFrameDocumentReady(bool ready)
|
| +{
|
| + // FIXME
|
| }
|
|
|
| // Creates a new connection and begins downloading from that (contrast this
|
| // with |download|).
|
| -void WebFrameLoaderClient::startDownload(const ResourceRequest& request) {
|
| - if (webframe_->client()) {
|
| - WrappedResourceRequest webreq(request);
|
| - webframe_->client()->loadURLExternally(
|
| - webframe_, webreq, WebKit::WebNavigationPolicyDownload);
|
| - }
|
| +void FrameLoaderClientImpl::startDownload(const ResourceRequest& request)
|
| +{
|
| + if (m_webFrame->client()) {
|
| + WrappedResourceRequest webreq(request);
|
| + m_webFrame->client()->loadURLExternally(
|
| + m_webFrame, webreq, WebNavigationPolicyDownload);
|
| + }
|
| }
|
|
|
| -void WebFrameLoaderClient::willChangeTitle(DocumentLoader*) {
|
| - // FIXME
|
| +void FrameLoaderClientImpl::willChangeTitle(DocumentLoader*)
|
| +{
|
| + // FIXME
|
| }
|
|
|
| -void WebFrameLoaderClient::didChangeTitle(DocumentLoader*) {
|
| - // FIXME
|
| +void FrameLoaderClientImpl::didChangeTitle(DocumentLoader*)
|
| +{
|
| + // FIXME
|
| }
|
|
|
| // Called whenever data is received.
|
| -void WebFrameLoaderClient::committedLoad(DocumentLoader* loader, const char* data, int length) {
|
| - if (!plugin_widget_.get()) {
|
| - if (webframe_->client()) {
|
| - bool preventDefault = false;
|
| - webframe_->client()->didReceiveDocumentData(webframe_, data, length, preventDefault);
|
| - if (!preventDefault)
|
| - webframe_->commitDocumentData(data, length);
|
| +void FrameLoaderClientImpl::committedLoad(DocumentLoader* loader, const char* data, int length) {
|
| + if (!m_pluginWidget.get()) {
|
| + if (m_webFrame->client()) {
|
| + bool preventDefault = false;
|
| + m_webFrame->client()->didReceiveDocumentData(m_webFrame, data, length, preventDefault);
|
| + if (!preventDefault)
|
| + m_webFrame->commitDocumentData(data, length);
|
| + }
|
| }
|
| - }
|
|
|
| - // If we are sending data to WebCore::MediaDocument, we should stop here
|
| - // and cancel the request.
|
| - if (webframe_->frame()->document() &&
|
| - webframe_->frame()->document()->isMediaDocument()) {
|
| - loader->cancelMainResourceLoad(
|
| - pluginWillHandleLoadError(loader->response()));
|
| - }
|
| + // If we are sending data to MediaDocument, we should stop here
|
| + // and cancel the request.
|
| + if (m_webFrame->frame()->document()
|
| + && m_webFrame->frame()->document()->isMediaDocument())
|
| + loader->cancelMainResourceLoad(pluginWillHandleLoadError(loader->response()));
|
|
|
| - // The plugin widget could have been created in the webframe_->DidReceiveData
|
| - // function.
|
| - if (plugin_widget_.get()) {
|
| - if (!sent_initial_response_to_plugin_) {
|
| - sent_initial_response_to_plugin_ = true;
|
| - plugin_widget_->didReceiveResponse(
|
| - webframe_->frame()->loader()->activeDocumentLoader()->response());
|
| + // The plugin widget could have been created in the m_webFrame->DidReceiveData
|
| + // function.
|
| + if (m_pluginWidget.get()) {
|
| + if (!m_sentInitialResponseToPlugin) {
|
| + m_sentInitialResponseToPlugin = true;
|
| + m_pluginWidget->didReceiveResponse(
|
| + m_webFrame->frame()->loader()->activeDocumentLoader()->response());
|
| + }
|
| + m_pluginWidget->didReceiveData(data, length);
|
| }
|
| - plugin_widget_->didReceiveData(data, length);
|
| - }
|
| }
|
|
|
| -void WebFrameLoaderClient::finishedLoading(DocumentLoader* dl) {
|
| - if (plugin_widget_.get()) {
|
| - plugin_widget_->didFinishLoading();
|
| - plugin_widget_ = NULL;
|
| - sent_initial_response_to_plugin_ = false;
|
| - } else {
|
| - // This is necessary to create an empty document. See bug 634004.
|
| - // However, we only want to do this if makeRepresentation has been called, to
|
| - // match the behavior on the Mac.
|
| - if (has_representation_)
|
| - dl->frameLoader()->setEncoding("", false);
|
| - }
|
| +void FrameLoaderClientImpl::finishedLoading(DocumentLoader* dl)
|
| +{
|
| + if (m_pluginWidget.get()) {
|
| + m_pluginWidget->didFinishLoading();
|
| + m_pluginWidget = 0;
|
| + m_sentInitialResponseToPlugin = false;
|
| + } else {
|
| + // This is necessary to create an empty document. See bug 634004.
|
| + // However, we only want to do this if makeRepresentation has been called, to
|
| + // match the behavior on the Mac.
|
| + if (m_hasRepresentation)
|
| + dl->frameLoader()->setEncoding("", false);
|
| + }
|
| }
|
|
|
| -void WebFrameLoaderClient::updateGlobalHistory() {
|
| +void FrameLoaderClientImpl::updateGlobalHistory()
|
| +{
|
| }
|
|
|
| -void WebFrameLoaderClient::updateGlobalHistoryRedirectLinks() {
|
| +void FrameLoaderClientImpl::updateGlobalHistoryRedirectLinks()
|
| +{
|
| }
|
|
|
| -bool WebFrameLoaderClient::shouldGoToHistoryItem(HistoryItem*) const {
|
| - // FIXME
|
| - return true;
|
| +bool FrameLoaderClientImpl::shouldGoToHistoryItem(HistoryItem*) const
|
| +{
|
| + // FIXME
|
| + return true;
|
| }
|
|
|
| -void WebFrameLoaderClient::didDisplayInsecureContent() {
|
| - if (webframe_->client())
|
| - webframe_->client()->didDisplayInsecureContent(webframe_);
|
| +void FrameLoaderClientImpl::didDisplayInsecureContent()
|
| +{
|
| + if (m_webFrame->client())
|
| + m_webFrame->client()->didDisplayInsecureContent(m_webFrame);
|
| }
|
|
|
| -void WebFrameLoaderClient::didRunInsecureContent(SecurityOrigin* origin) {
|
| - if (webframe_->client()) {
|
| - webframe_->client()->didRunInsecureContent(webframe_,
|
| - webkit_glue::SecurityOriginToWebSecurityOrigin(origin));
|
| - }
|
| +void FrameLoaderClientImpl::didRunInsecureContent(SecurityOrigin* origin)
|
| +{
|
| + if (m_webFrame->client())
|
| + m_webFrame->client()->didRunInsecureContent(m_webFrame, WebSecurityOrigin(origin));
|
| }
|
|
|
| -ResourceError WebFrameLoaderClient::blockedError(const WebCore::ResourceRequest&) {
|
| - // FIXME
|
| - return ResourceError();
|
| +ResourceError FrameLoaderClientImpl::blockedError(const ResourceRequest&)
|
| +{
|
| + // FIXME
|
| + return ResourceError();
|
| }
|
|
|
| -ResourceError WebFrameLoaderClient::cancelledError(
|
| - const ResourceRequest& request) {
|
| - if (!webframe_->client())
|
| - return ResourceError();
|
| +ResourceError FrameLoaderClientImpl::cancelledError(const ResourceRequest& request)
|
| +{
|
| + if (!m_webFrame->client())
|
| + return ResourceError();
|
|
|
| - return webkit_glue::WebURLErrorToResourceError(
|
| - webframe_->client()->cancelledError(
|
| - webframe_, WrappedResourceRequest(request)));
|
| + return m_webFrame->client()->cancelledError(
|
| + m_webFrame, WrappedResourceRequest(request));
|
| }
|
|
|
| -ResourceError WebFrameLoaderClient::cannotShowURLError(
|
| - const ResourceRequest& request) {
|
| - if (!webframe_->client())
|
| - return ResourceError();
|
| +ResourceError FrameLoaderClientImpl::cannotShowURLError(const ResourceRequest& request)
|
| +{
|
| + if (!m_webFrame->client())
|
| + return ResourceError();
|
|
|
| - return webkit_glue::WebURLErrorToResourceError(
|
| - webframe_->client()->cannotHandleRequestError(
|
| - webframe_, WrappedResourceRequest(request)));
|
| + return m_webFrame->client()->cannotHandleRequestError(
|
| + m_webFrame, WrappedResourceRequest(request));
|
| }
|
|
|
| -ResourceError WebFrameLoaderClient::interruptForPolicyChangeError(
|
| - const ResourceRequest& request) {
|
| - return ResourceError(kInternalErrorDomain, ERR_POLICY_CHANGE,
|
| - request.url().string(), String());
|
| +ResourceError FrameLoaderClientImpl::interruptForPolicyChangeError(
|
| + const ResourceRequest& request)
|
| +{
|
| + return ResourceError(internalErrorDomain, PolicyChangeError,
|
| + request.url().string(), String());
|
| }
|
|
|
| -ResourceError WebFrameLoaderClient::cannotShowMIMETypeError(const ResourceResponse&) {
|
| - // FIXME
|
| - return ResourceError();
|
| +ResourceError FrameLoaderClientImpl::cannotShowMIMETypeError(const ResourceResponse&)
|
| +{
|
| + // FIXME
|
| + return ResourceError();
|
| }
|
|
|
| -ResourceError WebFrameLoaderClient::fileDoesNotExistError(const ResourceResponse&) {
|
| - // FIXME
|
| - return ResourceError();
|
| +ResourceError FrameLoaderClientImpl::fileDoesNotExistError(const ResourceResponse&)
|
| +{
|
| + // FIXME
|
| + return ResourceError();
|
| }
|
|
|
| -ResourceError WebFrameLoaderClient::pluginWillHandleLoadError(const WebCore::ResourceResponse&) {
|
| - // FIXME
|
| - return ResourceError();
|
| +ResourceError FrameLoaderClientImpl::pluginWillHandleLoadError(const ResourceResponse&)
|
| +{
|
| + // FIXME
|
| + return ResourceError();
|
| }
|
|
|
| -bool WebFrameLoaderClient::shouldFallBack(const ResourceError& error) {
|
| - // This method is called when we fail to load the URL for an <object> tag
|
| - // that has fallback content (child elements) and is being loaded as a frame.
|
| - // The error parameter indicates the reason for the load failure.
|
| - // We should let the fallback content load only if this wasn't a cancelled
|
| - // request.
|
| - // Note: The mac version also has a case for "WebKitErrorPluginWillHandleLoad"
|
| - ResourceError cancelled_error = cancelledError(ResourceRequest());
|
| - return error.errorCode() != cancelled_error.errorCode() ||
|
| - error.domain() != cancelled_error.domain();
|
| +bool FrameLoaderClientImpl::shouldFallBack(const ResourceError& error)
|
| +{
|
| + // This method is called when we fail to load the URL for an <object> tag
|
| + // that has fallback content (child elements) and is being loaded as a frame.
|
| + // The error parameter indicates the reason for the load failure.
|
| + // We should let the fallback content load only if this wasn't a cancelled
|
| + // request.
|
| + // Note: The mac version also has a case for "WebKitErrorPluginWillHandleLoad"
|
| + ResourceError c = cancelledError(ResourceRequest());
|
| + return error.errorCode() != c.errorCode() || error.domain() != c.domain();
|
| }
|
|
|
| -bool WebFrameLoaderClient::canHandleRequest(
|
| - const ResourceRequest& request) const {
|
| - return webframe_->client()->canHandleRequest(
|
| - webframe_, WrappedResourceRequest(request));
|
| +bool FrameLoaderClientImpl::canHandleRequest(const ResourceRequest& request) const
|
| +{
|
| + return m_webFrame->client()->canHandleRequest(
|
| + m_webFrame, WrappedResourceRequest(request));
|
| }
|
|
|
| -bool WebFrameLoaderClient::canShowMIMEType(const String& mime_type) const {
|
| - // This method is called to determine if the media type can be shown
|
| - // "internally" (i.e. inside the browser) regardless of whether or not the
|
| - // browser or a plugin is doing the rendering.
|
| +bool FrameLoaderClientImpl::canShowMIMEType(const String& mimeType) const
|
| +{
|
| + // This method is called to determine if the media type can be shown
|
| + // "internally" (i.e. inside the browser) regardless of whether or not the
|
| + // browser or a plugin is doing the rendering.
|
|
|
| - // mime_type strings are supposed to be ASCII, but if they are not for some
|
| - // reason, then it just means that the mime type will fail all of these "is
|
| - // supported" checks and go down the path of an unhandled mime type.
|
| - if (net::IsSupportedMimeType(
|
| - webkit_glue::CStringToStdString(mime_type.latin1())))
|
| - return true;
|
| + // mimeType strings are supposed to be ASCII, but if they are not for some
|
| + // reason, then it just means that the mime type will fail all of these "is
|
| + // supported" checks and go down the path of an unhandled mime type.
|
| + if (net::IsSupportedMimeType(mimeType.latin1().data()))
|
| + return true;
|
|
|
| - // If Chrome is started with the --disable-plugins switch, pluginData is null.
|
| - WebCore::PluginData* plugin_data = webframe_->frame()->page()->pluginData();
|
| + // If Chrome is started with the --disable-plugins switch, pluginData is null.
|
| + PluginData* pluginData = m_webFrame->frame()->page()->pluginData();
|
|
|
| - // See if the type is handled by an installed plugin, if so, we can show it.
|
| - // TODO(beng): (http://b/1085524) This is the place to stick a preference to
|
| - // disable full page plugins (optionally for certain types!)
|
| - return !mime_type.isEmpty() && plugin_data && plugin_data->supportsMimeType(mime_type);
|
| + // See if the type is handled by an installed plugin, if so, we can show it.
|
| + // FIXME: (http://b/1085524) This is the place to stick a preference to
|
| + // disable full page plugins (optionally for certain types!)
|
| + return !mimeType.isEmpty() && pluginData && pluginData->supportsMimeType(mimeType);
|
| }
|
|
|
| -bool WebFrameLoaderClient::representationExistsForURLScheme(const String& URLScheme) const {
|
| - // FIXME
|
| - return false;
|
| +bool FrameLoaderClientImpl::representationExistsForURLScheme(const String&) const
|
| +{
|
| + // FIXME
|
| + return false;
|
| }
|
|
|
| -String WebFrameLoaderClient::generatedMIMETypeForURLScheme(const String& URLScheme) const {
|
| - // This appears to generate MIME types for protocol handlers that are handled
|
| - // internally. The only place I can find in the WebKit code that uses this
|
| - // function is WebView::registerViewClass, where it is used as part of the
|
| - // process by which custom view classes for certain document representations
|
| - // are registered.
|
| - String mimetype("x-apple-web-kit/");
|
| - mimetype.append(URLScheme.lower());
|
| - return mimetype;
|
| +String FrameLoaderClientImpl::generatedMIMETypeForURLScheme(const String& scheme) const
|
| +{
|
| + // This appears to generate MIME types for protocol handlers that are handled
|
| + // internally. The only place I can find in the WebKit code that uses this
|
| + // function is WebView::registerViewClass, where it is used as part of the
|
| + // process by which custom view classes for certain document representations
|
| + // are registered.
|
| + String mimeType("x-apple-web-kit/");
|
| + mimeType.append(scheme.lower());
|
| + return mimeType;
|
| }
|
|
|
| -void WebFrameLoaderClient::frameLoadCompleted() {
|
| - // FIXME: the mac port also conditionally calls setDrawsBackground:YES on
|
| - // it's ScrollView here.
|
| +void FrameLoaderClientImpl::frameLoadCompleted()
|
| +{
|
| + // FIXME: the mac port also conditionally calls setDrawsBackground:YES on
|
| + // it's ScrollView here.
|
|
|
| - // This comment from the Mac port:
|
| - // Note: Can be called multiple times.
|
| - // Even if already complete, we might have set a previous item on a frame that
|
| - // didn't do any data loading on the past transaction. Make sure to clear these out.
|
| + // This comment from the Mac port:
|
| + // Note: Can be called multiple times.
|
| + // Even if already complete, we might have set a previous item on a frame that
|
| + // didn't do any data loading on the past transaction. Make sure to clear these out.
|
|
|
| - // FIXME: setPreviousHistoryItem() no longer exists. http://crbug.com/8566
|
| - // webframe_->frame()->loader()->setPreviousHistoryItem(0);
|
| + // FIXME: setPreviousHistoryItem() no longer exists. http://crbug.com/8566
|
| + // m_webFrame->frame()->loader()->setPreviousHistoryItem(0);
|
| }
|
|
|
| -void WebFrameLoaderClient::saveViewStateToItem(HistoryItem*) {
|
| - // FIXME
|
| +void FrameLoaderClientImpl::saveViewStateToItem(HistoryItem*)
|
| +{
|
| + // FIXME
|
| }
|
|
|
| -
|
| -void WebFrameLoaderClient::restoreViewState() {
|
| - // FIXME: probably scrolls to last position when you go back or forward
|
| +void FrameLoaderClientImpl::restoreViewState()
|
| +{
|
| + // FIXME: probably scrolls to last position when you go back or forward
|
| }
|
|
|
| -void WebFrameLoaderClient::provisionalLoadStarted() {
|
| - // FIXME: On mac, this does various caching stuff
|
| +void FrameLoaderClientImpl::provisionalLoadStarted()
|
| +{
|
| + // FIXME: On mac, this does various caching stuff
|
| }
|
|
|
| -void WebFrameLoaderClient::didFinishLoad() {
|
| - OwnPtr<WebPluginLoadObserver> plugin_load_observer = GetPluginLoadObserver();
|
| - if (plugin_load_observer)
|
| - plugin_load_observer->didFinishLoading();
|
| +void FrameLoaderClientImpl::didFinishLoad()
|
| +{
|
| + OwnPtr<WebPluginLoadObserver> observer = pluginLoadObserver();
|
| + if (observer)
|
| + observer->didFinishLoading();
|
| }
|
|
|
| -void WebFrameLoaderClient::prepareForDataSourceReplacement() {
|
| - // FIXME
|
| +void FrameLoaderClientImpl::prepareForDataSourceReplacement()
|
| +{
|
| + // FIXME
|
| }
|
|
|
| -PassRefPtr<DocumentLoader> WebFrameLoaderClient::createDocumentLoader(
|
| +PassRefPtr<DocumentLoader> FrameLoaderClientImpl::createDocumentLoader(
|
| const ResourceRequest& request,
|
| - const SubstituteData& data) {
|
| - RefPtr<WebDataSourceImpl> ds = WebDataSourceImpl::create(request, data);
|
| - if (webframe_->client())
|
| - webframe_->client()->didCreateDataSource(webframe_, ds.get());
|
| - return ds.release();
|
| + const SubstituteData& data)
|
| +{
|
| + RefPtr<WebDataSourceImpl> ds = WebDataSourceImpl::create(request, data);
|
| + if (m_webFrame->client())
|
| + m_webFrame->client()->didCreateDataSource(m_webFrame, ds.get());
|
| + return ds.release();
|
| }
|
|
|
| -void WebFrameLoaderClient::setTitle(const String& title, const KURL& url) {
|
| - // FIXME: monitor for changes in WebFrameLoaderClient.mm
|
| - // FIXME: Set the title of the current history item. HistoryItemImpl's setter
|
| - // will notify its clients (e.g. the history database) that the title
|
| - // has changed.
|
| - //
|
| - // e.g.:
|
| - // WebHistoryItem* item =
|
| - // webframe_->GetWebViewImpl()->GetBackForwardList()->GetCurrentItem();
|
| - // WebHistoryItemImpl* item_impl = static_cast<WebHistoryItemImpl*>(item);
|
| - //
|
| - // item_impl->SetTitle(webkit_glue::StringToStdWString(title));
|
| +void FrameLoaderClientImpl::setTitle(const String& title, const KURL& url)
|
| +{
|
| + // FIXME: inform consumer of changes to the title.
|
| }
|
|
|
| -String WebFrameLoaderClient::userAgent(const KURL& url) {
|
| - return webkit_glue::StdStringToString(
|
| - webkit_glue::GetUserAgent(webkit_glue::KURLToGURL(url)));
|
| +String FrameLoaderClientImpl::userAgent(const KURL& url)
|
| +{
|
| + // FIXME: Convert this to a WebKitClient callback.
|
| + return webkit_glue::StdStringToString(
|
| + webkit_glue::GetUserAgent(webkit_glue::KURLToGURL(url)));
|
| }
|
|
|
| -void WebFrameLoaderClient::savePlatformDataToCachedFrame(WebCore::CachedFrame*) {
|
| - // The page cache should be disabled.
|
| - ASSERT_NOT_REACHED();
|
| +void FrameLoaderClientImpl::savePlatformDataToCachedFrame(CachedFrame*)
|
| +{
|
| + // The page cache should be disabled.
|
| + ASSERT_NOT_REACHED();
|
| }
|
|
|
| -void WebFrameLoaderClient::transitionToCommittedFromCachedFrame(WebCore::CachedFrame*) {
|
| - ASSERT_NOT_REACHED();
|
| +void FrameLoaderClientImpl::transitionToCommittedFromCachedFrame(CachedFrame*)
|
| +{
|
| + ASSERT_NOT_REACHED();
|
| }
|
|
|
| // Called when the FrameLoader goes into a state in which a new page load
|
| // will occur.
|
| -void WebFrameLoaderClient::transitionToCommittedForNewPage() {
|
| - makeDocumentView();
|
| +void FrameLoaderClientImpl::transitionToCommittedForNewPage()
|
| +{
|
| + makeDocumentView();
|
| }
|
|
|
| -bool WebFrameLoaderClient::canCachePage() const {
|
| - // Since we manage the cache, always report this page as non-cacheable to
|
| - // FrameLoader.
|
| - return false;
|
| +bool FrameLoaderClientImpl::canCachePage() const
|
| +{
|
| + // Since we manage the cache, always report this page as non-cacheable to
|
| + // FrameLoader.
|
| + return false;
|
| }
|
|
|
| // Downloading is handled in the browser process, not WebKit. If we get to this
|
| // point, our download detection code in the ResourceDispatcherHost is broken!
|
| -void WebFrameLoaderClient::download(ResourceHandle* handle,
|
| - const ResourceRequest& request,
|
| - const ResourceRequest& initialRequest,
|
| - const ResourceResponse& response) {
|
| - ASSERT_NOT_REACHED();
|
| +void FrameLoaderClientImpl::download(ResourceHandle* handle,
|
| + const ResourceRequest& request,
|
| + const ResourceRequest& initialRequest,
|
| + const ResourceResponse& response)
|
| +{
|
| + ASSERT_NOT_REACHED();
|
| }
|
|
|
| -PassRefPtr<Frame> WebFrameLoaderClient::createFrame(
|
| +PassRefPtr<Frame> FrameLoaderClientImpl::createFrame(
|
| const KURL& url,
|
| const String& name,
|
| - HTMLFrameOwnerElement* owner_element,
|
| + HTMLFrameOwnerElement* ownerElement,
|
| const String& referrer,
|
| - bool allows_scrolling,
|
| - int margin_width,
|
| - int margin_height) {
|
| - FrameLoadRequest frame_request(ResourceRequest(url, referrer), name);
|
| - return webframe_->CreateChildFrame(frame_request, owner_element);
|
| + bool allowsScrolling,
|
| + int marginWidth,
|
| + int marginHeight)
|
| +{
|
| + FrameLoadRequest frameRequest(ResourceRequest(url, referrer), name);
|
| + return m_webFrame->createChildFrame(frameRequest, ownerElement);
|
| }
|
|
|
| -PassRefPtr<Widget> WebFrameLoaderClient::createPlugin(
|
| - const IntSize& size, // TODO(erikkay): how do we use this?
|
| +PassRefPtr<Widget> FrameLoaderClientImpl::createPlugin(
|
| + const IntSize& size, // FIXME: how do we use this?
|
| HTMLPlugInElement* element,
|
| const KURL& url,
|
| - const Vector<String>& param_names,
|
| - const Vector<String>& param_values,
|
| - const String& mime_type,
|
| - bool load_manually) {
|
| + const Vector<String>& paramNames,
|
| + const Vector<String>& paramValues,
|
| + const String& mimeType,
|
| + bool loadManually)
|
| +{
|
| #if !PLATFORM(WIN_OS)
|
| - // WebCore asks us to make a plugin even if we don't have a
|
| - // registered handler, with a comment saying it's so we can display
|
| - // the broken plugin icon. In Chromium, we normally register a
|
| - // fallback plugin handler that allows you to install a missing
|
| - // plugin. Since we don't yet have a default plugin handler, we
|
| - // need to return NULL here rather than going through all the
|
| - // plugin-creation IPCs only to discover we don't have a plugin
|
| - // registered, which causes a crash.
|
| - // TODO(evanm): remove me once we have a default plugin.
|
| - if (objectContentType(url, mime_type) != ObjectContentNetscapePlugin)
|
| - return NULL;
|
| + // WebCore asks us to make a plugin even if we don't have a
|
| + // registered handler, with a comment saying it's so we can display
|
| + // the broken plugin icon. In Chromium, we normally register a
|
| + // fallback plugin handler that allows you to install a missing
|
| + // plugin. Since we don't yet have a default plugin handler, we
|
| + // need to return null here rather than going through all the
|
| + // plugin-creation IPCs only to discover we don't have a plugin
|
| + // registered, which causes a crash.
|
| + // FIXME: remove me once we have a default plugin.
|
| + if (objectContentType(url, mimeType) != ObjectContentNetscapePlugin)
|
| + return 0;
|
| #endif
|
|
|
| - if (!webframe_->client())
|
| - return NULL;
|
| + if (!m_webFrame->client())
|
| + return 0;
|
|
|
| - WebPluginParams params;
|
| - params.url = webkit_glue::KURLToWebURL(url);
|
| - params.mimeType = webkit_glue::StringToWebString(mime_type);
|
| - CopyStringVector(param_names, ¶ms.attributeNames);
|
| - CopyStringVector(param_values, ¶ms.attributeValues);
|
| - params.loadManually = load_manually;
|
| + WebPluginParams params;
|
| + params.url = url;
|
| + params.mimeType = mimeType;
|
| + params.attributeNames = paramNames;
|
| + params.attributeValues = paramValues;
|
| + params.loadManually = loadManually;
|
|
|
| - WebPlugin* webplugin = webframe_->client()->createPlugin(webframe_, params);
|
| - if (!webplugin)
|
| - return NULL;
|
| + WebPlugin* webPlugin = m_webFrame->client()->createPlugin(m_webFrame, params);
|
| + if (!webPlugin)
|
| + return 0;
|
|
|
| - // The container takes ownership of the WebPlugin.
|
| - RefPtr<WebPluginContainerImpl> container =
|
| - WebPluginContainerImpl::create(element, webplugin);
|
| + // The container takes ownership of the WebPlugin.
|
| + RefPtr<WebPluginContainerImpl> container =
|
| + WebPluginContainerImpl::create(element, webPlugin);
|
|
|
| - if (!webplugin->initialize(container.get()))
|
| - return NULL;
|
| + if (!webPlugin->initialize(container.get()))
|
| + return 0;
|
|
|
| - // The element might have been removed during plugin initialization!
|
| - if (!element->renderer())
|
| - return NULL;
|
| + // The element might have been removed during plugin initialization!
|
| + if (!element->renderer())
|
| + return 0;
|
|
|
| - return container;
|
| + return container;
|
| }
|
|
|
| // This method gets called when a plugin is put in place of html content
|
| // (e.g., acrobat reader).
|
| -void WebFrameLoaderClient::redirectDataToPlugin(Widget* pluginWidget) {
|
| - plugin_widget_ = static_cast<WebPluginContainerImpl*>(pluginWidget);
|
| - ASSERT(plugin_widget_.get());
|
| +void FrameLoaderClientImpl::redirectDataToPlugin(Widget* pluginWidget) {
|
| + m_pluginWidget = static_cast<WebPluginContainerImpl*>(pluginWidget);
|
| + ASSERT(m_pluginWidget.get());
|
| }
|
|
|
| -PassRefPtr<Widget> WebFrameLoaderClient::createJavaAppletWidget(
|
| - const IntSize& size,
|
| - HTMLAppletElement* element,
|
| - const KURL& /* base_url */,
|
| - const Vector<String>& param_names,
|
| - const Vector<String>& param_values) {
|
| - return createPlugin(size, element, KURL(), param_names, param_values,
|
| - "application/x-java-applet", false);
|
| +PassRefPtr<Widget> FrameLoaderClientImpl::createJavaAppletWidget(
|
| + const IntSize& size,
|
| + HTMLAppletElement* element,
|
| + const KURL& /* baseURL */,
|
| + const Vector<String>& paramNames,
|
| + const Vector<String>& paramValues)
|
| +{
|
| + return createPlugin(size, element, KURL(), paramNames, paramValues,
|
| + "application/x-java-applet", false);
|
| }
|
|
|
| -ObjectContentType WebFrameLoaderClient::objectContentType(
|
| +ObjectContentType FrameLoaderClientImpl::objectContentType(
|
| const KURL& url,
|
| - const String& explicit_mime_type) {
|
| - // This code is based on Apple's implementation from
|
| - // WebCoreSupport/WebFrameBridge.mm.
|
| + const String& explicitMimeType)
|
| +{
|
| + // This code is based on Apple's implementation from
|
| + // WebCoreSupport/WebFrameBridge.mm.
|
|
|
| - String mime_type = explicit_mime_type;
|
| - if (mime_type.isEmpty()) {
|
| - // Try to guess the MIME type based off the extension.
|
| - String filename = url.lastPathComponent();
|
| - int extension_pos = filename.reverseFind('.');
|
| - if (extension_pos >= 0)
|
| - mime_type = MIMETypeRegistry::getMIMETypeForPath(url.path());
|
| + String mimeType = explicitMimeType;
|
| + if (mimeType.isEmpty()) {
|
| + // Try to guess the MIME type based off the extension.
|
| + String filename = url.lastPathComponent();
|
| + int extensionPos = filename.reverseFind('.');
|
| + if (extensionPos >= 0)
|
| + mimeType = MIMETypeRegistry::getMIMETypeForPath(url.path());
|
|
|
| - if (mime_type.isEmpty())
|
| - return ObjectContentFrame;
|
| - }
|
| + if (mimeType.isEmpty())
|
| + return ObjectContentFrame;
|
| + }
|
|
|
| - if (MIMETypeRegistry::isSupportedImageMIMEType(mime_type))
|
| - return ObjectContentImage;
|
| + if (MIMETypeRegistry::isSupportedImageMIMEType(mimeType))
|
| + return ObjectContentImage;
|
|
|
| - // If Chrome is started with the --disable-plugins switch, pluginData is null.
|
| - PluginData* plugin_data = webframe_->frame()->page()->pluginData();
|
| - if (plugin_data && plugin_data->supportsMimeType(mime_type))
|
| - return ObjectContentNetscapePlugin;
|
| + // If Chrome is started with the --disable-plugins switch, pluginData is 0.
|
| + PluginData* pluginData = m_webFrame->frame()->page()->pluginData();
|
| + if (pluginData && pluginData->supportsMimeType(mimeType))
|
| + return ObjectContentNetscapePlugin;
|
|
|
| - if (MIMETypeRegistry::isSupportedNonImageMIMEType(mime_type))
|
| - return ObjectContentFrame;
|
| + if (MIMETypeRegistry::isSupportedNonImageMIMEType(mimeType))
|
| + return ObjectContentFrame;
|
|
|
| - return ObjectContentNone;
|
| + return ObjectContentNone;
|
| }
|
|
|
| -String WebFrameLoaderClient::overrideMediaType() const {
|
| - // FIXME
|
| - return String();
|
| +String FrameLoaderClientImpl::overrideMediaType() const
|
| +{
|
| + // FIXME
|
| + return String();
|
| }
|
|
|
| -bool WebFrameLoaderClient::ActionSpecifiesNavigationPolicy(
|
| - const WebCore::NavigationAction& action,
|
| - WebNavigationPolicy* policy) {
|
| - if ((action.type() != NavigationTypeLinkClicked) ||
|
| - !action.event()->isMouseEvent())
|
| - return false;
|
| +bool FrameLoaderClientImpl::actionSpecifiesNavigationPolicy(
|
| + const NavigationAction& action,
|
| + WebNavigationPolicy* policy)
|
| +{
|
| + if ((action.type() != NavigationTypeLinkClicked) || !action.event()->isMouseEvent())
|
| + return false;
|
|
|
| - const MouseEvent* event = static_cast<const MouseEvent*>(action.event());
|
| - return WebViewImpl::NavigationPolicyFromMouseEvent(event->button(),
|
| - event->ctrlKey(), event->shiftKey(), event->altKey(), event->metaKey(),
|
| - policy);
|
| + const MouseEvent* event = static_cast<const MouseEvent*>(action.event());
|
| + return WebViewImpl::navigationPolicyFromMouseEvent(
|
| + event->button(), event->ctrlKey(), event->shiftKey(), event->altKey(),
|
| + event->metaKey(), policy);
|
| }
|
|
|
| -void WebFrameLoaderClient::HandleBackForwardNavigation(const KURL& url) {
|
| - ASSERT(url.protocolIs(WebKit::backForwardNavigationScheme));
|
| +void FrameLoaderClientImpl::handleBackForwardNavigation(const KURL& url)
|
| +{
|
| + ASSERT(url.protocolIs(backForwardNavigationScheme));
|
|
|
| - bool ok;
|
| - int offset = url.lastPathComponent().toIntStrict(&ok);
|
| - if (!ok)
|
| - return;
|
| + bool ok;
|
| + int offset = url.lastPathComponent().toIntStrict(&ok);
|
| + if (!ok)
|
| + return;
|
|
|
| - WebViewImpl* webview = webframe_->GetWebViewImpl();
|
| - if (webview->client())
|
| - webview->client()->navigateBackForwardSoon(offset);
|
| + WebViewImpl* webview = m_webFrame->viewImpl();
|
| + if (webview->client())
|
| + webview->client()->navigateBackForwardSoon(offset);
|
| }
|
|
|
| -PassOwnPtr<WebPluginLoadObserver> WebFrameLoaderClient::GetPluginLoadObserver() {
|
| - WebDataSourceImpl* ds = WebDataSourceImpl::fromDocumentLoader(
|
| - webframe_->frame()->loader()->activeDocumentLoader());
|
| - return ds->releasePluginLoadObserver();
|
| +PassOwnPtr<WebPluginLoadObserver> FrameLoaderClientImpl::pluginLoadObserver()
|
| +{
|
| + WebDataSourceImpl* ds = WebDataSourceImpl::fromDocumentLoader(
|
| + m_webFrame->frame()->loader()->activeDocumentLoader());
|
| + return ds->releasePluginLoadObserver();
|
| }
|
| +
|
| +} // namespace WebKit
|
|
|
Chromium Code Reviews
Issue 341030:
Moves webview_impl.cc, webframe_impl.cc and webframeloaderclient_impl.cc into... (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src/