Add a BeforeDestroyFrame notification method to WebViewDelegate

webkit/glue/webframeloaderclient_impl.cc

 // Copyright (c) 2006-2008 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 "base/compiler_specific.h"
 
@@ skipping 82 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() {
-  WebViewImpl* webview = webframe_->webview_impl();
+  WebViewImpl* webview = webframe_->GetWebViewImpl();
   WebViewDelegate* d = webview->delegate();
   if (d)
     d->WindowObjectCleared(webframe_);
 }
 
 void WebFrameLoaderClient::documentElementAvailable() {
-  WebViewImpl* webview = webframe_->webview_impl();
+  WebViewImpl* webview = webframe_->GetWebViewImpl();
   WebViewDelegate* d = webview->delegate();
   if (d)
     d->DocumentElementAvailable(webframe_);
 }
 
 void WebFrameLoaderClient::didPerformFirstNavigation() const {
 }
 
 void WebFrameLoaderClient::registerForIconNotification(bool listen){
 }
 
 bool WebFrameLoaderClient::hasWebView() const {
-  return webframe_->webview_impl() != NULL;
+  return webframe_->GetWebViewImpl() != NULL;
 }
 
 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_->webview_impl() != NULL;
+  return webframe_->GetWebViewImpl() != NULL;
 }
 
 void WebFrameLoaderClient::makeDocumentView() {
   webframe_->CreateFrameView();
 }
 
 void WebFrameLoaderClient::makeRepresentation(DocumentLoader*) {
   has_representation_ = true;
 }
 
@@ skipping 22 matching lines @@
   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(
     unsigned long identifier, DocumentLoader* loader,
     const ResourceRequest& request) {
-  WebViewImpl* webview = webframe_->webview_impl();
+  WebViewImpl* webview = webframe_->GetWebViewImpl();
   WebViewDelegate* d = webview->delegate();
   if (d) {
     WebRequestImpl webreq(request);
     d->AssignIdentifierToRequest(webview, identifier, webreq);
   }
   NetAgentImpl* net_agent = GetNetAgentImpl();
   if (net_agent) {
     net_agent->AssignIdentifierToRequest(loader, identifier, request);
   }
 }
@@ skipping 39 matching lines @@
   }
 
   // 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("about:blank"));
   if (request.mainDocumentURL().isEmpty())
     request.setMainDocumentURL(KURL("about:blank"));
 
   // Give the delegate a crack at the request.
-  WebViewImpl* webview = webframe_->webview_impl();
+  WebViewImpl* webview = webframe_->GetWebViewImpl();
   WebViewDelegate* d = webview->delegate();
   if (d) {
     WebRequestImpl webreq(request);
     d->WillSendRequest(webview, identifier, &webreq);
     request = webreq.frame_load_request().resourceRequest();
   }
   NetAgentImpl* net_agent = GetNetAgentImpl();
   if (net_agent) {
     net_agent->WillSendRequest(loader, identifier, request);
   }
@@ skipping 87 matching lines @@
   if (postpone_loading_data_) {
     // The server returned a 404 and the content was < 512 bytes (which we
     // suppressed).  Go ahead and fetch the alternate page content.
     const GURL& url = GetAlt404PageUrl(loader);
     DCHECK(url.is_valid()) <<
         "URL changed? It was valid in dispatchDidReceiveResponse.";
     alt_404_page_fetcher_.reset(new Alt404PageResourceFetcher(this,
         webframe_->frame(), loader, url));
   }
 
