Conversion of content_shell target to use WebLocalFrame.

content/renderer/render_view_impl.cc

 // Copyright (c) 2012 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 "content/renderer/render_view_impl.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/auto_reset.h"
@@ skipping 148 matching lines @@
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebFileChooserParams.h"
 #include "third_party/WebKit/public/web/WebFindOptions.h"
 #include "third_party/WebKit/public/web/WebFormControlElement.h"
 #include "third_party/WebKit/public/web/WebFormElement.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebGlyphCache.h"
 #include "third_party/WebKit/public/web/WebHistoryItem.h"
 #include "third_party/WebKit/public/web/WebInputElement.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
+#include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebMediaPlayerAction.h"
 #include "third_party/WebKit/public/web/WebNavigationPolicy.h"
 #include "third_party/WebKit/public/web/WebNodeList.h"
 #include "third_party/WebKit/public/web/WebPageSerializer.h"
 #include "third_party/WebKit/public/web/WebPlugin.h"
 #include "third_party/WebKit/public/web/WebPluginAction.h"
 #include "third_party/WebKit/public/web/WebPluginContainer.h"
 #include "third_party/WebKit/public/web/WebPluginDocument.h"
 #include "third_party/WebKit/public/web/WebRange.h"
 #include "third_party/WebKit/public/web/WebScriptSource.h"
@@ skipping 85 matching lines @@
 using blink::WebFormControlElement;
 using blink::WebFormElement;
 using blink::WebFrame;
 using blink::WebGestureEvent;
 using blink::WebHistoryItem;
 using blink::WebHTTPBody;
 using blink::WebIconURL;
 using blink::WebImage;
 using blink::WebInputElement;
 using blink::WebInputEvent;
+using blink::WebLocalFrame;
 using blink::WebMediaPlayer;
 using blink::WebMediaPlayerAction;
 using blink::WebMediaPlayerClient;
 using blink::WebMouseEvent;
 using blink::WebNavigationPolicy;
 using blink::WebNavigationType;
 using blink::WebNode;
 using blink::WebPageSerializer;
 using blink::WebPageSerializerClient;
 using blink::WebPeerConnection00Handler;
@@ skipping 487 matching lines @@
   webview()->settings()->setCompositedScrollingForFramesEnabled(
       ShouldUseCompositedScrollingForFrames(device_scale_factor_));
   webview()->settings()
       ->setAcceleratedCompositingForGpuRasterizationHintEnabled(
           ShouldUseCompositingForGpuRasterizationHint());
 
   ApplyWebPreferences(webkit_preferences_, webview());
 
   main_render_frame_.reset(
       RenderFrameImpl::Create(this, params->main_frame_routing_id));
-  // The main frame WebFrame object is closed by
+  // The main frame WebLocalFrame object is closed by
   // RenderFrameImpl::frameDetached().
-  webview()->setMainFrame(WebFrame::create(main_render_frame_.get()));
-  main_render_frame_->SetWebFrame(webview()->mainFrame());
+  webview()->setMainFrame(WebLocalFrame::create(main_render_frame_.get()));
+  main_render_frame_->SetWebFrame(webview()->mainFrame()->toWebLocalFrame());
 
   if (switches::IsTouchDragDropEnabled())
     webview()->settings()->setTouchDragDropEnabled(true);
 
   if (switches::IsTouchEditingEnabled())
     webview()->settings()->setTouchEditingEnabled(true);
 
   if (!params->frame_name.empty())
     webview()->mainFrame()->setName(params->frame_name);
 
@@ skipping 666 matching lines @@
         it->second.Run(size, png);
         pending_snapshots_.erase(it++);
       } else {
         ++it;
       }
   }
 }
 
 // blink::WebViewClient ------------------------------------------------------
 
