Hook up WebFrameClient, replacing many WebViewDelegate methods....

webkit/glue/webframeloaderclient_impl.cc

 // 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.
 
 #include "config.h"
 
 #include <string>
 #include <vector>
 
 #include "Chrome.h"
@@ skipping 14 matching lines @@
 #include "StringExtras.h"
 #include "WindowFeatures.h"
 #undef LOG
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "webkit/api/public/WebForm.h"
+#include "webkit/api/public/WebFrameClient.h"
 #include "webkit/api/public/WebPlugin.h"
 #include "webkit/api/public/WebPluginParams.h"
 #include "webkit/api/public/WebURL.h"
 #include "webkit/api/public/WebURLError.h"
 #include "webkit/api/public/WebVector.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"
@@ skipping 58 matching lines @@
   // 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_->Release();
 }
 
 void WebFrameLoaderClient::windowObjectCleared() {
+  if (webframe_->client())
+    webframe_->client()->didClearWindowObject(webframe_);
+
   WebViewImpl* webview = webframe_->GetWebViewImpl();
-  WebViewDelegate* d = webview->delegate();
-  if (d)
-    d->WindowObjectCleared(webframe_);
-
-  WebDevToolsAgentImpl* tools_agent = webview->GetWebDevToolsAgentImpl();
-  if (tools_agent)
-    tools_agent->WindowObjectCleared(webframe_);
+  if (webview) {
+    WebDevToolsAgentImpl* tools_agent = webview->GetWebDevToolsAgentImpl();
+    if (tools_agent)
+      tools_agent->WindowObjectCleared(webframe_);
+  }
 }
 
 void WebFrameLoaderClient::documentElementAvailable() {
-  WebViewImpl* webview = webframe_->GetWebViewImpl();
-  WebViewDelegate* d = webview->delegate();
-  if (d)
-    d->DocumentElementAvailable(webframe_);
+  if (webframe_->client())
+    webframe_->client()->didCreateDocumentElement(webframe_);
 }
 
 void WebFrameLoaderClient::didCreateScriptContextForFrame() {
   WebViewImpl* webview = webframe_->GetWebViewImpl();
   WebViewDelegate* d = webview->delegate();
   if (d)
     d->DidCreateScriptContextForFrame(webframe_);
 }
 
 void WebFrameLoaderClient::didDestroyScriptContextForFrame() {
@@ skipping 51 matching lines @@
 }
 
 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();