-  WebViewImpl* webview = webframe_->webview_impl();
+  WebViewImpl* webview = webframe_->GetWebViewImpl();
   WebViewDelegate* d = webview->delegate();
   if (d)
     d->DidFinishLoading(webview, identifier);
 
   NetAgentImpl* net_agent = GetNetAgentImpl();
   if (net_agent) {
     net_agent->DidFinishLoading(loader, identifier);
   }
 }
 
 GURL WebFrameLoaderClient::GetAlt404PageUrl(DocumentLoader* loader) {
-  WebViewImpl* webview = webframe_->webview_impl();
+  WebViewImpl* webview = webframe_->GetWebViewImpl();
   WebViewDelegate* d = webview->delegate();
   if (!d)
     return GURL();
 
   const GURL& failedURL = webkit_glue::KURLToGURL(loader->url());
 
   // If trying to view source on a 404 page, just show the original page
   // content.
   if (webframe_->frame()->inViewSourceMode())
     return GURL();
@@ skipping 12 matching lines @@
   } else {
     // Fall back on original text
     webframe_->LoadHTMLString(postponed_data_,
                               webkit_glue::KURLToGURL(loader->url()));
   }
 }
 
 void WebFrameLoaderClient::dispatchDidFailLoading(DocumentLoader* loader,
                                                   unsigned long identifier,
                                                   const ResourceError& error) {
-  WebViewImpl* webview = webframe_->webview_impl();
+  WebViewImpl* webview = webframe_->GetWebViewImpl();
   if (webview && webview->delegate()) {
     webview->delegate()->DidFailLoadingWithError(webview, identifier,
                                                  WebErrorImpl(error));
   }
   NetAgentImpl* net_agent = GetNetAgentImpl();
   if (net_agent) {
     net_agent->DidFailLoading(loader, identifier, error);
   }
 }
 
 void WebFrameLoaderClient::dispatchDidFinishDocumentLoad() {
-  WebViewImpl* webview = webframe_->webview_impl();
+  WebViewImpl* webview = webframe_->GetWebViewImpl();
   WebViewDelegate* d = webview->delegate();
   DocumentLoader* documentLoader =
       webframe_->frame()->loader()->activeDocumentLoader();
   WebDataSourceImpl* data_source =
       WebDataSourceImpl::FromLoader(documentLoader);
 
   // A frame may be reused.  This call ensures we don't hold on to our password
   // listeners and their associated HTMLInputElements.
   webframe_->ClearPasswordListeners();
 
@@ skipping 29 matching lines @@
   if (d)
     d->DidFinishDocumentLoadForFrame(webview, webframe_);
   data_source->set_finish_document_load_time(base::Time::Now());
 }
 
 bool WebFrameLoaderClient::dispatchDidLoadResourceFromMemoryCache(
     DocumentLoader* loader,
     const ResourceRequest& request,
     const ResourceResponse& response,
     int length) {
-  WebViewImpl* webview = webframe_->webview_impl();
+  WebViewImpl* webview = webframe_->GetWebViewImpl();
   WebViewDelegate* d = webview->delegate();
 
   bool result = false;
   if (d) {
     WebRequestImpl webreq(request);
     WebResponseImpl webresp(response);
     result = d->DidLoadResourceFromMemoryCache(webview, webreq, webresp,
                                                webframe_);
   }
   NetAgentImpl* net_agent = GetNetAgentImpl();
@@ skipping 17 matching lines @@
         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_->webview_impl();
+  WebViewImpl* webview = webframe_->GetWebViewImpl();
   WebViewDelegate* d = webview->delegate();
   if (d)
     d->DidHandleOnloadEventsForFrame(webview, 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
@@ skipping 83 matching lines @@
   // entry in our redirect chain.
   DCHECK(!ds->GetRedirectChain().empty());
 
   // 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->GetRequest().GetURL());
 
   // Dispatch callback
-  WebViewImpl* webview = webframe_->webview_impl();
+  WebViewImpl* webview = webframe_->GetWebViewImpl();
   WebViewDelegate* d = webview->delegate();
   if (d)
     d->DidReceiveProvisionalLoadServerRedirect(webview, webframe_);
 }
 
 // Called on both success and failure of a client redirect.
 void WebFrameLoaderClient::dispatchDidCancelClientRedirect() {
   // No longer expecting a client redirect.
-  WebViewImpl* webview = webframe_->webview_impl();
+  WebViewImpl* webview = webframe_->GetWebViewImpl();
   WebViewDelegate* d = webview ? webview->delegate() : NULL;
   if (d) {
     expected_client_redirect_src_ = GURL();
     expected_client_redirect_dest_ = GURL();
 
     d->DidCancelClientRedirect(webview, 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) {
   // 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_->webview_impl();
+  WebViewImpl* webview = webframe_->GetWebViewImpl();
   WebViewDelegate* d = webview ? webview->delegate() : NULL;
   if (d) {
     expected_client_redirect_src_ = webframe_->GetURL();
     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));
   }
 }
 
 void WebFrameLoaderClient::dispatchDidChangeLocationWithinPage() {
   // Anchor fragment navigations are not normal loads, so we need to synthesize
   // some events for our delegate.
-  WebViewImpl* webview = webframe_->webview_impl();
+  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->GetRequest().GetURL();
     GURL chain_end = ds->GetRedirectChain().back();
     ds->ClearRedirectChain();
@@ skipping 37 matching lines @@
   if (d) {
     d->DidChangeLocationWithinPageForFrame(webview, webframe_,
                                            is_new_navigation);
   }
 
   if (d)
     d->DidStopLoading(webview);
 }
 
 void WebFrameLoaderClient::dispatchWillClose() {
-  WebViewImpl* webview = webframe_->webview_impl();
+  WebViewImpl* webview = webframe_->GetWebViewImpl();
   // Make sure WebViewImpl releases the references it uses to restore focus.
   // If we didn't do this, WebViewImpl might try to restore focus to an invalid
   // element.
   webview->ReleaseFocusReferences();
   WebViewDelegate* d = webview->delegate();
   if (d)
     d->WillCloseFrame(webview, webframe_);
 }
 
 void WebFrameLoaderClient::dispatchDidReceiveIcon() {
-  WebViewImpl* webview = webframe_->webview_impl();
+  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;
   }
   const GURL& url = ds->GetRequest().GetURL();
 
   // Since the provisional load just started, we should have not gotten
   // any redirects yet.
   DCHECK(ds->GetRedirectChain().empty());
 
-  WebViewImpl* webview = webframe_->webview_impl();
+  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") ||
@@ skipping 40 matching lines @@
   // TODO(timsteele): userGestureHint 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()->userGestureHint() ?
       NavigationGestureUnknown :
       NavigationGestureAuto;
 }
 
 void WebFrameLoaderClient::dispatchDidReceiveTitle(const String& title) {
-  WebViewImpl* webview = webframe_->webview_impl();
+  WebViewImpl* webview = webframe_->GetWebViewImpl();
   WebViewDelegate* d = webview->delegate();
   if (d) {
     d->DidReceiveTitle(webview, webkit_glue::StringToStdWString(title),
                        webframe_);
   }
 }
 
 void WebFrameLoaderClient::dispatchDidCommitLoad() {
   webframe_->SelectAppCacheWithoutManifest();
 
-  WebViewImpl* webview = webframe_->webview_impl();
+  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);
 
   WebDevToolsAgentImpl* tools_agent = webview->GetWebDevToolsAgentImpl();
   if (tools_agent) {
     tools_agent->DidCommitLoadForFrame(webview, webframe_, is_new_navigation);
   }