-WebView* RenderViewImpl::createView(
-    WebFrame* creator,
-    const WebURLRequest& request,
-    const WebWindowFeatures& features,
-    const WebString& frame_name,
-    WebNavigationPolicy policy,
-    bool suppress_opener) {
+WebView* RenderViewImpl::createView(WebLocalFrame* creator,
+                                    const WebURLRequest& request,
+                                    const WebWindowFeatures& features,
+                                    const WebString& frame_name,
+                                    WebNavigationPolicy policy,
+                                    bool suppress_opener) {
   ViewHostMsg_CreateWindow_Params params;
   params.opener_id = routing_id_;
   params.user_gesture = WebUserGestureIndicator::isProcessingUserGesture();
   if (GetContentClient()->renderer()->AllowPopup())
     params.user_gesture = true;
   params.window_container_type = WindowFeaturesToContainerType(features);
   params.session_storage_namespace_id = session_storage_namespace_id_;
   if (frame_name != "_blank")
     params.frame_name = frame_name;
   params.opener_render_frame_id =
@@ skipping 107 matching lines @@
 #else
   return NULL;
 #endif
 }
 
 WebStorageNamespace* RenderViewImpl::createSessionStorageNamespace() {
   CHECK(session_storage_namespace_id_ != kInvalidSessionStorageNamespaceId);
   return new WebStorageNamespaceImpl(session_storage_namespace_id_);
 }
 
-void RenderViewImpl::printPage(WebFrame* frame) {
+void RenderViewImpl::printPage(WebLocalFrame* frame) {
   FOR_EACH_OBSERVER(RenderViewObserver, observers_,
                     PrintPage(frame, handling_input_event_));
 }
 
 blink::WebNotificationPresenter* RenderViewImpl::notificationPresenter() {
   return notification_provider_;
 }
 
 bool RenderViewImpl::enumerateChosenDirectory(
     const WebString& path,
@@ skipping 112 matching lines @@
   ipc_params.accept_types.reserve(params.acceptTypes.size());
   for (size_t i = 0; i < params.acceptTypes.size(); ++i)
     ipc_params.accept_types.push_back(params.acceptTypes[i]);
 #if defined(OS_ANDROID)
   ipc_params.capture = params.useMediaCapture;
 #endif
 
   return ScheduleFileChooser(ipc_params, chooser_completion);
 }
 
-void RenderViewImpl::runModalAlertDialog(WebFrame* frame,
+void RenderViewImpl::runModalAlertDialog(WebLocalFrame* frame,
                                          const WebString& message) {
   RunJavaScriptMessage(JAVASCRIPT_MESSAGE_TYPE_ALERT,
                        message,
                        base::string16(),
                        frame->document().url(),
                        NULL);
 }
 
-bool RenderViewImpl::runModalConfirmDialog(WebFrame* frame,
+bool RenderViewImpl::runModalConfirmDialog(WebLocalFrame* frame,
                                            const WebString& message) {
   return RunJavaScriptMessage(JAVASCRIPT_MESSAGE_TYPE_CONFIRM,
                               message,
                               base::string16(),
                               frame->document().url(),
                               NULL);
 }
 
-bool RenderViewImpl::runModalPromptDialog(WebFrame* frame,
+bool RenderViewImpl::runModalPromptDialog(WebLocalFrame* frame,
                                           const WebString& message,
                                           const WebString& default_value,
                                           WebString* actual_value) {
   base::string16 result;
   bool ok = RunJavaScriptMessage(JAVASCRIPT_MESSAGE_TYPE_PROMPT,
                                  message,
                                  default_value,
                                  frame->document().url(),
                                  &result);
   if (ok)
     actual_value->assign(result);
   return ok;
 }
 
-bool RenderViewImpl::runModalBeforeUnloadDialog(
-    WebFrame* frame, const WebString& message) {
+bool RenderViewImpl::runModalBeforeUnloadDialog(WebLocalFrame* frame,
+                                                const WebString& message) {
   bool is_reload = false;
   WebDataSource* ds = frame->provisionalDataSource();
   if (ds)
     is_reload = (ds->navigationType() == blink::WebNavigationTypeReload);
   return runModalBeforeUnloadDialog(frame, is_reload, message);
 }
 
-bool RenderViewImpl::runModalBeforeUnloadDialog(
-    WebFrame* frame, bool is_reload, const WebString& message) {
+bool RenderViewImpl::runModalBeforeUnloadDialog(WebLocalFrame* frame,
+                                                bool is_reload,
+                                                const WebString& message) {
   // If we are swapping out, we have already run the beforeunload handler.
   // TODO(creis): Fix OnSwapOut to clear the frame without running beforeunload
   // at all, to avoid running it twice.
   if (is_swapped_out_)
     return true;
 
   // Don't allow further dialogs if we are waiting to swap out, since the
   // PageGroupLoadDeferrer in our stack prevents it.
   if (suppress_dialogs_until_swap_out_)
     return false;
@@ skipping 107 matching lines @@
 void RenderViewImpl::setMouseOverURL(const WebURL& url) {
   mouse_over_url_ = GURL(url);
   UpdateTargetURL(mouse_over_url_, focus_url_);
 }
 
 void RenderViewImpl::setKeyboardFocusURL(const WebURL& url) {
   focus_url_ = GURL(url);
   UpdateTargetURL(focus_url_, mouse_over_url_);
 }
 
-void RenderViewImpl::startDragging(WebFrame* frame,
+void RenderViewImpl::startDragging(WebLocalFrame* frame,
                                    const WebDragData& data,
                                    WebDragOperationsMask mask,
                                    const WebImage& image,
                                    const WebPoint& webImageOffset) {
   DropData drop_data(DropDataBuilder::Build(data));
   drop_data.referrer_policy = frame->document().referrerPolicy();
   gfx::Vector2d imageOffset(webImageOffset.x, webImageOffset.y);
   Send(new DragHostMsg_StartDragging(routing_id_,
                                      drop_data,
                                      mask,
@@ skipping 222 matching lines @@
   RenderWidget::initializeLayerTreeView();
   RenderWidgetCompositor* rwc = compositor();
   if (!rwc || !webview() || !webview()->devToolsAgent())
     return;
   webview()->devToolsAgent()->setLayerTreeId(rwc->GetLayerTreeId());
 }
 
 // blink::WebFrameClient -----------------------------------------------------
 
 WebMediaPlayer* RenderViewImpl::createMediaPlayer(
-    WebFrame* frame, const blink::WebURL& url, WebMediaPlayerClient* client) {
+    WebLocalFrame* frame,
+    const blink::WebURL& url,
+    WebMediaPlayerClient* client) {
   NOTREACHED();
   return NULL;
 }
 
 blink::WebMediaPlayer* RenderViewImpl::CreateMediaPlayer(
     RenderFrame* render_frame,
-    blink::WebFrame* frame,
+    blink::WebLocalFrame* frame,
     const blink::WebURL& url,
     blink::WebMediaPlayerClient* client) {
   FOR_EACH_OBSERVER(
       RenderViewObserver, observers_, WillCreateMediaPlayer(frame, client));
 
   WebMediaPlayer* player = CreateWebMediaPlayerForMediaStream(frame, url,
                                                               client);
   if (player)
     return player;
 
 #if defined(OS_ANDROID)
   return CreateAndroidWebMediaPlayer(frame, url, client);
 #else
   WebMediaPlayerParams params(
       base::Bind(&ContentRendererClient::DeferMediaLoad,
                  base::Unretained(GetContentClient()->renderer()),
                  static_cast<RenderFrame*>(render_frame)),
       RenderThreadImpl::current()->GetAudioRendererMixerManager()->CreateInput(
           routing_id_, render_frame->GetRoutingID()));
   return new WebMediaPlayerImpl(frame, client, AsWeakPtr(), params);
 #endif  // defined(OS_ANDROID)
 }
 
-void RenderViewImpl::didAccessInitialDocument(WebFrame* frame) {
+void RenderViewImpl::didAccessInitialDocument(WebLocalFrame* frame) {
   // Notify the browser process that it is no longer safe to show the pending
   // URL of the main frame, since a URL spoof is now possible.
   if (!frame->parent() && page_id_ == -1)
     Send(new ViewHostMsg_DidAccessInitialDocument(routing_id_));
 }
 
-void RenderViewImpl::didDisownOpener(blink::WebFrame* frame) {
+void RenderViewImpl::didDisownOpener(blink::WebLocalFrame* frame) {
   // We only need to notify the browser if the active, top-level frame clears
   // its opener.  We can ignore cases where a swapped out frame clears its
   // opener after hearing about it from the browser, and the browser does not
   // (yet) care about subframe openers.
   if (is_swapped_out_ || frame->parent())
     return;
 
   // Notify WebContents and all its swapped out RenderViews.
   Send(new ViewHostMsg_DidDisownOpener(routing_id_));
 }
 
 void RenderViewImpl::frameDetached(WebFrame* frame) {
   // NOTE: We may get here for either the main frame or for subframes.  The
   // RenderFrameImpl will be deleted immediately after this call for subframes
   // but not for the main frame, which is owned by |main_render_frame_|.
 
   FOR_EACH_OBSERVER(RenderViewObserver, observers_, FrameDetached(frame));
 }
 
 void RenderViewImpl::willClose(WebFrame* frame) {
   FOR_EACH_OBSERVER(RenderViewObserver, observers_, FrameWillClose(frame));
 }
 
 void RenderViewImpl::didMatchCSS(
-    WebFrame* frame,
+    WebLocalFrame* frame,
     const WebVector<WebString>& newly_matching_selectors,
     const WebVector<WebString>& stopped_matching_selectors) {
   FOR_EACH_OBSERVER(
       RenderViewObserver, observers_,
       DidMatchCSS(frame, newly_matching_selectors, stopped_matching_selectors));
 }
 
 void RenderViewImpl::Repaint(const gfx::Size& size) {
   OnRepaint(size);
 }
@@ skipping 21 matching lines @@
                           &ssl_status.security_bits,
                           &ssl_status.connection_status,
                           &ssl_status.signed_certificate_timestamp_ids);
   return ssl_status;
 }
 
 const std::string& RenderViewImpl::GetAcceptLanguages() const {
   return renderer_preferences_.accept_languages;
 }
 
-void RenderViewImpl::willSendSubmitEvent(blink::WebFrame* frame,
-    const blink::WebFormElement& form) {
+void RenderViewImpl::willSendSubmitEvent(blink::WebLocalFrame* frame,
+                                         const blink::WebFormElement& form) {
   FOR_EACH_OBSERVER(
       RenderViewObserver, observers_, WillSendSubmitEvent(frame, form));
 }
 
-void RenderViewImpl::willSubmitForm(WebFrame* frame,
+void RenderViewImpl::willSubmitForm(WebLocalFrame* frame,
                                     const WebFormElement& form) {
   FOR_EACH_OBSERVER(
       RenderViewObserver, observers_, WillSubmitForm(frame, form));
 }
 
-void RenderViewImpl::didCreateDataSource(WebFrame* frame, WebDataSource* ds) {
+void RenderViewImpl::didCreateDataSource(WebLocalFrame* frame,
+                                         WebDataSource* ds) {
   bool content_initiated = !pending_navigation_params_.get();
 
   // Make sure any previous redirect URLs end up in our new data source.
   if (pending_navigation_params_.get()) {
     for (std::vector<GURL>::const_iterator i =
              pending_navigation_params_->redirects.begin();
          i != pending_navigation_params_->redirects.end(); ++i) {
       ds->appendRedirect(*i);
     }
   }
@@ skipping 157 matching lines @@
 
   // When navigating to a new page, reset the page scale factor to be 1.0.
   webview()->setInitialPageScaleOverride(1.f);
 
   float maxPageScaleFactor =
       command_line.HasSwitch(switches::kEnablePinch) ? 4.f : 1.f ;
   webview()->setPageScaleFactorLimits(1, maxPageScaleFactor);
 }
 
 // TODO(nasko): Remove this method once WebTestProxy in Blink is fixed.
-void RenderViewImpl::didStartProvisionalLoad(WebFrame* frame) {
-}
+void RenderViewImpl::didStartProvisionalLoad(WebLocalFrame* frame) {}
 
-void RenderViewImpl::didFailProvisionalLoad(WebFrame* frame,
+void RenderViewImpl::didFailProvisionalLoad(WebLocalFrame* frame,
                                             const WebURLError& error) {
   // Notify the browser that we failed a provisional load with an error.
   //
   // Note: It is important this notification occur before DidStopLoading so the
   //       SSL manager can react to the provisional load failure before being
   //       notified the load stopped.
   //
   FOR_EACH_OBSERVER(
       RenderViewObserver, observers_, DidFailProvisionalLoad(frame, error));
 }
 
-void RenderViewImpl::didCommitProvisionalLoad(WebFrame* frame,
+void RenderViewImpl::didCommitProvisionalLoad(WebLocalFrame* frame,
                                               bool is_new_navigation) {
   FOR_EACH_OBSERVER(RenderViewObserver, observers_,
                     DidCommitProvisionalLoad(frame, is_new_navigation));
 
   // TODO(nasko): Transition this code to RenderFrameImpl, since g_view_map is
   // not accessible from there.
   if (!frame->parent()) {  // Only for top frames.
     RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
     if (render_thread_impl) {  // Can be NULL in tests.
       render_thread_impl->histogram_customizer()->
           RenderViewNavigatedToHost(GURL(GetLoadingUrl(frame)).host(),
                                     g_view_map.Get().size());
     }
   }
 }
 
-void RenderViewImpl::didClearWindowObject(WebFrame* frame, int world_id) {
+void RenderViewImpl::didClearWindowObject(WebLocalFrame* frame, int world_id) {
   FOR_EACH_OBSERVER(RenderViewObserver, observers_,
                     DidClearWindowObject(frame, world_id));
 
   // Only install controllers into the main world.
   if (world_id)
     return;
 
   if (enabled_bindings_& BINDINGS_POLICY_WEB_UI)
     WebUIExtension::Install(frame);
 
   if (enabled_bindings_ & BINDINGS_POLICY_STATS_COLLECTION)
     StatsCollectionController::Install(frame);
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
   if (command_line.HasSwitch(switches::kEnableSkiaBenchmarking))
     SkiaBenchmarking::Install(frame);
 
   if (command_line.HasSwitch(switches::kEnableMemoryBenchmarking))
     MemoryBenchmarkingExtension::Install(frame);
 }
 
-void RenderViewImpl::didCreateDocumentElement(WebFrame* frame) {
+void RenderViewImpl::didCreateDocumentElement(WebLocalFrame* frame) {
   FOR_EACH_OBSERVER(RenderViewObserver, observers_,
                     DidCreateDocumentElement(frame));
 }
 
-void RenderViewImpl::didReceiveTitle(WebFrame* frame, const WebString& title,
+void RenderViewImpl::didReceiveTitle(WebLocalFrame* frame,
+                                     const WebString& title,
                                      WebTextDirection direction) {
   UpdateTitle(frame, title, direction);
 
   // Also check whether we have new encoding name.
   UpdateEncoding(frame, frame->view()->pageEncoding().utf8());
 }
 
-void RenderViewImpl::didChangeIcon(WebFrame* frame,
+void RenderViewImpl::didChangeIcon(WebLocalFrame* frame,
                                    WebIconURL::Type icon_type) {
   if (frame->parent())
     return;
 
   if (!TouchEnabled() && icon_type != WebIconURL::TypeFavicon)
     return;
 
   WebVector<WebIconURL> icon_urls = frame->iconURLs(icon_type);
   std::vector<FaviconURL> urls;
   for (size_t i = 0; i < icon_urls.size(); i++) {
     std::vector<gfx::Size> sizes(icon_urls[i].sizes().size());
     ConvertToFaviconSizes(icon_urls[i].sizes(), &sizes);
     urls.push_back(FaviconURL(
         icon_urls[i].iconURL(), ToFaviconType(icon_urls[i].iconType()), sizes));
   }
   SendUpdateFaviconURL(urls);
 }
 
-void RenderViewImpl::didFinishDocumentLoad(WebFrame* frame) {
+void RenderViewImpl::didFinishDocumentLoad(WebLocalFrame* frame) {
   FOR_EACH_OBSERVER(RenderViewObserver, observers_,
                     DidFinishDocumentLoad(frame));
 }
 
-void RenderViewImpl::didHandleOnloadEvents(WebFrame* frame) {
+void RenderViewImpl::didHandleOnloadEvents(WebLocalFrame* frame) {
   if (webview()->mainFrame() == frame) {
     Send(new ViewHostMsg_DocumentOnLoadCompletedInMainFrame(routing_id_,
                                                             page_id_));
   }
 }
 
-void RenderViewImpl::didFailLoad(WebFrame* frame, const WebURLError& error) {
+void RenderViewImpl::didFailLoad(WebLocalFrame* frame,
+                                 const WebURLError& error) {
   FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidFailLoad(frame, error));
 }
 
-void RenderViewImpl::didFinishLoad(WebFrame* frame) {
+void RenderViewImpl::didFinishLoad(WebLocalFrame* frame) {
   FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidFinishLoad(frame));
 }
 
-void RenderViewImpl::didNavigateWithinPage(
-    WebFrame* frame,
-    bool is_new_navigation) {
+void RenderViewImpl::didNavigateWithinPage(WebLocalFrame* frame,
+                                           bool is_new_navigation) {
   // TODO(nasko): Forward calls to the main RenderFrameImpl until all
   // callers of this method on RenderView are removed.
   main_render_frame_->didNavigateWithinPage(frame, is_new_navigation);
 }
 
-void RenderViewImpl::didUpdateCurrentHistoryItem(WebFrame* frame) {
+void RenderViewImpl::didUpdateCurrentHistoryItem(WebLocalFrame* frame) {
   StartNavStateSyncTimerIfNecessary();
 }
 
-void RenderViewImpl::willSendRequest(WebFrame* frame,
+void RenderViewImpl::willSendRequest(WebLocalFrame* frame,
                                      unsigned identifier,
                                      WebURLRequest& request,
                                      const WebURLResponse& redirect_response) {
   NOTREACHED();
 }
 
-void RenderViewImpl::didReceiveResponse(
-    WebFrame* frame, unsigned identifier, const WebURLResponse& response) {
+void RenderViewImpl::didReceiveResponse(WebLocalFrame* frame,
+                                        unsigned identifier,
+                                        const WebURLResponse& response) {
   NOTREACHED();
 }
 
-void RenderViewImpl::didFinishResourceLoad(
-    WebFrame* frame, unsigned identifier) {
+void RenderViewImpl::didFinishResourceLoad(WebLocalFrame* frame,
+                                           unsigned identifier) {
   InternalDocumentStateData* internal_data =
       InternalDocumentStateData::FromDataSource(frame->dataSource());
   if (!internal_data->use_error_page())
     return;
 
   // Do not show error page when DevTools is attached.
   if (devtools_agent_->IsAttached())
     return;
 
   // Display error page, if appropriate.
   std::string error_domain = "http";
   int http_status_code = internal_data->http_status_code();
   if (GetContentClient()->renderer()->HasErrorPage(
           http_status_code, &error_domain)) {
     WebURLError error;
     error.unreachableURL = frame->document().url();
     error.domain = WebString::fromUTF8(error_domain);
     error.reason = http_status_code;
     LoadNavigationErrorPage(frame, frame->dataSource()->request(), error, true);
   }
 }
 
 void RenderViewImpl::didLoadResourceFromMemoryCache(
-    WebFrame* frame, const WebURLRequest& request,
+    WebLocalFrame* frame,
+    const WebURLRequest& request,
     const WebURLResponse& response) {
   NOTREACHED();
 }
 
-void RenderViewImpl::didDisplayInsecureContent(WebFrame* frame) {
+void RenderViewImpl::didDisplayInsecureContent(WebLocalFrame* frame) {
   NOTREACHED();
 }
 
-void RenderViewImpl::didRunInsecureContent(
-    WebFrame* frame, const WebSecurityOrigin& origin, const WebURL& target) {
+void RenderViewImpl::didRunInsecureContent(WebLocalFrame* frame,
+                                           const WebSecurityOrigin& origin,
+                                           const WebURL& target) {
   NOTREACHED();
 }
 
-void RenderViewImpl::didCreateScriptContext(WebFrame* frame,
+void RenderViewImpl::didCreateScriptContext(WebLocalFrame* frame,
                                             v8::Handle<v8::Context> context,
                                             int extension_group,
                                             int world_id) {
   NOTREACHED();
 }
 
-void RenderViewImpl::willReleaseScriptContext(WebFrame* frame,
+void RenderViewImpl::willReleaseScriptContext(WebLocalFrame* frame,
                                               v8::Handle<v8::Context> context,
                                               int world_id) {
   NOTREACHED();
 }
 
 void RenderViewImpl::CheckPreferredSize() {
   // We don't always want to send the change messages over IPC, only if we've
   // been put in that mode by getting a |ViewMsg_EnablePreferredSizeChangedMode|
   // message.
   if (!send_preferred_size_changes_ || !webview())
@@ skipping 42 matching lines @@
       media_stream_dispatcher_,
       RenderThreadImpl::current()->GetMediaStreamDependencyFactory());
   media_stream_client_ = media_stream_impl;
   web_user_media_client_ = media_stream_impl;
   return true;
 #else
   return false;
 #endif
 }
 
-void RenderViewImpl::didChangeContentsSize(WebFrame* frame,
+void RenderViewImpl::didChangeContentsSize(WebLocalFrame* frame,
                                            const WebSize& size) {
   if (webview()->mainFrame() != frame)
     return;
   WebView* frameView = frame->view();
   if (!frameView)
     return;
 
   bool has_horizontal_scrollbar = frame->hasHorizontalScrollbar();
   bool has_vertical_scrollbar = frame->hasVerticalScrollbar();
 
@@ skipping 20 matching lines @@
     Send(new ViewHostMsg_DidChangeScrollOffsetPinningForMainFrame(
           routing_id_, is_pinned_to_left, is_pinned_to_right));
 
     cached_is_main_frame_pinned_to_left_ = is_pinned_to_left;
     cached_is_main_frame_pinned_to_right_ = is_pinned_to_right;
   }
 
   Send(new ViewHostMsg_DidChangeScrollOffset(routing_id_));
 }
 
-void RenderViewImpl::didChangeScrollOffset(WebFrame* frame) {
+void RenderViewImpl::didChangeScrollOffset(WebLocalFrame* frame) {
   StartNavStateSyncTimerIfNecessary();
 
   if (webview()->mainFrame() == frame)
     UpdateScrollState(frame);
 
   FOR_EACH_OBSERVER(
       RenderViewObserver, observers_, DidChangeScrollOffset(frame));
 }
 
-void RenderViewImpl::willInsertBody(blink::WebFrame* frame) {
+void RenderViewImpl::willInsertBody(blink::WebLocalFrame* frame) {
   NOTREACHED();
 }
 
-void RenderViewImpl::didFirstVisuallyNonEmptyLayout(WebFrame* frame) {
+void RenderViewImpl::didFirstVisuallyNonEmptyLayout(WebLocalFrame* frame) {
   if (frame != webview()->mainFrame())
     return;
 
   InternalDocumentStateData* data =
       InternalDocumentStateData::FromDataSource(frame->dataSource());
   data->set_did_first_visually_non_empty_layout(true);
 
 #if defined(OS_ANDROID)
   // Update body background color if necessary.
   SkColor bg_color = webwidget_->backgroundColor();
@@ skipping 30 matching lines @@
   NOTREACHED();
 }
 
 void RenderViewImpl::reportFindInPageSelection(int request_id,
                                                int active_match_ordinal,
                                                const WebRect& selection_rect) {
   NOTREACHED();
 }
 
 void RenderViewImpl::requestStorageQuota(
-    WebFrame* frame,
+    WebLocalFrame* frame,
     WebStorageQuotaType type,
     unsigned long long requested_size,
     blink::WebStorageQuotaCallbacks callbacks) {
   NOTREACHED();
 }
 
 bool RenderViewImpl::willCheckAndDispatchMessageEvent(
-    blink::WebFrame* sourceFrame,
+    blink::WebLocalFrame* sourceFrame,
     blink::WebFrame* targetFrame,
     blink::WebSecurityOrigin target_origin,
     blink::WebDOMMessageEvent event) {
   if (!is_swapped_out_)
     return false;
 
   ViewMsg_PostMessage_Params params;
   params.data = event.data().toString();
   params.source_origin = event.origin();
   if (!target_origin.isNull())
@@ skipping 26 matching lines @@
   Send(new ViewHostMsg_RouteMessageEvent(routing_id_, params));
   return true;
 }
 
 void RenderViewImpl::willOpenSocketStream(
     WebSocketStreamHandle* handle) {
   NOTREACHED();
 }
 
 void RenderViewImpl::willStartUsingPeerConnectionHandler(
-    blink::WebFrame* frame, blink::WebRTCPeerConnectionHandler* handler) {
+    blink::WebLocalFrame* frame,
+    blink::WebRTCPeerConnectionHandler* handler) {
   NOTREACHED();
 }
 
 blink::WebString RenderViewImpl::acceptLanguages() {
   return WebString::fromUTF8(renderer_preferences_.accept_languages);
 }
 
-blink::WebString RenderViewImpl::userAgentOverride(
-    blink::WebFrame* frame,
-    const blink::WebURL& url) {
+blink::WebString RenderViewImpl::userAgentOverride(blink::WebLocalFrame* frame,
+                                                   const blink::WebURL& url) {
   NOTREACHED();
   return blink::WebString();
 }
 
-WebString RenderViewImpl::doNotTrackValue(WebFrame* frame) {
+WebString RenderViewImpl::doNotTrackValue(WebLocalFrame* frame) {
   NOTREACHED();
   return blink::WebString();
 }
 
-bool RenderViewImpl::allowWebGL(WebFrame* frame, bool default_value) {
+bool RenderViewImpl::allowWebGL(WebLocalFrame* frame, bool default_value) {
   NOTREACHED();
   return false;
 }
 
-void RenderViewImpl::didLoseWebGLContext(
-    blink::WebFrame* frame,
-    int arb_robustness_status_code) {
+void RenderViewImpl::didLoseWebGLContext(blink::WebLocalFrame* frame,
+                                         int arb_robustness_status_code) {
   NOTREACHED();
 }
 
 // blink::WebPageSerializerClient implementation ------------------------------
 
 void RenderViewImpl::didSerializeDataForFrame(
     const WebURL& frame_url,
     const WebCString& data,
     WebPageSerializerClient::PageSerializationStatus status) {
   Send(new ViewHostMsg_SendSerializedHtmlData(
@@ skipping 90 matching lines @@
 }
 
 float RenderViewImpl::GetFilteredTimePerFrame() const {
   return filtered_time_per_frame();
 }
 
 blink::WebPageVisibilityState RenderViewImpl::GetVisibilityState() const {
   return visibilityState();
 }
 
-void RenderViewImpl::RunModalAlertDialog(blink::WebFrame* frame,
+void RenderViewImpl::RunModalAlertDialog(blink::WebLocalFrame* frame,
                                          const blink::WebString& message) {
   return runModalAlertDialog(frame, message);
 }
 
 void RenderViewImpl::DidStartLoading() {
   main_render_frame_->didStartLoading(true);
 }
 
 void RenderViewImpl::DidStopLoading() {
   main_render_frame_->didStopLoading();
@@ skipping 620 matching lines @@
     const base::FilePath& local_directory_name) {
 
   // Convert std::vector of GURLs to WebVector<WebURL>
   WebVector<WebURL> weburl_links(links);
 
   // Convert std::vector of base::FilePath to WebVector<WebString>
   WebVector<WebString> webstring_paths(local_paths.size());
   for (size_t i = 0; i < local_paths.size(); i++)
     webstring_paths[i] = local_paths[i].AsUTF16Unsafe();
 
-  WebPageSerializer::serialize(webview()->mainFrame(), true, this, weburl_links,
+  WebPageSerializer::serialize(webview()->mainFrame()->toWebLocalFrame(),
+                               true,
+                               this,
+                               weburl_links,
                                webstring_paths,
                                local_directory_name.AsUTF16Unsafe());
 }
 
 void RenderViewImpl::OnSuppressDialogsUntilSwapOut() {
   // Don't show any more dialogs until we finish OnSwapOut.
   suppress_dialogs_until_swap_out_ = true;
 }
 
 void RenderViewImpl::NavigateToSwappedOutURL(blink::WebFrame* frame) {
@@ skipping 461 matching lines @@
           it != plugin_delegates_.end(); ++it) {
       (*it)->ImeCompositionCompleted(text, focused_plugin_id_);
     }
     return;
   }
 #endif  // OS_WIN
 #endif  // ENABLE_PLUGINS
   if (replacement_range.IsValid() && webview()) {
     // Select the text in |replacement_range|, it will then be replaced by
     // text added by the call to RenderWidget::OnImeConfirmComposition().
-    if (WebFrame* frame = webview()->focusedFrame()) {
+    if (WebLocalFrame* frame = webview()->focusedFrame()->toWebLocalFrame()) {
       WebRange webrange = WebRange::fromDocumentRange(
           frame, replacement_range.start(), replacement_range.length());
       if (!webrange.isNull())
         frame->selectRange(webrange);
     }
   }
   RenderWidget::OnImeConfirmComposition(text,
                                         replacement_range,
                                         keep_selection);
 }
@@ skipping 632 matching lines @@
     std::vector<gfx::Size> sizes(icon_urls[i].sizes().size());
     ConvertToFaviconSizes(icon_urls[i].sizes(), &sizes);
     if (!url.isEmpty())
       urls.push_back(
           FaviconURL(url, ToFaviconType(icon_urls[i].iconType()), sizes));
   }
   SendUpdateFaviconURL(urls);
 }
 
 }  // namespace content