+
+  // Drop any reference to the client since it may shortly become invalid.
+  webframe_->drop_client();
 }
 
 // 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(
     unsigned long identifier, DocumentLoader* loader,
     const ResourceRequest& request) {
-  WebViewDelegate* d = webframe_->GetWebViewImpl()->delegate();
-  if (d) {
+  if (webframe_->client()) {
     WrappedResourceRequest webreq(request);
-    d->AssignIdentifierToRequest(webframe_, identifier, webreq);
+    webframe_->client()->assignIdentifierToRequest(
+        webframe_, identifier, webreq);
   }
 }
 
 // Determines whether the request being loaded by |loader| is a frame or a
 // subresource. A subresource in this context is anything other than a frame --
 // this includes images and xmlhttp requests.  It is important to note that a
 // subresource is NOT limited to stuff loaded through the frame's subresource
 // loader. Synchronous xmlhttp requests for example, do not go through the
 // subresource loader, but we still label them as TargetIsSubResource.
 //
@@ skipping 21 matching lines @@
     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"));
 
-  // Give the delegate a crack at the request.
-  WebViewDelegate* d = webframe_->GetWebViewImpl()->delegate();
-  if (d) {
+  // Give the WebFrameClient a crack at the request.
+  if (webframe_->client()) {
     WrappedResourceRequest webreq(request);
     WrappedResourceResponse webresp(redirect_response);
-    d->WillSendRequest(webframe_, identifier, &webreq, webresp);
+    webframe_->client()->willSendRequest(
+        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
@@ skipping 11 matching lines @@
 }
 
 void WebFrameLoaderClient::dispatchDidCancelAuthenticationChallenge(
     DocumentLoader*, unsigned long identifier, const AuthenticationChallenge&) {
   // FIXME
 }
 
 void WebFrameLoaderClient::dispatchDidReceiveResponse(DocumentLoader* loader,
                                                       unsigned long identifier,
                                                       const ResourceResponse& response) {
-  WebViewDelegate* d = webframe_->GetWebViewImpl()->delegate();
-  if (d) {
+  if (webframe_->client()) {
     WrappedResourceResponse webresp(response);
-    d->DidReceiveResponse(webframe_, identifier, webresp);
+    webframe_->client()->didReceiveResponse(webframe_, identifier, webresp);
   }
 }
 
 void WebFrameLoaderClient::dispatchDidReceiveContentLength(
     DocumentLoader* loader,
     unsigned long identifier,
     int length_received) {
 }
 
 // Called when a particular resource load completes
 void WebFrameLoaderClient::dispatchDidFinishLoading(DocumentLoader* loader,
                                                     unsigned long identifier) {
-  WebViewDelegate* d = webframe_->GetWebViewImpl()->delegate();
-  if (d)
-    d->DidFinishLoading(webframe_, identifier);
+  if (webframe_->client())
+    webframe_->client()->didFinishResourceLoad(webframe_, identifier);
 }
 
 void WebFrameLoaderClient::dispatchDidFailLoading(DocumentLoader* loader,
                                                   unsigned long identifier,
                                                   const ResourceError& error) {
-  WebViewImpl* webview = webframe_->GetWebViewImpl();
-  if (webview && webview->delegate()) {
-    webview->delegate()->DidFailLoadingWithError(
+  if (webframe_->client()) {
+    webframe_->client()->didFailResourceLoad(
         webframe_, identifier, webkit_glue::ResourceErrorToWebURLError(error));
   }
 }
 
 void WebFrameLoaderClient::dispatchDidFinishDocumentLoad() {
-  WebViewImpl* webview = webframe_->GetWebViewImpl();
-  DocumentLoader* documentLoader =
-      webframe_->frame()->loader()->activeDocumentLoader();
-  WebDataSourceImpl* data_source =
-      WebDataSourceImpl::fromDocumentLoader(documentLoader);
-
   // A frame may be reused.  This call ensures we don't hold on to our password
   // listeners and their associated HTMLInputElements.
   webframe_->ClearPasswordListeners();
 
-  if (webview && webview->delegate())
-    webview->delegate()->DidFinishDocumentLoadForFrame(webview, webframe_);
+  if (webframe_->client())
+    webframe_->client()->didFinishDocumentLoad(webframe_);
 }
 
 bool WebFrameLoaderClient::dispatchDidLoadResourceFromMemoryCache(
     DocumentLoader* loader,
     const ResourceRequest& request,
     const ResourceResponse& response,
     int length) {
-  WebViewImpl* webview = webframe_->GetWebViewImpl();
-  WebViewDelegate* d = webview->delegate();
-
-  bool result = false;
-  if (d) {
+  if (webframe_->client()) {
     WrappedResourceRequest webreq(request);
     WrappedResourceResponse webresp(response);
-    result = d->DidLoadResourceFromMemoryCache(webview, webreq, webresp,
-                                               webframe_);
+    webframe_->client()->didLoadResourceFromMemoryCache(
+        webframe_, webreq, webresp);
   }
-  return result;
+  return false;  // Do not suppress remaining notifications
 }
 
 void WebFrameLoaderClient::dispatchDidLoadResourceByXMLHttpRequest(
     unsigned long identifier,
     const ScriptString& source) {
 }
 
 void WebFrameLoaderClient::dispatchDidHandleOnloadEvents() {
-  // During the onload event of a subframe, the subframe can be removed.  In
-  // that case, it has no page.  This is covered by
-  // LayoutTests/fast/dom/replaceChild.html
-  if (!webframe_->frame()->page())
-    return;
-  WebViewImpl* webview = webframe_->GetWebViewImpl();
-  WebViewDelegate* d = webview->delegate();
-  if (d)
-    d->DidHandleOnloadEventsForFrame(webview, webframe_);
+  if (webframe_->client())
+    webframe_->client()->didHandleOnloadEvents(webframe_);
 }
 
 // Redirect Tracking
 // =================
 // We want to keep track of the chain of redirects that occur during page
 // loading. There are two types of redirects, server redirects which are HTTP
 // response codes, and client redirects which are document.location= and meta
 // refreshes.
 //
 // This outlines the callbacks that we get in different redirect situations,
@@ skipping 83 matching lines @@
   // A provisional load should have started already, which should have put an
   // entry in our redirect chain.
   DCHECK(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(ds->request().url());
 
-  // Dispatch callback
-  WebViewImpl* webview = webframe_->GetWebViewImpl();
-  WebViewDelegate* d = webview->delegate();
-  if (d)
-    d->DidReceiveProvisionalLoadServerRedirect(webview, webframe_);
+  if (webframe_->client())
+    webframe_->client()->didReceiveServerRedirectForProvisionalLoad(webframe_);
 }
 
 // Called on both success and failure of a client redirect.
 void WebFrameLoaderClient::dispatchDidCancelClientRedirect() {
   // No longer expecting a client redirect.
-  WebViewImpl* webview = webframe_->GetWebViewImpl();
-  WebViewDelegate* d = webview ? webview->delegate() : NULL;
-  if (d) {
+  if (webframe_->client()) {
     expected_client_redirect_src_ = GURL();
     expected_client_redirect_dest_ = GURL();
-
-    d->DidCancelClientRedirect(webview, webframe_);
+    webframe_->client()->didCancelClientRedirect(webframe_);
   }
 
   // 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(const KURL& url,
-                                                             double interval,
-                                                             double fire_date) {
+void WebFrameLoaderClient::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.
-  WebViewImpl* webview = webframe_->GetWebViewImpl();
-  WebViewDelegate* d = webview ? webview->delegate() : NULL;
-  if (d) {
+  if (webframe_->client()) {
     expected_client_redirect_src_ = webframe_->url();
     expected_client_redirect_dest_ = webkit_glue::KURLToGURL(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_.SchemeIsFile() &&
        (expected_client_redirect_src_.SchemeIs("http") ||
         expected_client_redirect_src_.SchemeIsSecure())) {
       expected_client_redirect_src_ = GURL();
       expected_client_redirect_dest_ = GURL();
       return;
     }
 
-    d->WillPerformClientRedirect(webview,
-                                 webframe_,
-                                 expected_client_redirect_src_,
-                                 expected_client_redirect_dest_,
-                                 static_cast<unsigned int>(interval),
-                                 static_cast<unsigned int>(fire_date));
+    webframe_->client()->willPerformClientRedirect(
+        webframe_,
+        expected_client_redirect_src_,
+        expected_client_redirect_dest_,
+        static_cast<unsigned int>(interval),
+        static_cast<unsigned int>(fire_date));
   }
 }
 
 void WebFrameLoaderClient::dispatchDidChangeLocationWithinPage() {
   // Anchor fragment navigations are not normal loads, so we need to synthesize
   // some events for our delegate.
   WebViewImpl* webview = webframe_->GetWebViewImpl();
   WebViewDelegate* d = webview->delegate();
   if (d)
     d->DidStartLoading(webview);
 
   WebDataSourceImpl* ds = webframe_->GetDataSourceImpl();
   DCHECK(ds) << "DataSource NULL when navigating to reference fragment";
   if (ds) {
     GURL url = ds->request().url();
     GURL chain_end = 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_)) ||
-        (NavigationGestureForLastLoad() == NavigationGestureAuto);
+        (url == expected_client_redirect_dest_ &&
+         chain_end == expected_client_redirect_src_) ||
+        !webframe_->isProcessingUserGesture();
 
     if (was_client_redirect) {
-      if (d)
-        d->DidCompleteClientRedirect(webview, webframe_, chain_end);
+      if (webframe_->client())
+        webframe_->client()->didCompleteClientRedirect(webframe_, chain_end);
       ds->appendRedirect(chain_end);
       // Make sure we clear the expected redirect since we just effectively
       // completed it.
       expected_client_redirect_src_ = GURL();
       expected_client_redirect_dest_ = GURL();
      }
 
     // 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 (d) {
-    d->DidChangeLocationWithinPageForFrame(webview, webframe_,
-                                           is_new_navigation);
+  if (webframe_->client()) {
+    webframe_->client()->didChangeLocationWithinPage(
+        webframe_, is_new_navigation);
   }
 
   if (d)
     d->DidStopLoading(webview);
 }
 
 void WebFrameLoaderClient::dispatchWillClose() {
-  WebViewImpl* webview = webframe_->GetWebViewImpl();
-  WebViewDelegate* d = webview->delegate();
-  if (d)
-    d->WillCloseFrame(webview, webframe_);
+  if (webframe_->client())
+    webframe_->client()->willClose(webframe_);
 }
 
 void WebFrameLoaderClient::dispatchDidReceiveIcon() {
   WebViewImpl* webview = webframe_->GetWebViewImpl();
   WebViewDelegate* d = webview->delegate();
   if (d)
     d->DidReceiveIconForFrame(webview, webframe_);
 }
 
 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) {
     NOTREACHED() << "Attempting to provisional load but there isn't one";
     return;
   }
   GURL url = ds->request().url();
 
   // Since the provisional load just started, we should have not gotten
   // any redirects yet.
   DCHECK(!ds->hasRedirectChain());
 
-  WebViewImpl* webview = webframe_->GetWebViewImpl();
-  WebViewDelegate* d = webview->delegate();
   // 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_.is_valid()) {
     // expected_client_redirect_dest_ could be something like
     // "javascript:history.go(-1)" thus we need to exclude url starts with
     // "javascript:". See bug: 1080873
     DCHECK(expected_client_redirect_dest_.SchemeIs("javascript") ||
            expected_client_redirect_dest_ == url);
     ds->appendRedirect(expected_client_redirect_src_);
     completing_client_redirect = true;
   }
   ds->appendRedirect(url);
 
-  if (d) {
+  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.
-    d->DidStartProvisionalLoadForFrame(webview, webframe_,
-                                       NavigationGestureForLastLoad());
+    webframe_->client()->didStartProvisionalLoad(webframe_);
     if (completing_client_redirect)
-      d->DidCompleteClientRedirect(webview, webframe_,
-                                   expected_client_redirect_src_);
+      webframe_->client()->didCompleteClientRedirect(
+          webframe_, expected_client_redirect_src_);
   }
 }
 
 void WebFrameLoaderClient::dispatchDidReceiveTitle(const String& title) {
-  WebViewImpl* webview = webframe_->GetWebViewImpl();
-  WebViewDelegate* d = webview->delegate();
-  if (d) {
-    d->DidReceiveTitle(webview, webkit_glue::StringToStdWString(title),
-                       webframe_);
+  if (webframe_->client()) {
+    webframe_->client()->didReceiveTitle(
+        webframe_, webkit_glue::StringToWebString(title));
   }
 }
 
 void WebFrameLoaderClient::dispatchDidCommitLoad() {
   WebViewImpl* webview = webframe_->GetWebViewImpl();
   bool is_new_navigation;
   webview->DidCommitLoad(&is_new_navigation);
-  WebViewDelegate* d = webview->delegate();
-  if (d)
-    d->DidCommitLoadForFrame(webview, webframe_, is_new_navigation);
+
+  if (webframe_->client()) {
+    webframe_->client()->didCommitProvisionalLoad(
+        webframe_, is_new_navigation);
+  }
 
   WebDevToolsAgentImpl* tools_agent = webview->GetWebDevToolsAgentImpl();
   if (tools_agent) {
     tools_agent->DidCommitLoadForFrame(webview, webframe_, is_new_navigation);
   }
 }
 
 void WebFrameLoaderClient::dispatchDidFailProvisionalLoad(
     const ResourceError& error) {
   // If a policy change occured, then we do not want to inform the plugin
@@ skipping 19 matching lines @@
     plugin_load_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.
 }
 
 void WebFrameLoaderClient::dispatchDidFinishLoad() {
   OwnPtr<WebPluginLoadObserver> plugin_load_observer = GetPluginLoadObserver();
 
-  WebViewImpl* webview = webframe_->GetWebViewImpl();
-  WebViewDelegate* d = webview->delegate();
-  if (d)
-    d->DidFinishLoadForFrame(webview, webframe_);
+  if (webframe_->client())
+    webframe_->client()->didFinishLoad(webframe_);
+
   if (plugin_load_observer)
     plugin_load_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.
 }
 
 void WebFrameLoaderClient::dispatchDidFirstLayout() {
 }
@@ skipping 116 matching lines @@
   (webframe_->frame()->loader()->*function)(policy_action);
 }
 
 void WebFrameLoaderClient::dispatchDecidePolicyForNavigationAction(
     WebCore::FramePolicyFunction function,
     const WebCore::NavigationAction& action,
     const WebCore::ResourceRequest& request,
     PassRefPtr<WebCore::FormState> form_state) {
   PolicyAction policy_action = PolicyIgnore;
 
-  WebViewImpl* wv = webframe_->GetWebViewImpl();
-  WebViewDelegate* d = wv->delegate();
   // 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 (d && !request.url().isNull()) {
+  if (webframe_->client() && !request.url().isNull()) {
     WebNavigationPolicy navigation_policy =
         WebKit::WebNavigationPolicyCurrentTab;
     ActionSpecifiesNavigationPolicy(action, &navigation_policy);
 
     // Give the delegate a chance to change the navigation policy.
     const WebDataSourceImpl* ds = webframe_->GetProvisionalDataSourceImpl();
     if (ds) {
       GURL url = ds->request().url();
       if (url.SchemeIs(webkit_glue::kBackForwardNavigationScheme)) {
         HandleBackForwardNavigation(url);
         navigation_policy = WebKit::WebNavigationPolicyIgnore;
       } else {
         bool is_redirect = ds->hasRedirectChain();
 
         WebNavigationType webnav_type =
             WebDataSourceImpl::toWebNavigationType(action.type());
 
-        navigation_policy = d->PolicyForNavigationAction(
-            wv, webframe_, ds->request(), webnav_type, navigation_policy,
+        navigation_policy = webframe_->client()->decidePolicyForNavigation(
+            webframe_, ds->request(), webnav_type, 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) {
-        GURL referrer = webkit_glue::StringToGURL(
-            request.httpHeaderField("Referer"));
-
-        d->OpenURL(webframe_->GetWebViewImpl(),
-                   webkit_glue::KURLToGURL(request.url()),
-                   referrer,
-                   navigation_policy);
+        WrappedResourceRequest webreq(request);
+        webframe_->client()->loadURLExternally(
+            webframe_, webreq, navigation_policy);
       }
       policy_action = PolicyIgnore;
     }
   }
 
   (webframe_->frame()->loader()->*function)(policy_action);
 }
 
 void WebFrameLoaderClient::cancelPolicyCheck() {
   // FIXME
 }
 
 void WebFrameLoaderClient::dispatchUnableToImplementPolicy(const ResourceError&) {
   // FIXME
 }
 
 void WebFrameLoaderClient::dispatchWillSubmitForm(FramePolicyFunction function,
     PassRefPtr<FormState> form_ref) {
-  WebViewImpl* webview = webframe_->GetWebViewImpl();
-  WebViewDelegate* d = webview->delegate();
-  if (d) {
-    d->WillSubmitForm(webview, webframe_,
-                      webkit_glue::HTMLFormElementToWebForm(form_ref->form()));
+  if (webframe_->client()) {
+    webframe_->client()->willSubmitForm(
+        webframe_, webkit_glue::HTMLFormElementToWebForm(form_ref->form()));
   }
   (webframe_->frame()->loader()->*function)(PolicyUse);
 }
 
 void WebFrameLoaderClient::dispatchDidLoadMainResource(DocumentLoader*) {
   // FIXME
 }
 
 void WebFrameLoaderClient::revertToProvisionalState(DocumentLoader*) {
   has_representation_ = true;
@@ skipping 53 matching lines @@
   // FIXME
 }
 
 void WebFrameLoaderClient::didChangeTitle(DocumentLoader*) {
   // FIXME
 }
 
 // Called whenever data is received.
 void WebFrameLoaderClient::committedLoad(DocumentLoader* loader, const char* data, int length) {
   if (!plugin_widget_.get()) {
-    WebViewDelegate* d = webframe_->GetWebViewImpl()->delegate();
-    if (d)
-      d->DidReceiveDocumentData(webframe_, data, length);
+    if (webframe_->client()) {
+      bool preventDefault = false;
+      webframe_->client()->didReceiveDocumentData(webframe_, data, length, preventDefault);
+      if (!preventDefault)
+        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()));
   }
 
@@ skipping 161 matching lines @@
 }
 
 void WebFrameLoaderClient::prepareForDataSourceReplacement() {
   // FIXME
 }
 
 PassRefPtr<DocumentLoader> WebFrameLoaderClient::createDocumentLoader(
     const ResourceRequest& request,
     const SubstituteData& data) {
   RefPtr<WebDataSourceImpl> ds = WebDataSourceImpl::create(request, data);
-  WebViewDelegate* d = webframe_->GetWebViewImpl()->delegate();
-  if (d)
-    d->DidCreateDataSource(webframe_, ds.get());
+  if (webframe_->client())
+    webframe_->client()->didCreateDataSource(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.:
@@ skipping 65 matching lines @@
   // 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;
 #endif
 
-  WebViewImpl* webview = webframe_->GetWebViewImpl();
-  if (!webview->delegate())
+  if (!webframe_->client())
     return NULL;
 
   WebPluginParams params;
   params.url = webkit_glue::KURLToWebURL(url);
   params.mimeType = webkit_glue::StringToWebString(mime_type);
   CopyStringVector(param_names, &params.attributeNames);
   CopyStringVector(param_values, &params.attributeValues);
   params.loadManually = load_manually;
 
-  WebPlugin* webplugin = webview->delegate()->CreatePlugin(webframe_, params);
+  WebPlugin* webplugin = webframe_->client()->createPlugin(webframe_, params);
   if (!webplugin)
     return NULL;
 
   // The container takes ownership of the WebPlugin.
   RefPtr<WebPluginContainerImpl> container =
       WebPluginContainerImpl::create(element, webplugin);
 
   if (!webplugin->initialize(container.get()))
     return NULL;
 
@@ skipping 83 matching lines @@
   } else {
     if (shift) {
       *policy = WebKit::WebNavigationPolicyNewWindow;
     } else {
       *policy = WebKit::WebNavigationPolicyDownload;
     }
   }
   return true;
 }
 
-NavigationGesture WebFrameLoaderClient::NavigationGestureForLastLoad() {
-  // TODO(timsteele): isProcessingUserGesture() returns too many false positives
-  // (see bug 1051891) to trust it and assign NavigationGestureUser, so
-  // for now we assign Unknown in those cases and Auto otherwise.
-  // (Issue 874811 known false negative as well).
-  return webframe_->frame()->loader()->isProcessingUserGesture() ?
-      NavigationGestureUnknown :
-      NavigationGestureAuto;
-}
-
 void WebFrameLoaderClient::HandleBackForwardNavigation(const GURL& url) {
   DCHECK(url.SchemeIs(webkit_glue::kBackForwardNavigationScheme));
 
   std::string offset_str = url.ExtractFileName();
   int offset;
   if (!StringToInt(offset_str, &offset))
     return;
 
   WebViewDelegate* d = webframe_->GetWebViewImpl()->delegate();
   if (d)
     d->NavigateBackForwardSoon(offset);
 }
 
 PassOwnPtr<WebPluginLoadObserver> WebFrameLoaderClient::GetPluginLoadObserver() {
   WebDataSourceImpl* ds = WebDataSourceImpl::fromDocumentLoader(
       webframe_->frame()->loader()->activeDocumentLoader());
   return ds->releasePluginLoadObserver();
 }