@@ skipping 24 matching lines @@
   // 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() {
   DocumentLoader* documentLoader =
       webframe_->frame()->loader()->activeDocumentLoader();
   WebDataSourceImpl* dataSource =
       WebDataSourceImpl::FromLoader(documentLoader);
-  WebViewImpl* webview = webframe_->webview_impl();
+  WebViewImpl* webview = webframe_->GetWebViewImpl();
   WebViewDelegate* d = webview->delegate();
   dataSource->set_finish_load_time(base::Time::Now());
   if (d)
     d->DidFinishLoadForFrame(webview, webframe_);
   WebPluginDelegate* plg_delegate = webframe_->plugin_delegate();
   if (plg_delegate)
     plg_delegate->DidFinishLoadWithReason(NPRES_DONE);
 
   // 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
@@ skipping 31 matching lines @@
 
   // createWindow can return NULL (e.g., popup blocker denies the window).
   if (!new_page)
     return NULL;
 
   WebViewImpl::FromPage(new_page)->set_window_open_disposition(disp);
   return new_page->mainFrame();
 }
 
 void WebFrameLoaderClient::dispatchShow() {
-  WebViewImpl* webview = webframe_->webview_impl();
+  WebViewImpl* webview = webframe_->GetWebViewImpl();
   WebViewDelegate* d = webview->delegate();
   if (d)
     d->Show(webview, webview->window_open_disposition());
 }
 
 static bool TreatAsAttachment(const ResourceResponse& response) {
   const String& content_disposition =
       response.httpHeaderField("Content-Disposition");
   if (content_disposition.isEmpty())
     return false;
@@ skipping 78 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 = PolicyUse;
 
-  WebViewImpl* wv = webframe_->webview_impl();
+  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()) {
     WindowOpenDisposition disposition = CURRENT_TAB;
     ActionSpecifiesDisposition(action, &disposition);
 
     // Give the delegate a chance to change the disposition.  When we do not
@@ skipping 12 matching lines @@
 
       if (disposition != IGNORE_ACTION) {
         if (disposition == CURRENT_TAB) {
           policy_action = PolicyUse;
         } else if (disposition == SAVE_TO_DISK) {
           policy_action = PolicyDownload;
         } else {
           GURL referrer = webkit_glue::StringToGURL(
               request.httpHeaderField("Referer"));
 
-          d->OpenURL(webframe_->webview_impl(),
+          d->OpenURL(webframe_->GetWebViewImpl(),
                      webkit_glue::KURLToGURL(request.url()),
                      referrer,
                      disposition);
           policy_action = PolicyIgnore;
         }
       } else {
         policy_action = PolicyIgnore;
       }
     }
   } else {
@@ skipping 17 matching lines @@
   WebDataSourceImpl* ds = WebDataSourceImpl::FromLoader(
       webframe_->frame()->loader()->provisionalDocumentLoader());
   // Don't free the SearchableFormData, the datasource will do that.
   ds->set_searchable_form_data(form_data);
 
   PasswordForm* pass_data =
       PasswordFormDomManager::CreatePasswordForm(form_ref->form());
   // Don't free the PasswordFormData, the datasource will do that.
   ds->set_password_form_data(pass_data);
 
-  WebViewImpl* webview = webframe_->webview_impl();
+  WebViewImpl* webview = webframe_->GetWebViewImpl();
   WebViewDelegate* d = webview->delegate();
 
   // Unless autocomplete=off, record what the user put in it for future
   // autofilling.
   if (form_ref->form()->autoComplete()) {
     scoped_ptr<AutofillForm> autofill_form(
         AutofillForm::CreateAutofillForm(form_ref->form()));
     if (autofill_form.get()) {
       d->OnAutofillFormSubmitted(webview, *autofill_form);
     }
@@ skipping 18 matching lines @@
     if (sent_initial_response_to_plugin_) {
       plugin_widget_->didFail(error);
       sent_initial_response_to_plugin_ = false;
     }
     plugin_widget_ = NULL;
   }
 }
 
 void WebFrameLoaderClient::postProgressStartedNotification() {
   if (hasWebView()) {
-    WebViewDelegate* d = webframe_->webview_impl()->delegate();
+    WebViewImpl* web_view = webframe_->GetWebViewImpl();
+    WebViewDelegate* d = web_view->delegate();
     if (d)
-      d->DidStartLoading(webframe_->webview_impl());
+      d->DidStartLoading(web_view);
   }
 }
 
 void WebFrameLoaderClient::postProgressEstimateChangedNotification() {
   // FIXME
 }
 
 void WebFrameLoaderClient::postProgressFinishedNotification() {
   // TODO(ericroman): why might webframe_->webview_impl be null?
   // http://b/1234461
   if (hasWebView()) {
-    WebViewDelegate* d = webframe_->webview_impl()->delegate();
-
+    WebViewImpl* web_view = webframe_->GetWebViewImpl();
+    WebViewDelegate* d = web_view->delegate();
     if (d)
-      d->DidStopLoading(webframe_->webview_impl());
+      d->DidStopLoading(web_view);
   }
 }
 
 void WebFrameLoaderClient::setMainFrameDocumentReady(bool ready) {
-  WebViewImpl* web_view = webframe_->webview_impl();
+  WebViewImpl* web_view = webframe_->GetWebViewImpl();
   if (!web_view)
     return;
   WebDevToolsAgentImpl* tools_agent = web_view->GetWebDevToolsAgentImpl();
   if (!tools_agent)
     return;
 
   if (webframe_ == web_view->GetMainFrame()) {
     tools_agent->SetMainFrameDocumentReady(ready);
   }
 }
 
 // Creates a new connection and begins downloading from that (contrast this
 // with |download|).
 void WebFrameLoaderClient::startDownload(const ResourceRequest& request) {
-  WebViewDelegate* d = webframe_->webview_impl()->delegate();
+  WebViewDelegate* d = webframe_->GetWebViewImpl()->delegate();
   if (d) {
     const GURL url(webkit_glue::KURLToGURL(request.url()));
     const GURL referrer(webkit_glue::StringToStdString(request.httpReferrer()));
     d->DownloadUrl(url, referrer);
   }
 }
 
 void WebFrameLoaderClient::willChangeTitle(DocumentLoader*) {
   // FIXME
 }
@@ skipping 185 matching lines @@
 }
 
 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_->webview_impl()->GetBackForwardList()->GetCurrentItem();
+  // webframe_->GetWebViewImpl()->GetBackForwardList()->GetCurrentItem();
   // WebHistoryItemImpl* item_impl = static_cast<WebHistoryItemImpl*>(item);
   //
   // item_impl->SetTitle(webkit_glue::StringToStdWString(title));
 }
 
 String WebFrameLoaderClient::userAgent(const KURL& url) {
   return webkit_glue::StdStringToString(
       webkit_glue::GetUserAgent(webkit_glue::KURLToGURL(url)));
 }
 
@@ skipping 62 matching lines @@
   delete [] arr;
 }
 
 Widget* WebFrameLoaderClient::createPlugin(const IntSize& size, // TODO(erikkay): 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) {
-  WebViewImpl* webview = webframe_->webview_impl();
+  WebViewImpl* webview = webframe_->GetWebViewImpl();
   WebViewDelegate* d = webview->delegate();
   if (!d)
     return NULL;
 
   GURL gurl = webkit_glue::KURLToGURL(url);
   std::string my_mime_type =
       webkit_glue::CStringToStdString(mime_type.latin1());
   StringToLowerASCII(&my_mime_type);
 
   // Get the classid and version from attributes of the object.
@@ skipping 39 matching lines @@
   // 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
 
   std::string actual_mime_type;
   WebPluginDelegate* plugin_delegate =
-      d->CreatePluginDelegate(webframe_->webview_impl(), gurl, my_mime_type,
+      d->CreatePluginDelegate(webframe_->GetWebViewImpl(), gurl, my_mime_type,
                               combined_clsid, &actual_mime_type);
   if (!plugin_delegate)
     return NULL;
 
   if (!actual_mime_type.empty())
     my_mime_type = actual_mime_type;
 
   DCHECK(param_names.size() == param_values.size());
 
   char **argn = NULL;
@@ skipping 115 matching lines @@
 
   DCHECK(disposition);
   if (new_tab_modifier)
     *disposition = shift ? NEW_FOREGROUND_TAB : NEW_BACKGROUND_TAB;
   else
     *disposition = shift ? NEW_WINDOW : SAVE_TO_DISK;
   return true;
 }
 
 NetAgentImpl* WebFrameLoaderClient::GetNetAgentImpl() {
-  WebViewImpl* web_view = webframe_->webview_impl();
+  WebViewImpl* web_view = webframe_->GetWebViewImpl();
   if (!web_view) {
     return NULL;
   }
   WebDevToolsAgentImpl* tools_agent = web_view->GetWebDevToolsAgentImpl();
   if (tools_agent) {
     return tools_agent->net_agent_impl();
   } else {
     return NULL;
   }
 }