Conversion of content_shell target to use WebLocalFrame.

Fairly straightforward, as the locations where I had to add conversions
should only ever expect to be called in the context of a local frame.

BUG=346764

Review URL: https://codereview.chromium.org/222973003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@261764 0039d316-1c4b-4281-b951-d872f2087c98

33 files changed, 484 insertions, 468 deletions

diff --git a/content/public/renderer/render_frame.h b/content/public/renderer/render_frame.h
index f7de446..19feb7d 100644
--- a/content/public/renderer/render_frame.h
+++ b/content/public/renderer/render_frame.h
@@ -9,6 +9,8 @@
 #include "content/common/content_export.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_sender.h"
+// TODO(dcheng): Convert back to a forward declare.
+#include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebNavigationPolicy.h"
 
 struct WebPreferences;
@@ -77,10 +79,9 @@ class CONTENT_EXPORT RenderFrame : public IPC::Listener,
       const blink::WebPluginParams& params) = 0;
 
   // The client should handle the navigation externally.
-  virtual void LoadURLExternally(
-      blink::WebFrame* frame,
-      const blink::WebURLRequest& request,
-      blink::WebNavigationPolicy policy) = 0;
+  virtual void LoadURLExternally(blink::WebLocalFrame* frame,
+                                 const blink::WebURLRequest& request,
+                                 blink::WebNavigationPolicy policy) = 0;
 
   // Execute a string of JavaScript in this frame's context.
   virtual void ExecuteJavaScript(const base::string16& javascript) = 0;
diff --git a/content/public/renderer/render_view.h b/content/public/renderer/render_view.h
index 60de1c4..2fe09a5 100644
--- a/content/public/renderer/render_view.h
+++ b/content/public/renderer/render_view.h
@@ -12,6 +12,8 @@
 #include "content/common/content_export.h"
 #include "content/public/common/top_controls_state.h"
 #include "ipc/ipc_sender.h"
+// TODO(dcheng): Convert back to a forward declare.
+#include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebPageVisibilityState.h"
 #include "ui/gfx/native_widget_types.h"
 
@@ -105,7 +107,7 @@ class CONTENT_EXPORT RenderView : public IPC::Sender {
 
   // Displays a modal alert dialog containing the given message.  Returns
   // once the user dismisses the dialog.
-  virtual void RunModalAlertDialog(blink::WebFrame* frame,
+  virtual void RunModalAlertDialog(blink::WebLocalFrame* frame,
                                    const blink::WebString& message) = 0;
 
   // Used by plugins that load data in this RenderView to update the loading
diff --git a/content/public/renderer/render_view_observer.h b/content/public/renderer/render_view_observer.h
index aed5a2f..e0a4ee2 100644
--- a/content/public/renderer/render_view_observer.h
+++ b/content/public/renderer/render_view_observer.h
@@ -12,6 +12,8 @@
 #include "ipc/ipc_sender.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebIconURL.h"
+// TODO(dcheng): Temporary. Convert back to a forward declare.
+#include "third_party/WebKit/public/web/WebLocalFrame.h"
 
 class GURL;
 
@@ -52,37 +54,38 @@ class CONTENT_EXPORT RenderViewObserver : public IPC::Listener,
   // These match the WebKit API notifications
   virtual void DidStartLoading() {}
   virtual void DidStopLoading() {}
-  virtual void DidFinishDocumentLoad(blink::WebFrame* frame) {}
-  virtual void DidFailLoad(blink::WebFrame* frame,
+  virtual void DidFinishDocumentLoad(blink::WebLocalFrame* frame) {}
+  virtual void DidFailLoad(blink::WebLocalFrame* frame,
                            const blink::WebURLError& error) {}
-  virtual void DidFinishLoad(blink::WebFrame* frame) {}
-  virtual void DidStartProvisionalLoad(blink::WebFrame* frame) {}
-  virtual void DidFailProvisionalLoad(blink::WebFrame* frame,
+  virtual void DidFinishLoad(blink::WebLocalFrame* frame) {}
+  virtual void DidStartProvisionalLoad(blink::WebLocalFrame* frame) {}
+  virtual void DidFailProvisionalLoad(blink::WebLocalFrame* frame,
                                       const blink::WebURLError& error) {}
-  virtual void DidCommitProvisionalLoad(blink::WebFrame* frame,
+  virtual void DidCommitProvisionalLoad(blink::WebLocalFrame* frame,
                                         bool is_new_navigation) {}
-  virtual void DidClearWindowObject(blink::WebFrame* frame, int world_id) {}
-  virtual void DidCreateDocumentElement(blink::WebFrame* frame) {}
-  virtual void FrameCreated(blink::WebFrame* parent,
+  virtual void DidClearWindowObject(blink::WebLocalFrame* frame, int world_id) {
+  }
+  virtual void DidCreateDocumentElement(blink::WebLocalFrame* frame) {}
+  virtual void FrameCreated(blink::WebLocalFrame* parent,
                             blink::WebFrame* frame) {}
   virtual void FrameDetached(blink::WebFrame* frame) {}
   virtual void FrameWillClose(blink::WebFrame* frame) {}
   virtual void DidMatchCSS(
-      blink::WebFrame* frame,
+      blink::WebLocalFrame* frame,
       const blink::WebVector<blink::WebString>& newly_matching_selectors,
       const blink::WebVector<blink::WebString>& stopped_matching_selectors) {}
-  virtual void WillSendSubmitEvent(blink::WebFrame* frame,
+  virtual void WillSendSubmitEvent(blink::WebLocalFrame* frame,
                                    const blink::WebFormElement& form) {}
-  virtual void WillSubmitForm(blink::WebFrame* frame,
+  virtual void WillSubmitForm(blink::WebLocalFrame* frame,
                               const blink::WebFormElement& form) {}
-  virtual void DidCreateDataSource(blink::WebFrame* frame,
+  virtual void DidCreateDataSource(blink::WebLocalFrame* frame,
                                    blink::WebDataSource* ds) {}
-  virtual void PrintPage(blink::WebFrame* frame, bool user_initiated) {}
+  virtual void PrintPage(blink::WebLocalFrame* frame, bool user_initiated) {}
   virtual void FocusedNodeChanged(const blink::WebNode& node) {}
-  virtual void WillCreateMediaPlayer(blink::WebFrame* frame,
+  virtual void WillCreateMediaPlayer(blink::WebLocalFrame* frame,
                                      blink::WebMediaPlayerClient* client) {}
   virtual void ZoomLevelChanged() {};
-  virtual void DidChangeScrollOffset(blink::WebFrame* frame) {}
+  virtual void DidChangeScrollOffset(blink::WebLocalFrame* frame) {}
   virtual void DraggableRegionsChanged(blink::WebFrame* frame) {}
   virtual void DidCommitCompositorFrame() {}
   virtual void DidUpdateLayout() {}
diff --git a/content/public/test/render_view_test.cc b/content/public/test/render_view_test.cc
index d89209b..e01965f 100644
--- a/content/public/test/render_view_test.cc
+++ b/content/public/test/render_view_test.cc
@@ -357,7 +357,7 @@ bool RenderViewTest::OnMessageReceived(const IPC::Message& msg) {
   return impl->OnMessageReceived(msg);
 }
 
-void RenderViewTest::DidNavigateWithinPage(blink::WebFrame* frame,
+void RenderViewTest::DidNavigateWithinPage(blink::WebLocalFrame* frame,
                                            bool is_new_navigation) {
   RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
   impl->didNavigateWithinPage(frame, is_new_navigation);
diff --git a/content/public/test/render_view_test.h b/content/public/test/render_view_test.h
index 87ae5b9..1f40e99 100644
--- a/content/public/test/render_view_test.h
+++ b/content/public/test/render_view_test.h
@@ -119,7 +119,8 @@ class RenderViewTest : public testing::Test {
 
   // These are all methods from RenderViewImpl that we expose to testing code.
   bool OnMessageReceived(const IPC::Message& msg);
-  void DidNavigateWithinPage(blink::WebFrame* frame, bool is_new_navigation);
+  void DidNavigateWithinPage(blink::WebLocalFrame* frame,
+                             bool is_new_navigation);
   void SendContentStateImmediately();
   blink::WebWidget* GetWebWidget();
 
diff --git a/content/renderer/accessibility/renderer_accessibility_complete.cc b/content/renderer/accessibility/renderer_accessibility_complete.cc
index cd17e24..e5dd980 100644
--- a/content/renderer/accessibility/renderer_accessibility_complete.cc
+++ b/content/renderer/accessibility/renderer_accessibility_complete.cc
@@ -92,7 +92,7 @@ void RendererAccessibilityComplete::FocusedNodeChanged(const WebNode& node) {
   }
 }
 
-void RendererAccessibilityComplete::DidFinishLoad(blink::WebFrame* frame) {
+void RendererAccessibilityComplete::DidFinishLoad(blink::WebLocalFrame* frame) {
   const WebDocument& document = GetMainDocument();
   if (document.isNull())
     return;
diff --git a/content/renderer/accessibility/renderer_accessibility_complete.h b/content/renderer/accessibility/renderer_accessibility_complete.h
index 16eeeae..227c72a 100644
--- a/content/renderer/accessibility/renderer_accessibility_complete.h
+++ b/content/renderer/accessibility/renderer_accessibility_complete.h
@@ -43,7 +43,7 @@ class CONTENT_EXPORT RendererAccessibilityComplete
   // RenderView::Observer implementation.
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
   virtual void FocusedNodeChanged(const blink::WebNode& node) OVERRIDE;
-  virtual void DidFinishLoad(blink::WebFrame* frame) OVERRIDE;
+  virtual void DidFinishLoad(blink::WebLocalFrame* frame) OVERRIDE;
 
   // RendererAccessibility.
   virtual void HandleWebAccessibilityEvent(
diff --git a/content/renderer/accessibility/renderer_accessibility_focus_only.cc b/content/renderer/accessibility/renderer_accessibility_focus_only.cc
index cebba6f..972916c 100644
--- a/content/renderer/accessibility/renderer_accessibility_focus_only.cc
+++ b/content/renderer/accessibility/renderer_accessibility_focus_only.cc
@@ -49,7 +49,8 @@ void RendererAccessibilityFocusOnly::FocusedNodeChanged(const WebNode& node) {
   HandleFocusedNodeChanged(node, true);
 }
 
-void RendererAccessibilityFocusOnly::DidFinishLoad(blink::WebFrame* frame) {
+void RendererAccessibilityFocusOnly::DidFinishLoad(
+    blink::WebLocalFrame* frame) {
   WebView* view = render_view()->GetWebView();
   if (view->focusedFrame() != frame)
     return;
diff --git a/content/renderer/accessibility/renderer_accessibility_focus_only.h b/content/renderer/accessibility/renderer_accessibility_focus_only.h
index f5152fd..806cd4b 100644
--- a/content/renderer/accessibility/renderer_accessibility_focus_only.h
+++ b/content/renderer/accessibility/renderer_accessibility_focus_only.h
@@ -59,7 +59,7 @@ class RendererAccessibilityFocusOnly : public RendererAccessibility {
 
   // RenderView::Observer implementation.
   virtual void FocusedNodeChanged(const blink::WebNode& node) OVERRIDE;
-  virtual void DidFinishLoad(blink::WebFrame* frame) OVERRIDE;
+  virtual void DidFinishLoad(blink::WebLocalFrame* frame) OVERRIDE;
 
  private:
   void HandleFocusedNodeChanged(const blink::WebNode& node,
diff --git a/content/renderer/media/crypto/pepper_cdm_wrapper_impl.cc b/content/renderer/media/crypto/pepper_cdm_wrapper_impl.cc
index 69059cd..73de599 100644
--- a/content/renderer/media/crypto/pepper_cdm_wrapper_impl.cc
+++ b/content/renderer/media/crypto/pepper_cdm_wrapper_impl.cc
@@ -21,7 +21,7 @@ void WebHelperPluginDeleter::operator()(blink::WebHelperPlugin* plugin) const {
 }
 
 scoped_ptr<PepperCdmWrapper> PepperCdmWrapperImpl::Create(
-    blink::WebFrame* frame,
+    blink::WebLocalFrame* frame,
     const std::string& pluginType) {
   DCHECK(frame);
   ScopedHelperPlugin helper_plugin(blink::WebHelperPlugin::create(
diff --git a/content/renderer/media/crypto/pepper_cdm_wrapper_impl.h b/content/renderer/media/crypto/pepper_cdm_wrapper_impl.h
index df037e8..75009a2c 100644
--- a/content/renderer/media/crypto/pepper_cdm_wrapper_impl.h
+++ b/content/renderer/media/crypto/pepper_cdm_wrapper_impl.h
@@ -13,9 +13,10 @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/renderer/media/crypto/pepper_cdm_wrapper.h"
+// TODO(dcheng): Temporary. Convert back to a forward declare.
+#include "third_party/WebKit/public/web/WebLocalFrame.h"
 
 namespace blink {
-class WebFrame;
 class WebHelperPlugin;
 }
 
@@ -40,7 +41,7 @@ struct WebHelperPluginDeleter {
 // blink:: objects.
 class PepperCdmWrapperImpl : public PepperCdmWrapper {
  public:
-  static scoped_ptr<PepperCdmWrapper> Create(blink::WebFrame* frame,
+  static scoped_ptr<PepperCdmWrapper> Create(blink::WebLocalFrame* frame,
                                              const std::string& pluginType);
 
   virtual ~PepperCdmWrapperImpl();
diff --git a/content/renderer/media/webcontentdecryptionmodule_impl.cc b/content/renderer/media/webcontentdecryptionmodule_impl.cc
index bdb9f4e..e99859f 100644
--- a/content/renderer/media/webcontentdecryptionmodule_impl.cc
+++ b/content/renderer/media/webcontentdecryptionmodule_impl.cc
@@ -31,7 +31,7 @@ class WebFrame;
 namespace content {
 
 WebContentDecryptionModuleImpl* WebContentDecryptionModuleImpl::Create(
-    blink::WebFrame* frame,
+    blink::WebLocalFrame* frame,
     const blink::WebSecurityOrigin& security_origin,
     const base::string16& key_system) {
   DCHECK(frame);
diff --git a/content/renderer/media/webcontentdecryptionmodule_impl.h b/content/renderer/media/webcontentdecryptionmodule_impl.h
index 38df1a0..ca9c218 100644
--- a/content/renderer/media/webcontentdecryptionmodule_impl.h
+++ b/content/renderer/media/webcontentdecryptionmodule_impl.h
@@ -11,9 +11,10 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string16.h"
 #include "third_party/WebKit/public/platform/WebContentDecryptionModule.h"
+// TODO(dcheng): Remove and convert back to a forward declare.
+#include "third_party/WebKit/public/web/WebLocalFrame.h"
 
 namespace blink {
-class WebFrame;
 class WebSecurityOrigin;
 }
 
@@ -31,7 +32,7 @@ class WebContentDecryptionModuleImpl
     : public blink::WebContentDecryptionModule {
  public:
   static WebContentDecryptionModuleImpl* Create(
-      blink::WebFrame* frame,
+      blink::WebLocalFrame* frame,
       const blink::WebSecurityOrigin& security_origin,
       const base::string16& key_system);
 
diff --git a/content/renderer/media/webmediaplayer_impl.cc b/content/renderer/media/webmediaplayer_impl.cc
index 813e103..451317e 100644
--- a/content/renderer/media/webmediaplayer_impl.cc
+++ b/content/renderer/media/webmediaplayer_impl.cc
@@ -140,7 +140,7 @@ static void LogMediaSourceError(const scoped_refptr<media::MediaLog>& media_log,
 }
 
 WebMediaPlayerImpl::WebMediaPlayerImpl(
-    blink::WebFrame* frame,
+    blink::WebLocalFrame* frame,
     blink::WebMediaPlayerClient* client,
     base::WeakPtr<WebMediaPlayerDelegate> delegate,
     const WebMediaPlayerParams& params)
diff --git a/content/renderer/media/webmediaplayer_impl.h b/content/renderer/media/webmediaplayer_impl.h
index 60d0138..d59b7c2a 100644
--- a/content/renderer/media/webmediaplayer_impl.h
+++ b/content/renderer/media/webmediaplayer_impl.h
@@ -27,13 +27,14 @@
 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayer.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerClient.h"
+// TODO(dcheng): Convert back to forward declare.
+#include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "url/gurl.h"
 
 class RenderAudioSourceProvider;
 
 namespace blink {
 class WebContentDecryptionModule;
-class WebFrame;
 }
 
 namespace base {
@@ -68,11 +69,10 @@ class WebMediaPlayerImpl
  public:
   // Constructs a WebMediaPlayer implementation using Chromium's media stack.
   // |delegate| may be null.
-  WebMediaPlayerImpl(
-      blink::WebFrame* frame,
-      blink::WebMediaPlayerClient* client,
-      base::WeakPtr<WebMediaPlayerDelegate> delegate,
-      const WebMediaPlayerParams& params);
+  WebMediaPlayerImpl(blink::WebLocalFrame* frame,
+                     blink::WebMediaPlayerClient* client,
+                     base::WeakPtr<WebMediaPlayerDelegate> delegate,
+                     const WebMediaPlayerParams& params);
   virtual ~WebMediaPlayerImpl();
 
   virtual void load(LoadType load_type,
@@ -238,7 +238,7 @@ class WebMediaPlayerImpl
   // NULL immediately and reset.
   void SetDecryptorReadyCB(const media::DecryptorReadyCB& decryptor_ready_cb);
 
-  blink::WebFrame* frame_;
+  blink::WebLocalFrame* frame_;
 
   // TODO(hclam): get rid of these members and read from the pipeline directly.
   blink::WebMediaPlayer::NetworkState network_state_;
diff --git a/content/renderer/pepper/resource_converter.cc b/content/renderer/pepper/resource_converter.cc
index ac90364..d18e19e0 100644
--- a/content/renderer/pepper/resource_converter.cc
+++ b/content/renderer/pepper/resource_converter.cc
@@ -132,7 +132,7 @@ bool ResourceHostToDOMFileSystem(
   blink::WebFileSystemType blink_type;
   if (!FileApiFileSystemTypeToWebFileSystemType(type, &blink_type))
     return false;
-  blink::WebFrame* frame = blink::WebFrame::frameForContext(context);
+  blink::WebLocalFrame* frame = blink::WebLocalFrame::frameForContext(context);
   blink::WebDOMFileSystem web_dom_file_system = blink::WebDOMFileSystem::create(
       frame,
       blink_type,
diff --git a/content/renderer/render_frame_impl.cc b/content/renderer/render_frame_impl.cc
index 3b80b81..b18c551 100644
--- a/content/renderer/render_frame_impl.cc
+++ b/content/renderer/render_frame_impl.cc
@@ -109,6 +109,7 @@ using blink::WebElement;
 using blink::WebFrame;
 using blink::WebHistoryItem;
 using blink::WebHTTPBody;
+using blink::WebLocalFrame;
 using blink::WebNavigationPolicy;
 using blink::WebNavigationType;
 using blink::WebNode;
@@ -330,7 +331,7 @@ RenderFrameImpl::~RenderFrameImpl() {
   RenderThread::Get()->RemoveRoute(routing_id_);
 }
 
-void RenderFrameImpl::SetWebFrame(blink::WebFrame* web_frame) {
+void RenderFrameImpl::SetWebFrame(blink::WebLocalFrame* web_frame) {
   DCHECK(!frame_);
 
   std::pair<FrameMap::iterator, bool> result = g_frame_map.Get().insert(
@@ -1156,10 +1157,9 @@ blink::WebPlugin* RenderFrameImpl::CreatePlugin(
 #endif
 }
 
-void RenderFrameImpl::LoadURLExternally(
-    blink::WebFrame* frame,
-    const blink::WebURLRequest& request,
-    blink::WebNavigationPolicy policy) {
+void RenderFrameImpl::LoadURLExternally(blink::WebLocalFrame* frame,
+                                        const blink::WebURLRequest& request,
+                                        blink::WebNavigationPolicy policy) {
   DCHECK(!frame_ || frame_ == frame);
   loadURLExternally(frame, request, policy);
 }
@@ -1176,7 +1176,7 @@ void RenderFrameImpl::OnChildFrameProcessGone() {
 // blink::WebFrameClient implementation ----------------------------------------
 
 blink::WebPlugin* RenderFrameImpl::createPlugin(
-    blink::WebFrame* frame,
+    blink::WebLocalFrame* frame,
     const blink::WebPluginParams& params) {
   DCHECK_EQ(frame_, frame);
   blink::WebPlugin* plugin = NULL;
@@ -1209,7 +1209,7 @@ blink::WebPlugin* RenderFrameImpl::createPlugin(
 }
 
 blink::WebMediaPlayer* RenderFrameImpl::createMediaPlayer(
-    blink::WebFrame* frame,
+    blink::WebLocalFrame* frame,
     const blink::WebURL& url,
     blink::WebMediaPlayerClient* client) {
   DCHECK(!frame_ || frame_ == frame);
@@ -1221,7 +1221,7 @@ blink::WebMediaPlayer* RenderFrameImpl::createMediaPlayer(
 
 blink::WebContentDecryptionModule*
 RenderFrameImpl::createContentDecryptionModule(
-    blink::WebFrame* frame,
+    blink::WebLocalFrame* frame,
     const blink::WebSecurityOrigin& security_origin,
     const blink::WebString& key_system) {
   DCHECK(!frame_ || frame_ == frame);
@@ -1230,7 +1230,7 @@ RenderFrameImpl::createContentDecryptionModule(
 }
 
 blink::WebApplicationCacheHost* RenderFrameImpl::createApplicationCacheHost(
-    blink::WebFrame* frame,
+    blink::WebLocalFrame* frame,
     blink::WebApplicationCacheHostClient* client) {
   if (!frame || !frame->view())
     return NULL;
@@ -1241,7 +1241,8 @@ blink::WebApplicationCacheHost* RenderFrameImpl::createApplicationCacheHost(
 }
 
 blink::WebWorkerPermissionClientProxy*
-RenderFrameImpl::createWorkerPermissionClientProxy(blink::WebFrame* frame) {
+RenderFrameImpl::createWorkerPermissionClientProxy(
+    blink::WebLocalFrame* frame) {
   if (!frame || !frame->view())
     return NULL;
   DCHECK(!frame_ || frame_ == frame);
@@ -1249,13 +1250,13 @@ RenderFrameImpl::createWorkerPermissionClientProxy(blink::WebFrame* frame) {
       this, frame);
 }
 
-blink::WebCookieJar* RenderFrameImpl::cookieJar(blink::WebFrame* frame) {
+blink::WebCookieJar* RenderFrameImpl::cookieJar(blink::WebLocalFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
   return &cookie_jar_;
 }
 
 blink::WebServiceWorkerProvider* RenderFrameImpl::createServiceWorkerProvider(
-    blink::WebFrame* frame) {
+    blink::WebLocalFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
   // At this point we should have non-null data source.
   DCHECK(frame->dataSource());
@@ -1269,13 +1270,13 @@ blink::WebServiceWorkerProvider* RenderFrameImpl::createServiceWorkerProvider(
       ChildThread::current()->thread_safe_sender(), provider_id);
 }
 
-void RenderFrameImpl::didAccessInitialDocument(blink::WebFrame* frame) {
+void RenderFrameImpl::didAccessInitialDocument(blink::WebLocalFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
   render_view_->didAccessInitialDocument(frame);
 }
 
 blink::WebFrame* RenderFrameImpl::createChildFrame(
-    blink::WebFrame* parent,
+    blink::WebLocalFrame* parent,
     const blink::WebString& name) {
   // Synchronously notify the browser of a child frame creation to get the
   // routing_id for the RenderFrame.
@@ -1300,14 +1301,14 @@ blink::WebFrame* RenderFrameImpl::createChildFrame(
 
   RenderFrameImpl* child_render_frame = RenderFrameImpl::Create(
       render_view_.get(), child_routing_id);
-  blink::WebFrame* web_frame = WebFrame::create(child_render_frame);
+  blink::WebLocalFrame* web_frame = WebLocalFrame::create(child_render_frame);
   parent->appendChild(web_frame);
   child_render_frame->SetWebFrame(web_frame);
 
   return web_frame;
 }
 
-void RenderFrameImpl::didDisownOpener(blink::WebFrame* frame) {
+void RenderFrameImpl::didDisownOpener(blink::WebLocalFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
   render_view_->didDisownOpener(frame);
 }
@@ -1367,7 +1368,7 @@ void RenderFrameImpl::willClose(blink::WebFrame* frame) {
   render_view_->willClose(frame);
 }
 
-void RenderFrameImpl::didChangeName(blink::WebFrame* frame,
+void RenderFrameImpl::didChangeName(blink::WebLocalFrame* frame,
                                     const blink::WebString& name) {
   DCHECK(!frame_ || frame_ == frame);
   if (!render_view_->renderer_preferences_.report_frame_name_changes)
@@ -1381,7 +1382,7 @@ void RenderFrameImpl::didChangeName(blink::WebFrame* frame,
 }
 
 void RenderFrameImpl::didMatchCSS(
-    blink::WebFrame* frame,
+    blink::WebLocalFrame* frame,
     const blink::WebVector<blink::WebString>& newly_matching_selectors,
     const blink::WebVector<blink::WebString>& stopped_matching_selectors) {
   DCHECK(!frame_ || frame_ == frame);
@@ -1445,7 +1446,7 @@ void RenderFrameImpl::didAddMessageToConsole(
                                             source_name));
 }
 
-void RenderFrameImpl::loadURLExternally(blink::WebFrame* frame,
+void RenderFrameImpl::loadURLExternally(blink::WebLocalFrame* frame,
                                         const blink::WebURLRequest& request,
                                         blink::WebNavigationPolicy policy) {
   DCHECK(!frame_ || frame_ == frame);
@@ -1453,7 +1454,7 @@ void RenderFrameImpl::loadURLExternally(blink::WebFrame* frame,
 }
 
 void RenderFrameImpl::loadURLExternally(
-    blink::WebFrame* frame,
+    blink::WebLocalFrame* frame,
     const blink::WebURLRequest& request,
     blink::WebNavigationPolicy policy,
     const blink::WebString& suggested_name) {
@@ -1469,7 +1470,7 @@ void RenderFrameImpl::loadURLExternally(
 }
 
 blink::WebNavigationPolicy RenderFrameImpl::decidePolicyForNavigation(
-    blink::WebFrame* frame,
+    blink::WebLocalFrame* frame,
     blink::WebDataSource::ExtraData* extra_data,
     const blink::WebURLRequest& request,
     blink::WebNavigationType type,
@@ -1485,7 +1486,7 @@ blink::WebHistoryItem RenderFrameImpl::historyItemForNewChildFrame(
   return render_view_->webview()->itemForNewChildFrame(frame);
 }
 
-void RenderFrameImpl::willSendSubmitEvent(blink::WebFrame* frame,
+void RenderFrameImpl::willSendSubmitEvent(blink::WebLocalFrame* frame,
                                           const blink::WebFormElement& form) {
   DCHECK(!frame_ || frame_ == frame);
   // Call back to RenderViewImpl for observers to be notified.
@@ -1493,7 +1494,7 @@ void RenderFrameImpl::willSendSubmitEvent(blink::WebFrame* frame,
   render_view_->willSendSubmitEvent(frame, form);
 }
 
-void RenderFrameImpl::willSubmitForm(blink::WebFrame* frame,
+void RenderFrameImpl::willSubmitForm(blink::WebLocalFrame* frame,
                                      const blink::WebFormElement& form) {
   DCHECK(!frame_ || frame_ == frame);
   DocumentState* document_state =
@@ -1518,7 +1519,7 @@ void RenderFrameImpl::willSubmitForm(blink::WebFrame* frame,
   render_view_->willSubmitForm(frame, form);
 }
 
-void RenderFrameImpl::didCreateDataSource(blink::WebFrame* frame,
+void RenderFrameImpl::didCreateDataSource(blink::WebLocalFrame* frame,
                                           blink::WebDataSource* datasource) {
   DCHECK(!frame_ || frame_ == frame);
 
@@ -1538,7 +1539,7 @@ void RenderFrameImpl::didCreateDataSource(blink::WebFrame* frame,
       network_provider.Pass());
 }
 
-void RenderFrameImpl::didStartProvisionalLoad(blink::WebFrame* frame) {
+void RenderFrameImpl::didStartProvisionalLoad(blink::WebLocalFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
   WebDataSource* ds = frame->provisionalDataSource();
 
@@ -1593,7 +1594,7 @@ void RenderFrameImpl::didStartProvisionalLoad(blink::WebFrame* frame) {
 }
 
 void RenderFrameImpl::didReceiveServerRedirectForProvisionalLoad(
-    blink::WebFrame* frame) {
+    blink::WebLocalFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
   render_view_->webview()->removeChildrenForRedirect(frame);
   if (frame->parent())
@@ -1616,9 +1617,8 @@ void RenderFrameImpl::didReceiveServerRedirectForProvisionalLoad(
   }
 }
 
-void RenderFrameImpl::didFailProvisionalLoad(
-    blink::WebFrame* frame,
-    const blink::WebURLError& error) {
+void RenderFrameImpl::didFailProvisionalLoad(blink::WebLocalFrame* frame,
+                                             const blink::WebURLError& error) {
   DCHECK(!frame_ || frame_ == frame);
   WebDataSource* ds = frame->provisionalDataSource();
   DCHECK(ds);
@@ -1729,7 +1729,7 @@ void RenderFrameImpl::didCommitProvisionalLoad(
   didCommitProvisionalLoad(frame, commit_type == blink::WebStandardCommit);
 }
 
-void RenderFrameImpl::didCommitProvisionalLoad(blink::WebFrame* frame,
+void RenderFrameImpl::didCommitProvisionalLoad(blink::WebLocalFrame* frame,
                                                bool is_new_navigation) {
   DCHECK(!frame_ || frame_ == frame);
   DocumentState* document_state =
@@ -1822,7 +1822,7 @@ void RenderFrameImpl::didCommitProvisionalLoad(blink::WebFrame* frame,
   render_view_->UpdateEncoding(frame, frame->view()->pageEncoding().utf8());
 }
 
-void RenderFrameImpl::didClearWindowObject(blink::WebFrame* frame,
+void RenderFrameImpl::didClearWindowObject(blink::WebLocalFrame* frame,
                                            int world_id) {
   DCHECK(!frame_ || frame_ == frame);
   // TODO(nasko): Move implementation here. Needed state:
@@ -1843,7 +1843,7 @@ void RenderFrameImpl::didClearWindowObject(blink::WebFrame* frame,
                     DidClearWindowObject(world_id));
 }
 
-void RenderFrameImpl::didCreateDocumentElement(blink::WebFrame* frame) {
+void RenderFrameImpl::didCreateDocumentElement(blink::WebLocalFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
 
   // Notify the browser about non-blank documents loading in the top frame.
@@ -1862,7 +1862,7 @@ void RenderFrameImpl::didCreateDocumentElement(blink::WebFrame* frame) {
   render_view_->didCreateDocumentElement(frame);
 }
 
-void RenderFrameImpl::didReceiveTitle(blink::WebFrame* frame,
+void RenderFrameImpl::didReceiveTitle(blink::WebLocalFrame* frame,
                                       const blink::WebString& title,
                                       blink::WebTextDirection direction) {
   DCHECK(!frame_ || frame_ == frame);
@@ -1870,14 +1870,14 @@ void RenderFrameImpl::didReceiveTitle(blink::WebFrame* frame,
   render_view_->didReceiveTitle(frame, title, direction);
 }
 
-void RenderFrameImpl::didChangeIcon(blink::WebFrame* frame,
+void RenderFrameImpl::didChangeIcon(blink::WebLocalFrame* frame,
                                     blink::WebIconURL::Type icon_type) {
   DCHECK(!frame_ || frame_ == frame);
   // TODO(nasko): Investigate wheather implementation should move here.
   render_view_->didChangeIcon(frame, icon_type);
 }
 
-void RenderFrameImpl::didFinishDocumentLoad(blink::WebFrame* frame) {
+void RenderFrameImpl::didFinishDocumentLoad(blink::WebLocalFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
   WebDataSource* ds = frame->dataSource();
   DocumentState* document_state = DocumentState::FromDataSource(ds);
@@ -1895,14 +1895,14 @@ void RenderFrameImpl::didFinishDocumentLoad(blink::WebFrame* frame) {
   render_view_->UpdateEncoding(frame, frame->view()->pageEncoding().utf8());
 }
 
-void RenderFrameImpl::didHandleOnloadEvents(blink::WebFrame* frame) {
+void RenderFrameImpl::didHandleOnloadEvents(blink::WebLocalFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
   // TODO(nasko): Move implementation here. Needed state:
   // * page_id_
   render_view_->didHandleOnloadEvents(frame);
 }
 
-void RenderFrameImpl::didFailLoad(blink::WebFrame* frame,
+void RenderFrameImpl::didFailLoad(blink::WebLocalFrame* frame,
                                   const blink::WebURLError& error) {
   DCHECK(!frame_ || frame_ == frame);
   // TODO(nasko): Move implementation here. No state needed.
@@ -1926,7 +1926,7 @@ void RenderFrameImpl::didFailLoad(blink::WebFrame* frame,
                                              error_description));
 }
 
-void RenderFrameImpl::didFinishLoad(blink::WebFrame* frame) {
+void RenderFrameImpl::didFinishLoad(blink::WebLocalFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
   WebDataSource* ds = frame->dataSource();
   DocumentState* document_state = DocumentState::FromDataSource(ds);
@@ -1970,7 +1970,7 @@ void RenderFrameImpl::didNavigateWithinPage(blink::WebFrame* frame,
   didCommitProvisionalLoad(frame, item, commit_type);
 }
 
-void RenderFrameImpl::didNavigateWithinPage(blink::WebFrame* frame,
+void RenderFrameImpl::didNavigateWithinPage(blink::WebLocalFrame* frame,
                                             bool is_new_navigation) {
   DCHECK(!frame_ || frame_ == frame);
   // If this was a reference fragment navigation that we initiated, then we
@@ -1990,7 +1990,7 @@ void RenderFrameImpl::didNavigateWithinPage(blink::WebFrame* frame,
   didCommitProvisionalLoad(frame, is_new_navigation);
 }
 
-void RenderFrameImpl::didUpdateCurrentHistoryItem(blink::WebFrame* frame) {
+void RenderFrameImpl::didUpdateCurrentHistoryItem(blink::WebLocalFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
   // TODO(nasko): Move implementation here. Needed methods:
   // * StartNavStateSyncTimerIfNecessary
@@ -2067,7 +2067,7 @@ void RenderFrameImpl::clearContextMenu() {
 }
 
 void RenderFrameImpl::willRequestAfterPreconnect(
-    blink::WebFrame* frame,
+    blink::WebLocalFrame* frame,
     blink::WebURLRequest& request) {
   DCHECK(!frame_ || frame_ == frame);
   // FIXME(kohei): This will never be set.
@@ -2085,7 +2085,7 @@ void RenderFrameImpl::willRequestAfterPreconnect(
 }
 
 void RenderFrameImpl::willSendRequest(
-    blink::WebFrame* frame,
+    blink::WebLocalFrame* frame,
     unsigned identifier,
     blink::WebURLRequest& request,
     const blink::WebURLResponse& redirect_response) {
@@ -2243,7 +2243,7 @@ void RenderFrameImpl::willSendRequest(
 }
 
 void RenderFrameImpl::didReceiveResponse(
-    blink::WebFrame* frame,
+    blink::WebLocalFrame* frame,
     unsigned identifier,
     const blink::WebURLResponse& response) {
   DCHECK(!frame_ || frame_ == frame);
@@ -2289,7 +2289,7 @@ void RenderFrameImpl::didReceiveResponse(
   internal_data->set_use_error_page(true);
 }
 
-void RenderFrameImpl::didFinishResourceLoad(blink::WebFrame* frame,
+void RenderFrameImpl::didFinishResourceLoad(blink::WebLocalFrame* frame,
                                             unsigned identifier) {
   DCHECK(!frame_ || frame_ == frame);
   // TODO(nasko): Move implementation here. Needed state:
@@ -2300,7 +2300,7 @@ void RenderFrameImpl::didFinishResourceLoad(blink::WebFrame* frame,
 }
 
 void RenderFrameImpl::didLoadResourceFromMemoryCache(
-    blink::WebFrame* frame,
+    blink::WebLocalFrame* frame,
     const blink::WebURLRequest& request,
     const blink::WebURLResponse& response) {
   DCHECK(!frame_ || frame_ == frame);
@@ -2323,14 +2323,14 @@ void RenderFrameImpl::didLoadResourceFromMemoryCache(
       ResourceType::FromTargetType(request.targetType())));
 }
 
-void RenderFrameImpl::didDisplayInsecureContent(blink::WebFrame* frame) {
+void RenderFrameImpl::didDisplayInsecureContent(blink::WebLocalFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
   render_view_->Send(new ViewHostMsg_DidDisplayInsecureContent(
       render_view_->GetRoutingID()));
 }
 
 void RenderFrameImpl::didRunInsecureContent(
-    blink::WebFrame* frame,
+    blink::WebLocalFrame* frame,
     const blink::WebSecurityOrigin& origin,
     const blink::WebURL& target) {
   DCHECK(!frame_ || frame_ == frame);
@@ -2340,7 +2340,7 @@ void RenderFrameImpl::didRunInsecureContent(
       target));
 }
 
-void RenderFrameImpl::didAbortLoading(blink::WebFrame* frame) {
+void RenderFrameImpl::didAbortLoading(blink::WebLocalFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
 #if defined(ENABLE_PLUGINS)
   if (frame != render_view_->webview()->mainFrame())
@@ -2350,7 +2350,7 @@ void RenderFrameImpl::didAbortLoading(blink::WebFrame* frame) {
 #endif
 }
 
-void RenderFrameImpl::didCreateScriptContext(blink::WebFrame* frame,
+void RenderFrameImpl::didCreateScriptContext(blink::WebLocalFrame* frame,
                                              v8::Handle<v8::Context> context,
                                              int extension_group,
                                              int world_id) {
@@ -2359,7 +2359,7 @@ void RenderFrameImpl::didCreateScriptContext(blink::WebFrame* frame,
       frame, context, extension_group, world_id);
 }
 
-void RenderFrameImpl::willReleaseScriptContext(blink::WebFrame* frame,
+void RenderFrameImpl::willReleaseScriptContext(blink::WebLocalFrame* frame,
                                                v8::Handle<v8::Context> context,
                                                int world_id) {
   DCHECK(!frame_ || frame_ == frame);
@@ -2369,12 +2369,13 @@ void RenderFrameImpl::willReleaseScriptContext(blink::WebFrame* frame,
                     WillReleaseScriptContext(context, world_id));
 }
 
-void RenderFrameImpl::didFirstVisuallyNonEmptyLayout(blink::WebFrame* frame) {
+void RenderFrameImpl::didFirstVisuallyNonEmptyLayout(
+    blink::WebLocalFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
   render_view_->didFirstVisuallyNonEmptyLayout(frame);
 }
 
-void RenderFrameImpl::didChangeContentsSize(blink::WebFrame* frame,
+void RenderFrameImpl::didChangeContentsSize(blink::WebLocalFrame* frame,
                                             const blink::WebSize& size) {
   DCHECK(!frame_ || frame_ == frame);
   // TODO(nasko): Move implementation here. Needed state:
@@ -2383,14 +2384,14 @@ void RenderFrameImpl::didChangeContentsSize(blink::WebFrame* frame,
   render_view_->didChangeContentsSize(frame, size);
 }
 
-void RenderFrameImpl::didChangeScrollOffset(blink::WebFrame* frame) {
+void RenderFrameImpl::didChangeScrollOffset(blink::WebLocalFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
   // TODO(nasko): Move implementation here. Needed methods:
   // * StartNavStateSyncTimerIfNecessary
   render_view_->didChangeScrollOffset(frame);
 }
 
-void RenderFrameImpl::willInsertBody(blink::WebFrame* frame) {
+void RenderFrameImpl::willInsertBody(blink::WebLocalFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
   if (!frame->parent()) {
     render_view_->Send(new ViewHostMsg_WillInsertBody(
@@ -2420,7 +2421,7 @@ void RenderFrameImpl::reportFindInPageSelection(
 }
 
 void RenderFrameImpl::requestStorageQuota(
-    blink::WebFrame* frame,
+    blink::WebLocalFrame* frame,
     blink::WebStorageQuotaType type,
     unsigned long long requested_size,
     blink::WebStorageQuotaCallbacks callbacks) {
@@ -2445,7 +2446,7 @@ void RenderFrameImpl::willOpenSocketStream(
 }
 
 void RenderFrameImpl::willStartUsingPeerConnectionHandler(
-    blink::WebFrame* frame,
+    blink::WebLocalFrame* frame,
     blink::WebRTCPeerConnectionHandler* handler) {
   DCHECK(!frame_ || frame_ == frame);
 #if defined(ENABLE_WEBRTC)
@@ -2454,7 +2455,7 @@ void RenderFrameImpl::willStartUsingPeerConnectionHandler(
 }
 
 bool RenderFrameImpl::willCheckAndDispatchMessageEvent(
-    blink::WebFrame* sourceFrame,
+    blink::WebLocalFrame* sourceFrame,
     blink::WebFrame* targetFrame,
     blink::WebSecurityOrigin targetOrigin,
     blink::WebDOMMessageEvent event) {
@@ -2465,9 +2466,8 @@ bool RenderFrameImpl::willCheckAndDispatchMessageEvent(
       sourceFrame, targetFrame, targetOrigin, event);
 }
 
-blink::WebString RenderFrameImpl::userAgentOverride(
-    blink::WebFrame* frame,
-    const blink::WebURL& url) {
+blink::WebString RenderFrameImpl::userAgentOverride(blink::WebLocalFrame* frame,
+                                                    const blink::WebURL& url) {
   DCHECK(!frame_ || frame_ == frame);
   if (!render_view_->webview() || !render_view_->webview()->mainFrame() ||
       render_view_->renderer_preferences_.user_agent_override.empty()) {
@@ -2491,14 +2491,15 @@ blink::WebString RenderFrameImpl::userAgentOverride(
   return blink::WebString();
 }
 
-blink::WebString RenderFrameImpl::doNotTrackValue(blink::WebFrame* frame) {
+blink::WebString RenderFrameImpl::doNotTrackValue(blink::WebLocalFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
   if (render_view_->renderer_preferences_.enable_do_not_track)
     return WebString::fromUTF8("1");
   return WebString();
 }
 
-bool RenderFrameImpl::allowWebGL(blink::WebFrame* frame, bool default_value) {
+bool RenderFrameImpl::allowWebGL(blink::WebLocalFrame* frame,
+                                 bool default_value) {
   DCHECK(!frame_ || frame_ == frame);
   if (!default_value)
     return false;
@@ -2512,7 +2513,7 @@ bool RenderFrameImpl::allowWebGL(blink::WebFrame* frame, bool default_value) {
   return !blocked;
 }
 
-void RenderFrameImpl::didLoseWebGLContext(blink::WebFrame* frame,
+void RenderFrameImpl::didLoseWebGLContext(blink::WebLocalFrame* frame,
                                           int arb_robustness_status_code) {
   DCHECK(!frame_ || frame_ == frame);
   render_view_->Send(new ViewHostMsg_DidLose3DContext(
diff --git a/content/renderer/render_frame_impl.h b/content/renderer/render_frame_impl.h
index b8654f8..6ccc95b 100644
--- a/content/renderer/render_frame_impl.h
+++ b/content/renderer/render_frame_impl.h
@@ -92,8 +92,9 @@ class CONTENT_EXPORT RenderFrameImpl
   // Returns the RenderWidget associated with this frame.
   RenderWidget* GetRenderWidget();
 
-  // This is called right after creation with the WebFrame for this RenderFrame.
-  void SetWebFrame(blink::WebFrame* web_frame);
+  // This is called right after creation with the WebLocalFrame for this
+  // RenderFrame.
+  void SetWebFrame(blink::WebLocalFrame* web_frame);
 
   // Notification from RenderView.
   virtual void OnStop();
@@ -182,43 +183,41 @@ class CONTENT_EXPORT RenderFrameImpl
       blink::WebFrame* frame,
       const WebPluginInfo& info,
       const blink::WebPluginParams& params) OVERRIDE;
-  virtual void LoadURLExternally(
-      blink::WebFrame* frame,
-      const blink::WebURLRequest& request,
-      blink::WebNavigationPolicy policy) OVERRIDE;
+  virtual void LoadURLExternally(blink::WebLocalFrame* frame,
+                                 const blink::WebURLRequest& request,
+                                 blink::WebNavigationPolicy policy) OVERRIDE;
   virtual void ExecuteJavaScript(const base::string16& javascript) OVERRIDE;
 
   // blink::WebFrameClient implementation -------------------------------------
-  virtual blink::WebPlugin* createPlugin(
-      blink::WebFrame* frame,
-      const blink::WebPluginParams& params);
+  virtual blink::WebPlugin* createPlugin(blink::WebLocalFrame* frame,
+                                         const blink::WebPluginParams& params);
   virtual blink::WebMediaPlayer* createMediaPlayer(
-      blink::WebFrame* frame,
+      blink::WebLocalFrame* frame,
       const blink::WebURL& url,
       blink::WebMediaPlayerClient* client);
   virtual blink::WebContentDecryptionModule* createContentDecryptionModule(
-      blink::WebFrame* frame,
+      blink::WebLocalFrame* frame,
       const blink::WebSecurityOrigin& security_origin,
       const blink::WebString& key_system);
   virtual blink::WebApplicationCacheHost* createApplicationCacheHost(
-      blink::WebFrame* frame,
+      blink::WebLocalFrame* frame,
       blink::WebApplicationCacheHostClient* client);
   virtual blink::WebWorkerPermissionClientProxy*
-      createWorkerPermissionClientProxy(blink::WebFrame* frame);
-  virtual blink::WebCookieJar* cookieJar(blink::WebFrame* frame);
+      createWorkerPermissionClientProxy(blink::WebLocalFrame* frame);
+  virtual blink::WebCookieJar* cookieJar(blink::WebLocalFrame* frame);
   virtual blink::WebServiceWorkerProvider* createServiceWorkerProvider(
-      blink::WebFrame* frame);
-  virtual void didAccessInitialDocument(blink::WebFrame* frame);
-  virtual blink::WebFrame* createChildFrame(blink::WebFrame* parent,
-                                             const blink::WebString& name);
-  virtual void didDisownOpener(blink::WebFrame* frame);
+      blink::WebLocalFrame* frame);
+  virtual void didAccessInitialDocument(blink::WebLocalFrame* frame);
+  virtual blink::WebFrame* createChildFrame(blink::WebLocalFrame* parent,
+                                            const blink::WebString& name);
+  virtual void didDisownOpener(blink::WebLocalFrame* frame);
   virtual void frameDetached(blink::WebFrame* frame);
   virtual void frameFocused();
   virtual void willClose(blink::WebFrame* frame);
-  virtual void didChangeName(blink::WebFrame* frame,
+  virtual void didChangeName(blink::WebLocalFrame* frame,
                              const blink::WebString& name);
   virtual void didMatchCSS(
-      blink::WebFrame* frame,
+      blink::WebLocalFrame* frame,
       const blink::WebVector<blink::WebString>& newly_matching_selectors,
       const blink::WebVector<blink::WebString>& stopped_matching_selectors);
   virtual bool shouldReportDetailedMessageForSource(
@@ -227,17 +226,16 @@ class CONTENT_EXPORT RenderFrameImpl
                                       const blink::WebString& source_name,
                                       unsigned source_line,
                                       const blink::WebString& stack_trace);
-  virtual void loadURLExternally(blink::WebFrame* frame,
+  virtual void loadURLExternally(blink::WebLocalFrame* frame,
                                  const blink::WebURLRequest& request,
                                  blink::WebNavigationPolicy policy);
-  virtual void loadURLExternally(
-      blink::WebFrame* frame,
-      const blink::WebURLRequest& request,
-      blink::WebNavigationPolicy policy,
-      const blink::WebString& suggested_name);
+  virtual void loadURLExternally(blink::WebLocalFrame* frame,
+                                 const blink::WebURLRequest& request,
+                                 blink::WebNavigationPolicy policy,
+                                 const blink::WebString& suggested_name);
   // The WebDataSource::ExtraData* is assumed to be a DocumentState* subclass.
   virtual blink::WebNavigationPolicy decidePolicyForNavigation(
-      blink::WebFrame* frame,
+      blink::WebLocalFrame* frame,
       blink::WebDataSource::ExtraData* extra_data,
       const blink::WebURLRequest& request,
       blink::WebNavigationType type,
@@ -245,13 +243,13 @@ class CONTENT_EXPORT RenderFrameImpl
       bool is_redirect);
   virtual blink::WebHistoryItem historyItemForNewChildFrame(
       blink::WebFrame* frame);
-  virtual void willSendSubmitEvent(blink::WebFrame* frame,
+  virtual void willSendSubmitEvent(blink::WebLocalFrame* frame,
                                    const blink::WebFormElement& form);
-  virtual void willSubmitForm(blink::WebFrame* frame,
+  virtual void willSubmitForm(blink::WebLocalFrame* frame,
                               const blink::WebFormElement& form);
-  virtual void didCreateDataSource(blink::WebFrame* frame,
+  virtual void didCreateDataSource(blink::WebLocalFrame* frame,
                                    blink::WebDataSource* datasource);
-  virtual void didStartProvisionalLoad(blink::WebFrame* frame);
+  virtual void didStartProvisionalLoad(blink::WebLocalFrame* frame);
   virtual void didReceiveServerRedirectForProvisionalLoad(
       blink::WebFrame* frame);
   virtual void didFailProvisionalLoad(
@@ -262,91 +260,87 @@ class CONTENT_EXPORT RenderFrameImpl
       const blink::WebHistoryItem& item,
       blink::WebHistoryCommitType commit_type);
   // DEPRECATED
-  virtual void didCommitProvisionalLoad(blink::WebFrame* frame,
+  virtual void didCommitProvisionalLoad(blink::WebLocalFrame* frame,
                                         bool is_new_navigation);
-  virtual void didClearWindowObject(blink::WebFrame* frame, int world_id);
-  virtual void didCreateDocumentElement(blink::WebFrame* frame);
-  virtual void didReceiveTitle(blink::WebFrame* frame,
+  virtual void didClearWindowObject(blink::WebLocalFrame* frame, int world_id);
+  virtual void didCreateDocumentElement(blink::WebLocalFrame* frame);
+  virtual void didReceiveTitle(blink::WebLocalFrame* frame,
                                const blink::WebString& title,
                                blink::WebTextDirection direction);
-  virtual void didChangeIcon(blink::WebFrame* frame,
+  virtual void didChangeIcon(blink::WebLocalFrame* frame,
                              blink::WebIconURL::Type icon_type);
-  virtual void didFinishDocumentLoad(blink::WebFrame* frame);
-  virtual void didHandleOnloadEvents(blink::WebFrame* frame);
-  virtual void didFailLoad(blink::WebFrame* frame,
+  virtual void didFinishDocumentLoad(blink::WebLocalFrame* frame);
+  virtual void didHandleOnloadEvents(blink::WebLocalFrame* frame);
+  virtual void didFailLoad(blink::WebLocalFrame* frame,
                            const blink::WebURLError& error);
   virtual void didFinishLoad(blink::WebFrame* frame);
   virtual void didNavigateWithinPage(blink::WebFrame* frame,
                                      const blink::WebHistoryItem& item,
                                      blink::WebHistoryCommitType commit_type);
   // DEPRECATED
-  virtual void didNavigateWithinPage(blink::WebFrame* frame,
+  virtual void didNavigateWithinPage(blink::WebLocalFrame* frame,
                                      bool is_new_navigation);
-  virtual void didUpdateCurrentHistoryItem(blink::WebFrame* frame);
+  virtual void didUpdateCurrentHistoryItem(blink::WebLocalFrame* frame);
   virtual void didChangeSelection(bool is_empty_selection);
   virtual void showContextMenu(const blink::WebContextMenuData& data);
   virtual void clearContextMenu();
-  virtual void willRequestAfterPreconnect(blink::WebFrame* frame,
+  virtual void willRequestAfterPreconnect(blink::WebLocalFrame* frame,
                                           blink::WebURLRequest& request);
-  virtual void willSendRequest(
-      blink::WebFrame* frame,
-      unsigned identifier,
-      blink::WebURLRequest& request,
-      const blink::WebURLResponse& redirect_response);
-  virtual void didReceiveResponse(
-      blink::WebFrame* frame,
-      unsigned identifier,
-      const blink::WebURLResponse& response);
-  virtual void didFinishResourceLoad(blink::WebFrame* frame,
+  virtual void willSendRequest(blink::WebLocalFrame* frame,
+                               unsigned identifier,
+                               blink::WebURLRequest& request,
+                               const blink::WebURLResponse& redirect_response);
+  virtual void didReceiveResponse(blink::WebLocalFrame* frame,
+                                  unsigned identifier,
+                                  const blink::WebURLResponse& response);
+  virtual void didFinishResourceLoad(blink::WebLocalFrame* frame,
                                      unsigned identifier);
   virtual void didLoadResourceFromMemoryCache(
-      blink::WebFrame* frame,
+      blink::WebLocalFrame* frame,
       const blink::WebURLRequest& request,
       const blink::WebURLResponse& response);
-  virtual void didDisplayInsecureContent(blink::WebFrame* frame);
-  virtual void didRunInsecureContent(blink::WebFrame* frame,
+  virtual void didDisplayInsecureContent(blink::WebLocalFrame* frame);
+  virtual void didRunInsecureContent(blink::WebLocalFrame* frame,
                                      const blink::WebSecurityOrigin& origin,
                                      const blink::WebURL& target);
-  virtual void didAbortLoading(blink::WebFrame* frame);
-  virtual void didCreateScriptContext(blink::WebFrame* frame,
+  virtual void didAbortLoading(blink::WebLocalFrame* frame);
+  virtual void didCreateScriptContext(blink::WebLocalFrame* frame,
                                       v8::Handle<v8::Context> context,
                                       int extension_group,
                                       int world_id);
-  virtual void willReleaseScriptContext(blink::WebFrame* frame,
+  virtual void willReleaseScriptContext(blink::WebLocalFrame* frame,
                                         v8::Handle<v8::Context> context,
                                         int world_id);
-  virtual void didFirstVisuallyNonEmptyLayout(blink::WebFrame* frame);
-  virtual void didChangeContentsSize(blink::WebFrame* frame,
+  virtual void didFirstVisuallyNonEmptyLayout(blink::WebLocalFrame* frame);
+  virtual void didChangeContentsSize(blink::WebLocalFrame* frame,
                                      const blink::WebSize& size);
-  virtual void didChangeScrollOffset(blink::WebFrame* frame);
-  virtual void willInsertBody(blink::WebFrame* frame);
+  virtual void didChangeScrollOffset(blink::WebLocalFrame* frame);
+  virtual void willInsertBody(blink::WebLocalFrame* frame);
   virtual void reportFindInPageMatchCount(int request_id,
                                           int count,
                                           bool final_update);
   virtual void reportFindInPageSelection(int request_id,
                                          int active_match_ordinal,
                                          const blink::WebRect& sel);
-  virtual void requestStorageQuota(
-      blink::WebFrame* frame,
-      blink::WebStorageQuotaType type,
-      unsigned long long requested_size,
-      blink::WebStorageQuotaCallbacks callbacks);
+  virtual void requestStorageQuota(blink::WebLocalFrame* frame,
+                                   blink::WebStorageQuotaType type,
+                                   unsigned long long requested_size,
+                                   blink::WebStorageQuotaCallbacks callbacks);
   virtual void willOpenSocketStream(
       blink::WebSocketStreamHandle* handle);
   virtual void willStartUsingPeerConnectionHandler(
-      blink::WebFrame* frame,
+      blink::WebLocalFrame* frame,
       blink::WebRTCPeerConnectionHandler* handler);
   virtual bool willCheckAndDispatchMessageEvent(
-      blink::WebFrame* sourceFrame,
+      blink::WebLocalFrame* sourceFrame,
       blink::WebFrame* targetFrame,
       blink::WebSecurityOrigin targetOrigin,
       blink::WebDOMMessageEvent event);
-  virtual blink::WebString userAgentOverride(
-      blink::WebFrame* frame,
-      const blink::WebURL& url);
-  virtual blink::WebString doNotTrackValue(blink::WebFrame* frame);
-  virtual bool allowWebGL(blink::WebFrame* frame, bool default_value);
-  virtual void didLoseWebGLContext(blink::WebFrame* frame,
+  virtual blink::WebString userAgentOverride(blink::WebLocalFrame* frame,
+                                             const blink::WebURL& url);
+  virtual blink::WebString doNotTrackValue(blink::WebLocalFrame* frame);
+  virtual bool allowWebGL(blink::WebLocalFrame* frame, bool default_value);
+  virtual void didLoseWebGLContext(blink::WebLocalFrame* frame,
                                    int arb_robustness_status_code);
   virtual void forwardInputEvent(const blink::WebInputEvent* event);
   virtual void initializeChildFrame(const blink::WebRect& frame_rect,
@@ -451,8 +445,8 @@ class CONTENT_EXPORT RenderFrameImpl
       const gfx::Range& selection_range,
       const ContextMenuParams& params);
 
-  // Stores the WebFrame we are associated with.
-  blink::WebFrame* frame_;
+  // Stores the WebLocalFrame we are associated with.
+  blink::WebLocalFrame* frame_;
 
   base::WeakPtr<RenderViewImpl> render_view_;
   int routing_id_;
diff --git a/content/renderer/render_view_impl.cc b/content/renderer/render_view_impl.cc
index 9830d69..26d6b53 100644
--- a/content/renderer/render_view_impl.cc
+++ b/content/renderer/render_view_impl.cc
@@ -166,6 +166,7 @@
 #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"
@@ -271,6 +272,7 @@ using blink::WebIconURL;
 using blink::WebImage;
 using blink::WebInputElement;
 using blink::WebInputEvent;
+using blink::WebLocalFrame;
 using blink::WebMediaPlayer;
 using blink::WebMediaPlayerAction;
 using blink::WebMediaPlayerClient;
@@ -778,10 +780,10 @@ void RenderViewImpl::Initialize(RenderViewImplParams* params) {
 
   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);
@@ -1468,13 +1470,12 @@ void RenderViewImpl::OnWindowSnapshotCompleted(const int snapshot_id,
 
 // 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();
@@ -1602,7 +1603,7 @@ WebStorageNamespace* RenderViewImpl::createSessionStorageNamespace() {
   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_));
 }
@@ -1735,7 +1736,7 @@ bool RenderViewImpl::runFileChooser(
   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,
@@ -1744,7 +1745,7 @@ void RenderViewImpl::runModalAlertDialog(WebFrame* frame,
                        NULL);
 }
 
-bool RenderViewImpl::runModalConfirmDialog(WebFrame* frame,
+bool RenderViewImpl::runModalConfirmDialog(WebLocalFrame* frame,
                                            const WebString& message) {
   return RunJavaScriptMessage(JAVASCRIPT_MESSAGE_TYPE_CONFIRM,
                               message,
@@ -1753,7 +1754,7 @@ bool RenderViewImpl::runModalConfirmDialog(WebFrame* frame,
                               NULL);
 }
 
-bool RenderViewImpl::runModalPromptDialog(WebFrame* frame,
+bool RenderViewImpl::runModalPromptDialog(WebLocalFrame* frame,
                                           const WebString& message,
                                           const WebString& default_value,
                                           WebString* actual_value) {
@@ -1768,8 +1769,8 @@ bool RenderViewImpl::runModalPromptDialog(WebFrame* frame,
   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)
@@ -1777,8 +1778,9 @@ bool RenderViewImpl::runModalBeforeUnloadDialog(
   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.
@@ -1906,7 +1908,7 @@ void RenderViewImpl::setKeyboardFocusURL(const WebURL& 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,
@@ -2149,14 +2151,16 @@ void RenderViewImpl::initializeLayerTreeView() {
 // 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(
@@ -2180,14 +2184,14 @@ blink::WebMediaPlayer* RenderViewImpl::CreateMediaPlayer(
 #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
@@ -2212,7 +2216,7 @@ void RenderViewImpl::willClose(WebFrame* frame) {
 }
 
 void RenderViewImpl::didMatchCSS(
-    WebFrame* frame,
+    WebLocalFrame* frame,
     const WebVector<WebString>& newly_matching_selectors,
     const WebVector<WebString>& stopped_matching_selectors) {
   FOR_EACH_OBSERVER(
@@ -2254,19 +2258,20 @@ 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.
@@ -2444,10 +2449,9 @@ void RenderViewImpl::ProcessViewLayoutFlags(const CommandLine& command_line) {
 }
 
 // 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.
   //
@@ -2459,7 +2463,7 @@ void RenderViewImpl::didFailProvisionalLoad(WebFrame* frame,
       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));
@@ -2476,7 +2480,7 @@ void RenderViewImpl::didCommitProvisionalLoad(WebFrame* frame,
   }
 }
 
-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));
 
@@ -2499,12 +2503,13 @@ void RenderViewImpl::didClearWindowObject(WebFrame* frame, int world_id) {
     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);
 
@@ -2512,7 +2517,7 @@ void RenderViewImpl::didReceiveTitle(WebFrame* frame, const WebString& title,
   UpdateEncoding(frame, frame->view()->pageEncoding().utf8());
 }
 
-void RenderViewImpl::didChangeIcon(WebFrame* frame,
+void RenderViewImpl::didChangeIcon(WebLocalFrame* frame,
                                    WebIconURL::Type icon_type) {
   if (frame->parent())
     return;
@@ -2531,52 +2536,53 @@ void RenderViewImpl::didChangeIcon(WebFrame* frame,
   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())
@@ -2600,28 +2606,30 @@ void RenderViewImpl::didFinishResourceLoad(
 }
 
 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();
@@ -2684,7 +2692,7 @@ bool RenderViewImpl::InitializeMediaStreamClient() {
 #endif
 }
 
-void RenderViewImpl::didChangeContentsSize(WebFrame* frame,
+void RenderViewImpl::didChangeContentsSize(WebLocalFrame* frame,
                                            const WebSize& size) {
   if (webview()->mainFrame() != frame)
     return;
@@ -2725,7 +2733,7 @@ void RenderViewImpl::UpdateScrollState(WebFrame* frame) {
   Send(new ViewHostMsg_DidChangeScrollOffset(routing_id_));
 }
 
-void RenderViewImpl::didChangeScrollOffset(WebFrame* frame) {
+void RenderViewImpl::didChangeScrollOffset(WebLocalFrame* frame) {
   StartNavStateSyncTimerIfNecessary();
 
   if (webview()->mainFrame() == frame)
@@ -2735,11 +2743,11 @@ void RenderViewImpl::didChangeScrollOffset(WebFrame* frame) {
       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;
 
@@ -2790,7 +2798,7 @@ void RenderViewImpl::reportFindInPageSelection(int request_id,
 }
 
 void RenderViewImpl::requestStorageQuota(
-    WebFrame* frame,
+    WebLocalFrame* frame,
     WebStorageQuotaType type,
     unsigned long long requested_size,
     blink::WebStorageQuotaCallbacks callbacks) {
@@ -2798,7 +2806,7 @@ void RenderViewImpl::requestStorageQuota(
 }
 
 bool RenderViewImpl::willCheckAndDispatchMessageEvent(
-    blink::WebFrame* sourceFrame,
+    blink::WebLocalFrame* sourceFrame,
     blink::WebFrame* targetFrame,
     blink::WebSecurityOrigin target_origin,
     blink::WebDOMMessageEvent event) {
@@ -2845,7 +2853,8 @@ void RenderViewImpl::willOpenSocketStream(
 }
 
 void RenderViewImpl::willStartUsingPeerConnectionHandler(
-    blink::WebFrame* frame, blink::WebRTCPeerConnectionHandler* handler) {
+    blink::WebLocalFrame* frame,
+    blink::WebRTCPeerConnectionHandler* handler) {
   NOTREACHED();
 }
 
@@ -2853,26 +2862,24 @@ 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();
 }
 
@@ -2983,7 +2990,7 @@ 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);
 }
@@ -3624,7 +3631,10 @@ void RenderViewImpl::OnGetSerializedHtmlDataForCurrentPageWithLocalLinks(
   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());
 }
@@ -4106,7 +4116,7 @@ void RenderViewImpl::OnImeConfirmComposition(
   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())
diff --git a/content/renderer/render_view_impl.h b/content/renderer/render_view_impl.h
index a1aec93..b11af11 100644
--- a/content/renderer/render_view_impl.h
+++ b/content/renderer/render_view_impl.h
@@ -353,11 +353,10 @@ class CONTENT_EXPORT RenderViewImpl
 
   // Temporary call until all this media code moves to RenderFrame.
   // TODO(jam): remove me
-  blink::WebMediaPlayer* CreateMediaPlayer(
-      RenderFrame* render_frame,
-      blink::WebFrame* frame,
-      const blink::WebURL& url,
-      blink::WebMediaPlayerClient* client);
+  blink::WebMediaPlayer* CreateMediaPlayer(RenderFrame* render_frame,
+                                           blink::WebLocalFrame* frame,
+                                           const blink::WebURL& url,
+                                           blink::WebMediaPlayerClient* client);
   // Returns the length of the session history of this RenderView. Note that
   // this only coincides with the actual length of the session history if this
   // RenderView is the currently active RenderView of a WebContents.
@@ -413,19 +412,18 @@ class CONTENT_EXPORT RenderViewImpl
 
   // blink::WebViewClient implementation --------------------------------------
 
-  virtual blink::WebView* createView(
-      blink::WebFrame* creator,
-      const blink::WebURLRequest& request,
-      const blink::WebWindowFeatures& features,
-      const blink::WebString& frame_name,
-      blink::WebNavigationPolicy policy,
-      bool suppress_opener);
+  virtual blink::WebView* createView(blink::WebLocalFrame* creator,
+                                     const blink::WebURLRequest& request,
+                                     const blink::WebWindowFeatures& features,
+                                     const blink::WebString& frame_name,
+                                     blink::WebNavigationPolicy policy,
+                                     bool suppress_opener);
   virtual blink::WebWidget* createPopupMenu(blink::WebPopupType popup_type);
   virtual blink::WebExternalPopupMenu* createExternalPopupMenu(
       const blink::WebPopupMenuInfo& popup_menu_info,
       blink::WebExternalPopupMenuClient* popup_menu_client);
   virtual blink::WebStorageNamespace* createSessionStorageNamespace();
-  virtual void printPage(blink::WebFrame* frame);
+  virtual void printPage(blink::WebLocalFrame* frame);
   virtual blink::WebNotificationPresenter* notificationPresenter();
   virtual bool enumerateChosenDirectory(
       const blink::WebString& path,
@@ -440,15 +438,15 @@ class CONTENT_EXPORT RenderViewImpl
   virtual bool runFileChooser(
       const blink::WebFileChooserParams& params,
       blink::WebFileChooserCompletion* chooser_completion);
-  virtual void runModalAlertDialog(blink::WebFrame* frame,
+  virtual void runModalAlertDialog(blink::WebLocalFrame* frame,
                                    const blink::WebString& message);
-  virtual bool runModalConfirmDialog(blink::WebFrame* frame,
+  virtual bool runModalConfirmDialog(blink::WebLocalFrame* frame,
                                      const blink::WebString& message);
-  virtual bool runModalPromptDialog(blink::WebFrame* frame,
+  virtual bool runModalPromptDialog(blink::WebLocalFrame* frame,
                                     const blink::WebString& message,
                                     const blink::WebString& default_value,
                                     blink::WebString* actual_value);
-  virtual bool runModalBeforeUnloadDialog(blink::WebFrame* frame,
+  virtual bool runModalBeforeUnloadDialog(blink::WebLocalFrame* frame,
                                           bool is_reload,
                                           const blink::WebString& message);
   virtual void showValidationMessage(const blink::WebRect& anchor_in_root_view,
@@ -460,12 +458,12 @@ class CONTENT_EXPORT RenderViewImpl
       const blink::WebRect& anchor_in_root_view) OVERRIDE;
 
   // DEPRECATED
-  virtual bool runModalBeforeUnloadDialog(blink::WebFrame* frame,
+  virtual bool runModalBeforeUnloadDialog(blink::WebLocalFrame* frame,
                                           const blink::WebString& message);
   virtual void setStatusText(const blink::WebString& text);
   virtual void setMouseOverURL(const blink::WebURL& url);
   virtual void setKeyboardFocusURL(const blink::WebURL& url);
-  virtual void startDragging(blink::WebFrame* frame,
+  virtual void startDragging(blink::WebLocalFrame* frame,
                              const blink::WebDragData& data,
                              blink::WebDragOperationsMask mask,
                              const blink::WebImage& image,
@@ -521,72 +519,70 @@ class CONTENT_EXPORT RenderViewImpl
   // blink::WebFrameClient implementation -------------------------------------
 
   virtual blink::WebMediaPlayer* createMediaPlayer(
-      blink::WebFrame* frame,
+      blink::WebLocalFrame* frame,
       const blink::WebURL& url,
       blink::WebMediaPlayerClient* client);
-  virtual void didAccessInitialDocument(blink::WebFrame* frame);
-  virtual void didDisownOpener(blink::WebFrame* frame);
+  virtual void didAccessInitialDocument(blink::WebLocalFrame* frame);
+  virtual void didDisownOpener(blink::WebLocalFrame* frame);
   virtual void frameDetached(blink::WebFrame* frame);
   virtual void willClose(blink::WebFrame* frame);
   virtual void didMatchCSS(
-      blink::WebFrame* frame,
+      blink::WebLocalFrame* frame,
       const blink::WebVector<blink::WebString>& newly_matching_selectors,
       const blink::WebVector<blink::WebString>& stopped_matching_selectors);
-  virtual void willSendSubmitEvent(blink::WebFrame* frame,
+  virtual void willSendSubmitEvent(blink::WebLocalFrame* frame,
                                    const blink::WebFormElement& form);
-  virtual void willSubmitForm(blink::WebFrame* frame,
+  virtual void willSubmitForm(blink::WebLocalFrame* frame,
                               const blink::WebFormElement& form);
-  virtual void didCreateDataSource(blink::WebFrame* frame,
+  virtual void didCreateDataSource(blink::WebLocalFrame* frame,
                                    blink::WebDataSource* datasource);
-  virtual void didStartProvisionalLoad(blink::WebFrame* frame);
-  virtual void didFailProvisionalLoad(blink::WebFrame* frame,
+  virtual void didStartProvisionalLoad(blink::WebLocalFrame* frame);
+  virtual void didFailProvisionalLoad(blink::WebLocalFrame* frame,
                                       const blink::WebURLError& error);
-  virtual void didCommitProvisionalLoad(blink::WebFrame* frame,
+  virtual void didCommitProvisionalLoad(blink::WebLocalFrame* frame,
                                         bool is_new_navigation);
-  virtual void didClearWindowObject(blink::WebFrame* frame, int world_id);
-  virtual void didCreateDocumentElement(blink::WebFrame* frame);
-  virtual void didReceiveTitle(blink::WebFrame* frame,
+  virtual void didClearWindowObject(blink::WebLocalFrame* frame, int world_id);
+  virtual void didCreateDocumentElement(blink::WebLocalFrame* frame);
+  virtual void didReceiveTitle(blink::WebLocalFrame* frame,
                                const blink::WebString& title,
                                blink::WebTextDirection direction);
-  virtual void didChangeIcon(blink::WebFrame*,
-                             blink::WebIconURL::Type);
-  virtual void didFinishDocumentLoad(blink::WebFrame* frame);
-  virtual void didHandleOnloadEvents(blink::WebFrame* frame);
-  virtual void didFailLoad(blink::WebFrame* frame,
+  virtual void didChangeIcon(blink::WebLocalFrame*, blink::WebIconURL::Type);
+  virtual void didFinishDocumentLoad(blink::WebLocalFrame* frame);
+  virtual void didHandleOnloadEvents(blink::WebLocalFrame* frame);
+  virtual void didFailLoad(blink::WebLocalFrame* frame,
                            const blink::WebURLError& error);
-  virtual void didFinishLoad(blink::WebFrame* frame);
-  virtual void didNavigateWithinPage(blink::WebFrame* frame,
+  virtual void didFinishLoad(blink::WebLocalFrame* frame);
+  virtual void didNavigateWithinPage(blink::WebLocalFrame* frame,
                                      bool is_new_navigation);
-  virtual void didUpdateCurrentHistoryItem(blink::WebFrame* frame);
-  virtual void willSendRequest(blink::WebFrame* frame,
+  virtual void didUpdateCurrentHistoryItem(blink::WebLocalFrame* frame);
+  virtual void willSendRequest(blink::WebLocalFrame* frame,
                                unsigned identifier,
                                blink::WebURLRequest& request,
                                const blink::WebURLResponse& redirect_response);
-  virtual void didReceiveResponse(blink::WebFrame* frame,
+  virtual void didReceiveResponse(blink::WebLocalFrame* frame,
                                   unsigned identifier,
                                   const blink::WebURLResponse& response);
-  virtual void didFinishResourceLoad(blink::WebFrame* frame,
+  virtual void didFinishResourceLoad(blink::WebLocalFrame* frame,
                                      unsigned identifier);
   virtual void didLoadResourceFromMemoryCache(
-      blink::WebFrame* frame,
+      blink::WebLocalFrame* frame,
       const blink::WebURLRequest& request,
       const blink::WebURLResponse&);
-  virtual void didDisplayInsecureContent(blink::WebFrame* frame);
-  virtual void didRunInsecureContent(
-      blink::WebFrame* frame,
-      const blink::WebSecurityOrigin& origin,
-      const blink::WebURL& target);
-  virtual void didCreateScriptContext(blink::WebFrame* frame,
+  virtual void didDisplayInsecureContent(blink::WebLocalFrame* frame);
+  virtual void didRunInsecureContent(blink::WebLocalFrame* frame,
+                                     const blink::WebSecurityOrigin& origin,
+                                     const blink::WebURL& target);
+  virtual void didCreateScriptContext(blink::WebLocalFrame* frame,
                                       v8::Handle<v8::Context>,
                                       int extension_group,
                                       int world_id);
-  virtual void willReleaseScriptContext(blink::WebFrame* frame,
+  virtual void willReleaseScriptContext(blink::WebLocalFrame* frame,
                                         v8::Handle<v8::Context>,
                                         int world_id);
-  virtual void didChangeScrollOffset(blink::WebFrame* frame);
-  virtual void willInsertBody(blink::WebFrame* frame);
-  virtual void didFirstVisuallyNonEmptyLayout(blink::WebFrame*);
-  virtual void didChangeContentsSize(blink::WebFrame* frame,
+  virtual void didChangeScrollOffset(blink::WebLocalFrame* frame);
+  virtual void willInsertBody(blink::WebLocalFrame* frame);
+  virtual void didFirstVisuallyNonEmptyLayout(blink::WebLocalFrame*);
+  virtual void didChangeContentsSize(blink::WebLocalFrame* frame,
                                      const blink::WebSize& size);
   virtual void reportFindInPageMatchCount(int request_id,
                                           int count,
@@ -594,29 +590,27 @@ class CONTENT_EXPORT RenderViewImpl
   virtual void reportFindInPageSelection(int request_id,
                                          int active_match_ordinal,
                                          const blink::WebRect& sel);
-  virtual void requestStorageQuota(
-      blink::WebFrame* frame,
-      blink::WebStorageQuotaType type,
-      unsigned long long requested_size,
-      blink::WebStorageQuotaCallbacks callbacks);
+  virtual void requestStorageQuota(blink::WebLocalFrame* frame,
+                                   blink::WebStorageQuotaType type,
+                                   unsigned long long requested_size,
+                                   blink::WebStorageQuotaCallbacks callbacks);
   virtual void willOpenSocketStream(
       blink::WebSocketStreamHandle* handle);
-  virtual void willStartUsingPeerConnectionHandler(blink::WebFrame* frame,
+  virtual void willStartUsingPeerConnectionHandler(
+      blink::WebLocalFrame* frame,
       blink::WebRTCPeerConnectionHandler* handler);
   virtual bool willCheckAndDispatchMessageEvent(
-      blink::WebFrame* sourceFrame,
+      blink::WebLocalFrame* sourceFrame,
       blink::WebFrame* targetFrame,
       blink::WebSecurityOrigin targetOrigin,
       blink::WebDOMMessageEvent event);
   virtual blink::WebString acceptLanguages();
-  virtual blink::WebString userAgentOverride(
-      blink::WebFrame* frame,
-      const blink::WebURL& url);
-  virtual blink::WebString doNotTrackValue(blink::WebFrame* frame);
-  virtual bool allowWebGL(blink::WebFrame* frame, bool default_value);
-  virtual void didLoseWebGLContext(
-      blink::WebFrame* frame,
-      int arb_robustness_status_code);
+  virtual blink::WebString userAgentOverride(blink::WebLocalFrame* frame,
+                                             const blink::WebURL& url);
+  virtual blink::WebString doNotTrackValue(blink::WebLocalFrame* frame);
+  virtual bool allowWebGL(blink::WebLocalFrame* frame, bool default_value);
+  virtual void didLoseWebGLContext(blink::WebLocalFrame* frame,
+                                   int arb_robustness_status_code);
 
   // blink::WebPageSerializerClient implementation ----------------------------
 
@@ -642,7 +636,7 @@ class CONTENT_EXPORT RenderViewImpl
   virtual bool GetContentStateImmediately() const OVERRIDE;
   virtual float GetFilteredTimePerFrame() const OVERRIDE;
   virtual blink::WebPageVisibilityState GetVisibilityState() const OVERRIDE;
-  virtual void RunModalAlertDialog(blink::WebFrame* frame,
+  virtual void RunModalAlertDialog(blink::WebLocalFrame* frame,
                                    const blink::WebString& message) OVERRIDE;
   virtual void DidStartLoading() OVERRIDE;
   virtual void DidStopLoading() OVERRIDE;
diff --git a/content/renderer/web_ui_mojo.cc b/content/renderer/web_ui_mojo.cc
index 58f67a8..b972c97 100644
--- a/content/renderer/web_ui_mojo.cc
+++ b/content/renderer/web_ui_mojo.cc
@@ -65,7 +65,8 @@ WebUIMojo::~WebUIMojo() {
 
 void WebUIMojo::CreateContextState() {
   v8::HandleScope handle_scope(blink::mainThreadIsolate());
-  blink::WebFrame* frame = render_view()->GetWebView()->mainFrame();
+  blink::WebFrame* frame =
+      render_view()->GetWebView()->mainFrame()->toWebLocalFrame();
   v8::Handle<v8::Context> context = frame->mainWorldScriptContext();
   gin::PerContextData* context_data = gin::PerContextData::From(context);
   WebUIMojoContextStateData* data = new WebUIMojoContextStateData;
@@ -96,7 +97,8 @@ void WebUIMojo::SetHandleOnContextState(mojo::ScopedMessagePipeHandle handle) {
 }
 
 WebUIMojoContextState* WebUIMojo::GetContextState() {
-  blink::WebFrame* frame = render_view()->GetWebView()->mainFrame();
+  blink::WebLocalFrame* frame =
+      render_view()->GetWebView()->mainFrame()->toWebLocalFrame();
   v8::HandleScope handle_scope(blink::mainThreadIsolate());
   v8::Handle<v8::Context> context = frame->mainWorldScriptContext();
   gin::PerContextData* context_data = gin::PerContextData::From(context);
@@ -108,7 +110,8 @@ WebUIMojoContextState* WebUIMojo::GetContextState() {
   return context_state ? context_state->state.get() : NULL;
 }
 
-void WebUIMojo::DidClearWindowObject(blink::WebFrame* frame, int world_id) {
+void WebUIMojo::DidClearWindowObject(blink::WebLocalFrame* frame,
+                                     int world_id) {
   if (frame != render_view()->GetWebView()->mainFrame())
     return;
 
diff --git a/content/renderer/web_ui_mojo.h b/content/renderer/web_ui_mojo.h
index d9a7f00..504f737 100644
--- a/content/renderer/web_ui_mojo.h
+++ b/content/renderer/web_ui_mojo.h
@@ -65,7 +65,7 @@ class WebUIMojo
   WebUIMojoContextState* GetContextState();
 
   // RenderViewObserver overrides:
-  virtual void DidClearWindowObject(blink::WebFrame* frame,
+  virtual void DidClearWindowObject(blink::WebLocalFrame* frame,
                                     int world_id) OVERRIDE;
 
   MainFrameObserver main_frame_observer_;
diff --git a/content/shell/renderer/leak_detector.cc b/content/shell/renderer/leak_detector.cc
index 0ad4e224..ce280f7 100644
--- a/content/shell/renderer/leak_detector.cc
+++ b/content/shell/renderer/leak_detector.cc
@@ -28,7 +28,8 @@ LeakDetector::LeakDetector()
       previous_number_of_live_nodes_(kInitialNumberOfLiveNodes) {
 }
 
-LeakDetectionResult LeakDetector::TryLeakDetection(blink::WebFrame* frame) {
+LeakDetectionResult LeakDetector::TryLeakDetection(
+    blink::WebLocalFrame* frame) {
   LeakDetectionResult result;
   unsigned number_of_live_documents = 0;
   unsigned number_of_live_nodes = 0;
diff --git a/content/shell/renderer/leak_detector.h b/content/shell/renderer/leak_detector.h
index e9935c2..60694f4 100644
--- a/content/shell/renderer/leak_detector.h
+++ b/content/shell/renderer/leak_detector.h
@@ -7,10 +7,8 @@
 
 #include "base/basictypes.h"
 #include "content/shell/common/leak_detection_result.h"
-
-namespace blink {
-class WebFrame;
-}
+// TODO(dcheng): Temporary. Convert back to a forward declare.
+#include "third_party/WebKit/public/web/WebLocalFrame.h"
 
 namespace content {
 
@@ -24,7 +22,7 @@ class LeakDetector {
   // specific page, like about:blank is loaded to compare the previous
   // circumstance of DOM objects. If the number of objects increses, there
   // should be a leak.
-  LeakDetectionResult TryLeakDetection(blink::WebFrame* frame);
+  LeakDetectionResult TryLeakDetection(blink::WebLocalFrame* frame);
 
  private:
   // The number of the live documents last time.
diff --git a/content/shell/renderer/shell_render_view_observer.cc b/content/shell/renderer/shell_render_view_observer.cc
index 673a527..482bb53 100644
--- a/content/shell/renderer/shell_render_view_observer.cc
+++ b/content/shell/renderer/shell_render_view_observer.cc
@@ -17,7 +17,7 @@ ShellRenderViewObserver::ShellRenderViewObserver(RenderView* render_view)
     : RenderViewObserver(render_view) {
 }
 
-void ShellRenderViewObserver::DidClearWindowObject(blink::WebFrame* frame,
+void ShellRenderViewObserver::DidClearWindowObject(blink::WebLocalFrame* frame,
                                                    int world_id) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kExposeInternalsForTesting)) {
diff --git a/content/shell/renderer/shell_render_view_observer.h b/content/shell/renderer/shell_render_view_observer.h
index 49ffed7..2d8092c 100644
--- a/content/shell/renderer/shell_render_view_observer.h
+++ b/content/shell/renderer/shell_render_view_observer.h
@@ -23,7 +23,7 @@ class ShellRenderViewObserver : public RenderViewObserver {
 
  private:
   // RenderViewObserver implementation.
-  virtual void DidClearWindowObject(blink::WebFrame* frame,
+  virtual void DidClearWindowObject(blink::WebLocalFrame* frame,
                                     int world_id) OVERRIDE;
 
   DISALLOW_COPY_AND_ASSIGN(ShellRenderViewObserver);
diff --git a/content/shell/renderer/test_runner/WebFrameTestProxy.h b/content/shell/renderer/test_runner/WebFrameTestProxy.h
index ee45b85..7756e9f 100644
--- a/content/shell/renderer/test_runner/WebFrameTestProxy.h
+++ b/content/shell/renderer/test_runner/WebFrameTestProxy.h
@@ -33,7 +33,7 @@ public:
         m_version = version;
     }
 
-    blink::WebPlugin* createPlugin(blink::WebFrame* frame, const blink::WebPluginParams& params)
+    blink::WebPlugin* createPlugin(blink::WebLocalFrame* frame, const blink::WebPluginParams& params)
     {
         blink::WebPlugin* plugin = m_baseProxy->createPlugin(frame, params);
         if (plugin)
@@ -54,46 +54,46 @@ public:
         const CR_DEFINE_STATIC_LOCAL(WebString, suffix, ("-can-create-without-renderer"));
         return mimeType.utf8().find(suffix.utf8()) != std::string::npos;
     }
-    virtual void didStartProvisionalLoad(blink::WebFrame* frame)
+    virtual void didStartProvisionalLoad(blink::WebLocalFrame* frame)
     {
         if (m_version > 2)
             m_baseProxy->didStartProvisionalLoad(frame);
         Base::didStartProvisionalLoad(frame);
     }
-    virtual void didReceiveServerRedirectForProvisionalLoad(blink::WebFrame* frame)
+    virtual void didReceiveServerRedirectForProvisionalLoad(blink::WebLocalFrame* frame)
     {
         m_baseProxy->didReceiveServerRedirectForProvisionalLoad(frame);
         Base::didReceiveServerRedirectForProvisionalLoad(frame);
     }
-    virtual void didFailProvisionalLoad(blink::WebFrame* frame, const blink::WebURLError& error)
+    virtual void didFailProvisionalLoad(blink::WebLocalFrame* frame, const blink::WebURLError& error)
     {
         Base::didFailProvisionalLoad(frame, error);
     }
-    virtual void didCommitProvisionalLoad(blink::WebFrame* frame, bool isNewNavigation)
+    virtual void didCommitProvisionalLoad(blink::WebLocalFrame* frame, bool isNewNavigation)
     {
         Base::didCommitProvisionalLoad(frame, isNewNavigation);
     }
-    virtual void didReceiveTitle(blink::WebFrame* frame, const blink::WebString& title, blink::WebTextDirection direction)
+    virtual void didReceiveTitle(blink::WebLocalFrame* frame, const blink::WebString& title, blink::WebTextDirection direction)
     {
         Base::didReceiveTitle(frame, title, direction);
     }
-    virtual void didChangeIcon(blink::WebFrame* frame, blink::WebIconURL::Type iconType)
+    virtual void didChangeIcon(blink::WebLocalFrame* frame, blink::WebIconURL::Type iconType)
     {
         Base::didChangeIcon(frame, iconType);
     }
-    virtual void didFinishDocumentLoad(blink::WebFrame* frame)
+    virtual void didFinishDocumentLoad(blink::WebLocalFrame* frame)
     {
         Base::didFinishDocumentLoad(frame);
     }
-    virtual void didHandleOnloadEvents(blink::WebFrame* frame)
+    virtual void didHandleOnloadEvents(blink::WebLocalFrame* frame)
     {
         Base::didHandleOnloadEvents(frame);
     }
-    virtual void didFailLoad(blink::WebFrame* frame, const blink::WebURLError& error)
+    virtual void didFailLoad(blink::WebLocalFrame* frame, const blink::WebURLError& error)
     {
         Base::didFailLoad(frame, error);
     }
-    virtual void didFinishLoad(blink::WebFrame* frame)
+    virtual void didFinishLoad(blink::WebLocalFrame* frame)
     {
         Base::didFinishLoad(frame);
     }
@@ -102,56 +102,56 @@ public:
         Base::didChangeSelection(is_selection_empty);
     }
     virtual void showContextMenu(const blink::WebContextMenuData& contextMenuData) {
-        m_baseProxy->showContextMenu(Base::GetWebFrame(), contextMenuData);
+        m_baseProxy->showContextMenu(Base::GetWebFrame()->toWebLocalFrame(), contextMenuData);
         Base::showContextMenu(contextMenuData);
     }
-    virtual void didDetectXSS(blink::WebFrame* frame, const blink::WebURL& insecureURL, bool didBlockEntirePage)
+    virtual void didDetectXSS(blink::WebLocalFrame* frame, const blink::WebURL& insecureURL, bool didBlockEntirePage)
     {
         // This is not implemented in RenderFrameImpl, so need to explicitly call
         // into the base proxy.
         m_baseProxy->didDetectXSS(frame, insecureURL, didBlockEntirePage);
         Base::didDetectXSS(frame, insecureURL, didBlockEntirePage);
     }
-    virtual void didDispatchPingLoader(blink::WebFrame* frame, const blink::WebURL& url)
+    virtual void didDispatchPingLoader(blink::WebLocalFrame* frame, const blink::WebURL& url)
     {
         // This is not implemented in RenderFrameImpl, so need to explicitly call
         // into the base proxy.
         m_baseProxy->didDispatchPingLoader(frame, url);
         Base::didDispatchPingLoader(frame, url);
     }
-    virtual void willRequestResource(blink::WebFrame* frame, const blink::WebCachedURLRequest& request)
+    virtual void willRequestResource(blink::WebLocalFrame* frame, const blink::WebCachedURLRequest& request)
     {
         // This is not implemented in RenderFrameImpl, so need to explicitly call
         // into the base proxy.
         m_baseProxy->willRequestResource(frame, request);
         Base::willRequestResource(frame, request);
     }
-    virtual void didCreateDataSource(blink::WebFrame* frame, blink::WebDataSource* ds)
+    virtual void didCreateDataSource(blink::WebLocalFrame* frame, blink::WebDataSource* ds)
     {
         Base::didCreateDataSource(frame, ds);
     }
-    virtual void willSendRequest(blink::WebFrame* frame, unsigned identifier, blink::WebURLRequest& request, const blink::WebURLResponse& redirectResponse)
+    virtual void willSendRequest(blink::WebLocalFrame* frame, unsigned identifier, blink::WebURLRequest& request, const blink::WebURLResponse& redirectResponse)
     {
         m_baseProxy->willSendRequest(frame, identifier, request, redirectResponse);
         Base::willSendRequest(frame, identifier, request, redirectResponse);
     }
-    virtual void didReceiveResponse(blink::WebFrame* frame, unsigned identifier, const blink::WebURLResponse& response)
+    virtual void didReceiveResponse(blink::WebLocalFrame* frame, unsigned identifier, const blink::WebURLResponse& response)
     {
         m_baseProxy->didReceiveResponse(frame, identifier, response);
         Base::didReceiveResponse(frame, identifier, response);
     }
-    virtual void didChangeResourcePriority(blink::WebFrame* frame, unsigned identifier, const blink::WebURLRequest::Priority& priority)
+    virtual void didChangeResourcePriority(blink::WebLocalFrame* frame, unsigned identifier, const blink::WebURLRequest::Priority& priority)
     {
         // This is not implemented in RenderFrameImpl, so need to explicitly call
         // into the base proxy.
         m_baseProxy->didChangeResourcePriority(frame, identifier, priority);
         Base::didChangeResourcePriority(frame, identifier, priority);
     }
-    virtual void didFinishResourceLoad(blink::WebFrame* frame, unsigned identifier)
+    virtual void didFinishResourceLoad(blink::WebLocalFrame* frame, unsigned identifier)
     {
         Base::didFinishResourceLoad(frame, identifier);
     }
-    virtual blink::WebNavigationPolicy decidePolicyForNavigation(blink::WebFrame* frame, blink::WebDataSource::ExtraData* extraData, const blink::WebURLRequest& request, blink::WebNavigationType type, blink::WebNavigationPolicy defaultPolicy, bool isRedirect)
+    virtual blink::WebNavigationPolicy decidePolicyForNavigation(blink::WebLocalFrame* frame, blink::WebDataSource::ExtraData* extraData, const blink::WebURLRequest& request, blink::WebNavigationType type, blink::WebNavigationPolicy defaultPolicy, bool isRedirect)
     {
         blink::WebNavigationPolicy policy = m_baseProxy->decidePolicyForNavigation(frame, extraData, request, type, defaultPolicy, isRedirect);
         if (policy == blink::WebNavigationPolicyIgnore)
@@ -159,7 +159,7 @@ public:
 
         return Base::decidePolicyForNavigation(frame, extraData, request, type, defaultPolicy, isRedirect);
     }
-    virtual bool willCheckAndDispatchMessageEvent(blink::WebFrame* sourceFrame, blink::WebFrame* targetFrame, blink::WebSecurityOrigin target, blink::WebDOMMessageEvent event)
+    virtual bool willCheckAndDispatchMessageEvent(blink::WebLocalFrame* sourceFrame, blink::WebFrame* targetFrame, blink::WebSecurityOrigin target, blink::WebDOMMessageEvent event)
     {
         if (m_baseProxy->willCheckAndDispatchMessageEvent(sourceFrame, targetFrame, target, event))
             return true;
diff --git a/content/shell/renderer/test_runner/WebPermissions.cpp b/content/shell/renderer/test_runner/WebPermissions.cpp
index 1eec6eb..11e1c07 100644
--- a/content/shell/renderer/test_runner/WebPermissions.cpp
+++ b/content/shell/renderer/test_runner/WebPermissions.cpp
@@ -23,32 +23,32 @@ WebPermissions::~WebPermissions()
 {
 }
 
-bool WebPermissions::allowImage(blink::WebFrame*, bool enabledPerSettings, const blink::WebURL& imageURL)
+bool WebPermissions::allowImage(blink::WebLocalFrame*, bool enabledPerSettings, const blink::WebURL& imageURL)
 {
     return allowImage(enabledPerSettings, imageURL);
 }
 
-bool WebPermissions::allowScriptFromSource(blink::WebFrame*, bool enabledPerSettings, const blink::WebURL& scriptURL)
+bool WebPermissions::allowScriptFromSource(blink::WebLocalFrame*, bool enabledPerSettings, const blink::WebURL& scriptURL)
 {
     return allowScriptFromSource(enabledPerSettings, scriptURL);
 }
 
-bool WebPermissions::allowStorage(blink::WebFrame*, bool temp)
+bool WebPermissions::allowStorage(blink::WebLocalFrame*, bool temp)
 {
     return allowStorage(temp);
 }
 
-bool WebPermissions::allowPlugins(blink::WebFrame*, bool enabledPerSettings)
+bool WebPermissions::allowPlugins(blink::WebLocalFrame*, bool enabledPerSettings)
 {
     return enabledPerSettings && m_pluginsAllowed;
 }
 
-bool WebPermissions::allowDisplayingInsecureContent(blink::WebFrame*, bool enabledPerSettings, const blink::WebSecurityOrigin& temp1, const blink::WebURL& temp2)
+bool WebPermissions::allowDisplayingInsecureContent(blink::WebLocalFrame*, bool enabledPerSettings, const blink::WebSecurityOrigin& temp1, const blink::WebURL& temp2)
 {
     return allowDisplayingInsecureContent(enabledPerSettings, temp1, temp2);
 }
 
-bool WebPermissions::allowRunningInsecureContent(blink::WebFrame*, bool enabledPerSettings, const blink::WebSecurityOrigin& temp1, const blink::WebURL& temp2)
+bool WebPermissions::allowRunningInsecureContent(blink::WebLocalFrame*, bool enabledPerSettings, const blink::WebSecurityOrigin& temp1, const blink::WebURL& temp2)
 {
     return allowRunningInsecureContent(enabledPerSettings, temp1, temp2);
 }
diff --git a/content/shell/renderer/test_runner/WebPermissions.h b/content/shell/renderer/test_runner/WebPermissions.h
index 724dc589..32ade11b 100644
--- a/content/shell/renderer/test_runner/WebPermissions.h
+++ b/content/shell/renderer/test_runner/WebPermissions.h
@@ -19,12 +19,12 @@ public:
 
     // Override WebPermissionClient methods.
     // TODO(jam): remove all these methods after Blink rolls.
-    virtual bool allowImage(blink::WebFrame*, bool enabledPerSettings, const blink::WebURL& imageURL);
-    virtual bool allowScriptFromSource(blink::WebFrame*, bool enabledPerSettings, const blink::WebURL& scriptURL);
-    virtual bool allowStorage(blink::WebFrame*, bool local);
-    virtual bool allowPlugins(blink::WebFrame*, bool enabledPerSettings);
-    virtual bool allowDisplayingInsecureContent(blink::WebFrame*, bool enabledPerSettings, const blink::WebSecurityOrigin&, const blink::WebURL&);
-    virtual bool allowRunningInsecureContent(blink::WebFrame*, bool enabledPerSettings, const blink::WebSecurityOrigin&, const blink::WebURL&);
+    virtual bool allowImage(blink::WebLocalFrame*, bool enabledPerSettings, const blink::WebURL& imageURL);
+    virtual bool allowScriptFromSource(blink::WebLocalFrame*, bool enabledPerSettings, const blink::WebURL& scriptURL);
+    virtual bool allowStorage(blink::WebLocalFrame*, bool local);
+    virtual bool allowPlugins(blink::WebLocalFrame*, bool enabledPerSettings);
+    virtual bool allowDisplayingInsecureContent(blink::WebLocalFrame*, bool enabledPerSettings, const blink::WebSecurityOrigin&, const blink::WebURL&);
+    virtual bool allowRunningInsecureContent(blink::WebLocalFrame*, bool enabledPerSettings, const blink::WebSecurityOrigin&, const blink::WebURL&);
 
     virtual bool allowImage(bool enabledPerSettings, const blink::WebURL& imageURL);
     virtual bool allowScriptFromSource(bool enabledPerSettings, const blink::WebURL& scriptURL);
diff --git a/content/shell/renderer/test_runner/WebTestProxy.cpp b/content/shell/renderer/test_runner/WebTestProxy.cpp
index 0ad4474..a1685c8 100644
--- a/content/shell/renderer/test_runner/WebTestProxy.cpp
+++ b/content/shell/renderer/test_runner/WebTestProxy.cpp
@@ -865,7 +865,7 @@ void WebTestProxyBase::postAccessibilityEvent(const blink::WebAXObject& obj, bli
     }
 }
 
-void WebTestProxyBase::startDragging(WebFrame*, const WebDragData& data, WebDragOperationsMask mask, const WebImage&, const WebPoint&)
+void WebTestProxyBase::startDragging(WebLocalFrame*, const WebDragData& data, WebDragOperationsMask mask, const WebImage&, const WebPoint&)
 {
     // When running a test, we need to fake a drag drop operation otherwise
     // Windows waits for real mouse events to know when the drag is over.
@@ -887,7 +887,7 @@ void WebTestProxyBase::didChangeContents()
         m_delegate->printMessage("EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification\n");
 }
 
-bool WebTestProxyBase::createView(WebFrame*, const WebURLRequest& request, const WebWindowFeatures&, const WebString&, WebNavigationPolicy, bool)
+bool WebTestProxyBase::createView(WebLocalFrame*, const WebURLRequest& request, const WebWindowFeatures&, const WebString&, WebNavigationPolicy, bool)
 {
     if (!m_testInterfaces->testRunner()->canOpenWindows())
         return false;
@@ -896,7 +896,7 @@ bool WebTestProxyBase::createView(WebFrame*, const WebURLRequest& request, const
     return true;
 }
 
-WebPlugin* WebTestProxyBase::createPlugin(WebFrame* frame, const WebPluginParams& params)
+WebPlugin* WebTestProxyBase::createPlugin(WebLocalFrame* frame, const WebPluginParams& params)
 {
     if (TestPlugin::isSupportedMimeType(params.mimeType))
         return TestPlugin::create(frame, params, m_delegate);
@@ -916,7 +916,7 @@ void WebTestProxyBase::didStopLoading()
         m_delegate->printMessage("postProgressFinishedNotification\n");
 }
 
-void WebTestProxyBase::showContextMenu(WebFrame*, const WebContextMenuData& contextMenuData)
+void WebTestProxyBase::showContextMenu(WebLocalFrame*, const WebContextMenuData& contextMenuData)
 {
     m_testInterfaces->eventSender()->SetContextMenuData(contextMenuData);
 }
@@ -929,7 +929,7 @@ WebUserMediaClient* WebTestProxyBase::userMediaClient()
 }
 
 // Simulate a print by going into print mode and then exit straight away.
-void WebTestProxyBase::printPage(WebFrame* frame)
+void WebTestProxyBase::printPage(WebLocalFrame* frame)
 {
     WebSize pageSizeInPixels = webWidget()->size();
     if (pageSizeInPixels.isEmpty())
@@ -1013,7 +1013,7 @@ bool WebTestProxyBase::isChooserShown()
     return 0 < m_chooserCount;
 }
 
-void WebTestProxyBase::didStartProvisionalLoad(WebFrame* frame)
+void WebTestProxyBase::didStartProvisionalLoad(WebLocalFrame* frame)
 {
     if (!m_testInterfaces->testRunner()->topLoadingFrame())
         m_testInterfaces->testRunner()->setTopLoadingFrame(frame, false);
@@ -1027,7 +1027,7 @@ void WebTestProxyBase::didStartProvisionalLoad(WebFrame* frame)
         printFrameUserGestureStatus(m_delegate, frame, " - in didStartProvisionalLoadForFrame\n");
 }
 
-void WebTestProxyBase::didReceiveServerRedirectForProvisionalLoad(WebFrame* frame)
+void WebTestProxyBase::didReceiveServerRedirectForProvisionalLoad(WebLocalFrame* frame)
 {
     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
         printFrameDescription(m_delegate, frame);
@@ -1035,7 +1035,7 @@ void WebTestProxyBase::didReceiveServerRedirectForProvisionalLoad(WebFrame* fram
     }
 }
 
-bool WebTestProxyBase::didFailProvisionalLoad(WebFrame* frame, const WebURLError&)
+bool WebTestProxyBase::didFailProvisionalLoad(WebLocalFrame* frame, const WebURLError&)
 {
     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
         printFrameDescription(m_delegate, frame);
@@ -1045,7 +1045,7 @@ bool WebTestProxyBase::didFailProvisionalLoad(WebFrame* frame, const WebURLError
     return !frame->provisionalDataSource();
 }
 
-void WebTestProxyBase::didCommitProvisionalLoad(WebFrame* frame, bool)
+void WebTestProxyBase::didCommitProvisionalLoad(WebLocalFrame* frame, bool)
 {
     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
         printFrameDescription(m_delegate, frame);
@@ -1053,7 +1053,7 @@ void WebTestProxyBase::didCommitProvisionalLoad(WebFrame* frame, bool)
     }
 }
 
-void WebTestProxyBase::didReceiveTitle(WebFrame* frame, const WebString& title, WebTextDirection direction)
+void WebTestProxyBase::didReceiveTitle(WebLocalFrame* frame, const WebString& title, WebTextDirection direction)
 {
     WebCString title8 = title.utf8();
 
@@ -1066,7 +1066,7 @@ void WebTestProxyBase::didReceiveTitle(WebFrame* frame, const WebString& title,
         m_delegate->printMessage(string("TITLE CHANGED: '") + title8.data() + "'\n");
 }
 
-void WebTestProxyBase::didChangeIcon(WebFrame* frame, WebIconURL::Type)
+void WebTestProxyBase::didChangeIcon(WebLocalFrame* frame, WebIconURL::Type)
 {
     if (m_testInterfaces->testRunner()->shouldDumpIconChanges()) {
         printFrameDescription(m_delegate, frame);
@@ -1074,7 +1074,7 @@ void WebTestProxyBase::didChangeIcon(WebFrame* frame, WebIconURL::Type)
     }
 }
 
-void WebTestProxyBase::didFinishDocumentLoad(WebFrame* frame)
+void WebTestProxyBase::didFinishDocumentLoad(WebLocalFrame* frame)
 {
     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
         printFrameDescription(m_delegate, frame);
@@ -1090,7 +1090,7 @@ void WebTestProxyBase::didFinishDocumentLoad(WebFrame* frame)
     }
 }
 
-void WebTestProxyBase::didHandleOnloadEvents(WebFrame* frame)
+void WebTestProxyBase::didHandleOnloadEvents(WebLocalFrame* frame)
 {
     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
         printFrameDescription(m_delegate, frame);
@@ -1098,7 +1098,7 @@ void WebTestProxyBase::didHandleOnloadEvents(WebFrame* frame)
     }
 }
 
-void WebTestProxyBase::didFailLoad(WebFrame* frame, const WebURLError&)
+void WebTestProxyBase::didFailLoad(WebLocalFrame* frame, const WebURLError&)
 {
     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
         printFrameDescription(m_delegate, frame);
@@ -1107,7 +1107,7 @@ void WebTestProxyBase::didFailLoad(WebFrame* frame, const WebURLError&)
     locationChangeDone(frame);
 }
 
-void WebTestProxyBase::didFinishLoad(WebFrame* frame)
+void WebTestProxyBase::didFinishLoad(WebLocalFrame* frame)
 {
     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
         printFrameDescription(m_delegate, frame);
@@ -1116,19 +1116,19 @@ void WebTestProxyBase::didFinishLoad(WebFrame* frame)
     locationChangeDone(frame);
 }
 
-void WebTestProxyBase::didDetectXSS(WebFrame*, const WebURL&, bool)
+void WebTestProxyBase::didDetectXSS(WebLocalFrame*, const WebURL&, bool)
 {
     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks())
         m_delegate->printMessage("didDetectXSS\n");
 }
 
-void WebTestProxyBase::didDispatchPingLoader(WebFrame*, const WebURL& url)
+void WebTestProxyBase::didDispatchPingLoader(WebLocalFrame*, const WebURL& url)
 {
     if (m_testInterfaces->testRunner()->shouldDumpPingLoaderCallbacks())
         m_delegate->printMessage(string("PingLoader dispatched to '") + URLDescription(url).c_str() + "'.\n");
 }
 
-void WebTestProxyBase::willRequestResource(WebFrame* frame, const blink::WebCachedURLRequest& request)
+void WebTestProxyBase::willRequestResource(WebLocalFrame* frame, const blink::WebCachedURLRequest& request)
 {
     if (m_testInterfaces->testRunner()->shouldDumpResourceRequestCallbacks()) {
         printFrameDescription(m_delegate, frame);
@@ -1137,7 +1137,7 @@ void WebTestProxyBase::willRequestResource(WebFrame* frame, const blink::WebCach
     }
 }
 
-void WebTestProxyBase::willSendRequest(WebFrame*, unsigned identifier, blink::WebURLRequest& request, const blink::WebURLResponse& redirectResponse)
+void WebTestProxyBase::willSendRequest(WebLocalFrame*, unsigned identifier, blink::WebURLRequest& request, const blink::WebURLResponse& redirectResponse)
 {
     // Need to use GURL for host() and SchemeIs()
     GURL url = request.url();
@@ -1194,7 +1194,7 @@ void WebTestProxyBase::willSendRequest(WebFrame*, unsigned identifier, blink::We
     request.setURL(m_delegate->rewriteLayoutTestsURL(request.url().spec()));
 }
 
-void WebTestProxyBase::didReceiveResponse(WebFrame*, unsigned identifier, const blink::WebURLResponse& response)
+void WebTestProxyBase::didReceiveResponse(WebLocalFrame*, unsigned identifier, const blink::WebURLResponse& response)
 {
     if (m_testInterfaces->testRunner()->shouldDumpResourceLoadCallbacks()) {
         if (m_resourceIdentifierMap.find(identifier) == m_resourceIdentifierMap.end())
@@ -1216,7 +1216,7 @@ void WebTestProxyBase::didReceiveResponse(WebFrame*, unsigned identifier, const
     }
 }
 
-void WebTestProxyBase::didChangeResourcePriority(WebFrame*, unsigned identifier, const blink::WebURLRequest::Priority& priority)
+void WebTestProxyBase::didChangeResourcePriority(WebLocalFrame*, unsigned identifier, const blink::WebURLRequest::Priority& priority)
 {
     if (m_testInterfaces->testRunner()->shouldDumpResourcePriorities()) {
         if (m_resourceIdentifierMap.find(identifier) == m_resourceIdentifierMap.end())
@@ -1229,7 +1229,7 @@ void WebTestProxyBase::didChangeResourcePriority(WebFrame*, unsigned identifier,
     }
 }
 
-void WebTestProxyBase::didFinishResourceLoad(WebFrame*, unsigned identifier)
+void WebTestProxyBase::didFinishResourceLoad(WebLocalFrame*, unsigned identifier)
 {
     if (m_testInterfaces->testRunner()->shouldDumpResourceLoadCallbacks()) {
         if (m_resourceIdentifierMap.find(identifier) == m_resourceIdentifierMap.end())
@@ -1283,24 +1283,24 @@ void WebTestProxyBase::didAddMessageToConsole(const WebConsoleMessage& message,
     m_delegate->printMessage(string("\n"));
 }
 
-void WebTestProxyBase::runModalAlertDialog(WebFrame*, const WebString& message)
+void WebTestProxyBase::runModalAlertDialog(WebLocalFrame*, const WebString& message)
 {
     m_delegate->printMessage(string("ALERT: ") + message.utf8().data() + "\n");
 }
 
-bool WebTestProxyBase::runModalConfirmDialog(WebFrame*, const WebString& message)
+bool WebTestProxyBase::runModalConfirmDialog(WebLocalFrame*, const WebString& message)
 {
     m_delegate->printMessage(string("CONFIRM: ") + message.utf8().data() + "\n");
     return true;
 }
 
-bool WebTestProxyBase::runModalPromptDialog(WebFrame* frame, const WebString& message, const WebString& defaultValue, WebString*)
+bool WebTestProxyBase::runModalPromptDialog(WebLocalFrame* frame, const WebString& message, const WebString& defaultValue, WebString*)
 {
     m_delegate->printMessage(string("PROMPT: ") + message.utf8().data() + ", default text: " + defaultValue.utf8().data() + "\n");
     return true;
 }
 
-bool WebTestProxyBase::runModalBeforeUnloadDialog(WebFrame*, const WebString& message)
+bool WebTestProxyBase::runModalBeforeUnloadDialog(WebLocalFrame*, const WebString& message)
 {
     m_delegate->printMessage(string("CONFIRM NAVIGATION: ") + message.utf8().data() + "\n");
     return !m_testInterfaces->testRunner()->shouldStayOnPageAfterHandlingBeforeUnload();
@@ -1313,7 +1313,7 @@ void WebTestProxyBase::locationChangeDone(WebFrame* frame)
     m_testInterfaces->testRunner()->setTopLoadingFrame(frame, true);
 }
 
-WebNavigationPolicy WebTestProxyBase::decidePolicyForNavigation(WebFrame*, WebDataSource::ExtraData*, const WebURLRequest& request, WebNavigationType type, WebNavigationPolicy defaultPolicy, bool isRedirect)
+WebNavigationPolicy WebTestProxyBase::decidePolicyForNavigation(WebLocalFrame*, WebDataSource::ExtraData*, const WebURLRequest& request, WebNavigationType type, WebNavigationPolicy defaultPolicy, bool isRedirect)
 {
     WebNavigationPolicy result;
     if (!m_testInterfaces->testRunner()->policyDelegateEnabled())
@@ -1330,7 +1330,7 @@ WebNavigationPolicy WebTestProxyBase::decidePolicyForNavigation(WebFrame*, WebDa
     return result;
 }
 
-bool WebTestProxyBase::willCheckAndDispatchMessageEvent(WebFrame*, WebFrame*, WebSecurityOrigin, WebDOMMessageEvent)
+bool WebTestProxyBase::willCheckAndDispatchMessageEvent(WebLocalFrame*, WebFrame*, WebSecurityOrigin, WebDOMMessageEvent)
 {
     if (m_testInterfaces->testRunner()->shouldInterceptPostMessage()) {
         m_delegate->printMessage("intercepted postMessage\n");
diff --git a/content/shell/renderer/test_runner/WebTestProxy.h b/content/shell/renderer/test_runner/WebTestProxy.h
index b870be7..3278ebd 100644
--- a/content/shell/renderer/test_runner/WebTestProxy.h
+++ b/content/shell/renderer/test_runner/WebTestProxy.h
@@ -18,7 +18,10 @@
 #include "third_party/WebKit/public/web/WebDOMMessageEvent.h"
 #include "third_party/WebKit/public/web/WebDataSource.h"
 #include "third_party/WebKit/public/web/WebDragOperation.h"
+#include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebIconURL.h"
+// TODO(dcheng): Temporary. Delete once forward declarable.
+#include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebNavigationPolicy.h"
 #include "third_party/WebKit/public/web/WebNavigationType.h"
 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
@@ -139,17 +142,17 @@ protected:
     void show(blink::WebNavigationPolicy);
     void didAutoResize(const blink::WebSize&);
     void postAccessibilityEvent(const blink::WebAXObject&, blink::WebAXEvent);
-    void startDragging(blink::WebFrame*, const blink::WebDragData&, blink::WebDragOperationsMask, const blink::WebImage&, const blink::WebPoint&);
+    void startDragging(blink::WebLocalFrame*, const blink::WebDragData&, blink::WebDragOperationsMask, const blink::WebImage&, const blink::WebPoint&);
     void didChangeSelection(bool isEmptySelection);
     void didChangeContents();
     void didEndEditing();
-    bool createView(blink::WebFrame* creator, const blink::WebURLRequest&, const blink::WebWindowFeatures&, const blink::WebString& frameName, blink::WebNavigationPolicy, bool suppressOpener);
-    blink::WebPlugin* createPlugin(blink::WebFrame*, const blink::WebPluginParams&);
+    bool createView(blink::WebLocalFrame* creator, const blink::WebURLRequest&, const blink::WebWindowFeatures&, const blink::WebString& frameName, blink::WebNavigationPolicy, bool suppressOpener);
+    blink::WebPlugin* createPlugin(blink::WebLocalFrame*, const blink::WebPluginParams&);
     void setStatusText(const blink::WebString&);
     void didStopLoading();
-    void showContextMenu(blink::WebFrame*, const blink::WebContextMenuData&);
+    void showContextMenu(blink::WebLocalFrame*, const blink::WebContextMenuData&);
     blink::WebUserMediaClient* userMediaClient();
-    void printPage(blink::WebFrame*);
+    void printPage(blink::WebLocalFrame*);
     blink::WebNotificationPresenter* notificationPresenter();
     blink::WebMIDIClient* webMIDIClient();
     blink::WebSpeechInputController* speechInputController(blink::WebSpeechInputListener*);
@@ -161,31 +164,31 @@ protected:
     void didBlur();
     void setToolTipText(const blink::WebString&, blink::WebTextDirection);
     void didAddMessageToConsole(const blink::WebConsoleMessage&, const blink::WebString& sourceName, unsigned sourceLine);
-    void runModalAlertDialog(blink::WebFrame*, const blink::WebString&);
-    bool runModalConfirmDialog(blink::WebFrame*, const blink::WebString&);
-    bool runModalPromptDialog(blink::WebFrame*, const blink::WebString& message, const blink::WebString& defaultValue, blink::WebString* actualValue);
-    bool runModalBeforeUnloadDialog(blink::WebFrame*, const blink::WebString&);
-
-    void didStartProvisionalLoad(blink::WebFrame*);
-    void didReceiveServerRedirectForProvisionalLoad(blink::WebFrame*);
-    bool didFailProvisionalLoad(blink::WebFrame*, const blink::WebURLError&);
-    void didCommitProvisionalLoad(blink::WebFrame*, bool isNewNavigation);
-    void didReceiveTitle(blink::WebFrame*, const blink::WebString& title, blink::WebTextDirection);
-    void didChangeIcon(blink::WebFrame*, blink::WebIconURL::Type);
-    void didFinishDocumentLoad(blink::WebFrame*);
-    void didHandleOnloadEvents(blink::WebFrame*);
-    void didFailLoad(blink::WebFrame*, const blink::WebURLError&);
-    void didFinishLoad(blink::WebFrame*);
-    void didChangeLocationWithinPage(blink::WebFrame*);
-    void didDetectXSS(blink::WebFrame*, const blink::WebURL& insecureURL, bool didBlockEntirePage);
-    void didDispatchPingLoader(blink::WebFrame*, const blink::WebURL&);
-    void willRequestResource(blink::WebFrame*, const blink::WebCachedURLRequest&);
-    void willSendRequest(blink::WebFrame*, unsigned identifier, blink::WebURLRequest&, const blink::WebURLResponse& redirectResponse);
-    void didReceiveResponse(blink::WebFrame*, unsigned identifier, const blink::WebURLResponse&);
-    void didChangeResourcePriority(blink::WebFrame*, unsigned identifier, const blink::WebURLRequest::Priority&);
-    void didFinishResourceLoad(blink::WebFrame*, unsigned identifier);
-    blink::WebNavigationPolicy decidePolicyForNavigation(blink::WebFrame*, blink::WebDataSource::ExtraData*, const blink::WebURLRequest&, blink::WebNavigationType, blink::WebNavigationPolicy defaultPolicy, bool isRedirect);
-    bool willCheckAndDispatchMessageEvent(blink::WebFrame* sourceFrame, blink::WebFrame* targetFrame, blink::WebSecurityOrigin target, blink::WebDOMMessageEvent);
+    void runModalAlertDialog(blink::WebLocalFrame*, const blink::WebString&);
+    bool runModalConfirmDialog(blink::WebLocalFrame*, const blink::WebString&);
+    bool runModalPromptDialog(blink::WebLocalFrame*, const blink::WebString& message, const blink::WebString& defaultValue, blink::WebString* actualValue);
+    bool runModalBeforeUnloadDialog(blink::WebLocalFrame*, const blink::WebString&);
+
+    void didStartProvisionalLoad(blink::WebLocalFrame*);
+    void didReceiveServerRedirectForProvisionalLoad(blink::WebLocalFrame*);
+    bool didFailProvisionalLoad(blink::WebLocalFrame*, const blink::WebURLError&);
+    void didCommitProvisionalLoad(blink::WebLocalFrame*, bool isNewNavigation);
+    void didReceiveTitle(blink::WebLocalFrame*, const blink::WebString& title, blink::WebTextDirection);
+    void didChangeIcon(blink::WebLocalFrame*, blink::WebIconURL::Type);
+    void didFinishDocumentLoad(blink::WebLocalFrame*);
+    void didHandleOnloadEvents(blink::WebLocalFrame*);
+    void didFailLoad(blink::WebLocalFrame*, const blink::WebURLError&);
+    void didFinishLoad(blink::WebLocalFrame*);
+    void didChangeLocationWithinPage(blink::WebLocalFrame*);
+    void didDetectXSS(blink::WebLocalFrame*, const blink::WebURL& insecureURL, bool didBlockEntirePage);
+    void didDispatchPingLoader(blink::WebLocalFrame*, const blink::WebURL&);
+    void willRequestResource(blink::WebLocalFrame*, const blink::WebCachedURLRequest&);
+    void willSendRequest(blink::WebLocalFrame*, unsigned identifier, blink::WebURLRequest&, const blink::WebURLResponse& redirectResponse);
+    void didReceiveResponse(blink::WebLocalFrame*, unsigned identifier, const blink::WebURLResponse&);
+    void didChangeResourcePriority(blink::WebLocalFrame*, unsigned identifier, const blink::WebURLRequest::Priority&);
+    void didFinishResourceLoad(blink::WebLocalFrame*, unsigned identifier);
+    blink::WebNavigationPolicy decidePolicyForNavigation(blink::WebLocalFrame*, blink::WebDataSource::ExtraData*, const blink::WebURLRequest&, blink::WebNavigationType, blink::WebNavigationPolicy defaultPolicy, bool isRedirect);
+    bool willCheckAndDispatchMessageEvent(blink::WebLocalFrame* sourceFrame, blink::WebFrame* targetFrame, blink::WebSecurityOrigin target, blink::WebDOMMessageEvent);
     void resetInputMethod();
 
 private:
@@ -282,7 +285,7 @@ public:
         WebTestProxyBase::postAccessibilityEvent(object, event);
         Base::postAccessibilityEvent(object, event);
     }
-    virtual void startDragging(blink::WebFrame* frame, const blink::WebDragData& data, blink::WebDragOperationsMask mask, const blink::WebImage& image, const blink::WebPoint& point)
+    virtual void startDragging(blink::WebLocalFrame* frame, const blink::WebDragData& data, blink::WebDragOperationsMask mask, const blink::WebImage& image, const blink::WebPoint& point)
     {
         WebTestProxyBase::startDragging(frame, data, mask, image, point);
         // Don't forward this call to Base because we don't want to do a real drag-and-drop.
@@ -292,7 +295,7 @@ public:
         WebTestProxyBase::didChangeContents();
         Base::didChangeContents();
     }
-    virtual blink::WebView* createView(blink::WebFrame* creator, const blink::WebURLRequest& request, const blink::WebWindowFeatures& features, const blink::WebString& frameName, blink::WebNavigationPolicy policy, bool suppressOpener)
+    virtual blink::WebView* createView(blink::WebLocalFrame* creator, const blink::WebURLRequest& request, const blink::WebWindowFeatures& features, const blink::WebString& frameName, blink::WebNavigationPolicy policy, bool suppressOpener)
     {
         if (!WebTestProxyBase::createView(creator, request, features, frameName, policy, suppressOpener))
             return 0;
@@ -307,7 +310,7 @@ public:
     {
         return WebTestProxyBase::userMediaClient();
     }
-    virtual void printPage(blink::WebFrame* frame)
+    virtual void printPage(blink::WebLocalFrame* frame)
     {
         WebTestProxyBase::printPage(frame);
     }
@@ -359,17 +362,17 @@ public:
         WebTestProxyBase::resetInputMethod();
     }
 
-    virtual void didStartProvisionalLoad(blink::WebFrame* frame)
+    virtual void didStartProvisionalLoad(blink::WebLocalFrame* frame)
     {
         WebTestProxyBase::didStartProvisionalLoad(frame);
         Base::didStartProvisionalLoad(frame);
     }
-    virtual void didReceiveServerRedirectForProvisionalLoad(blink::WebFrame* frame)
+    virtual void didReceiveServerRedirectForProvisionalLoad(blink::WebLocalFrame* frame)
     {
         WebTestProxyBase::didReceiveServerRedirectForProvisionalLoad(frame);
         Base::didReceiveServerRedirectForProvisionalLoad(frame);
     }
-    virtual void didFailProvisionalLoad(blink::WebFrame* frame, const blink::WebURLError& error)
+    virtual void didFailProvisionalLoad(blink::WebLocalFrame* frame, const blink::WebURLError& error)
     {
         // If the test finished, don't notify the embedder of the failed load,
         // as we already destroyed the document loader.
@@ -377,91 +380,91 @@ public:
             return;
         Base::didFailProvisionalLoad(frame, error);
     }
-    virtual void didCommitProvisionalLoad(blink::WebFrame* frame, bool isNewNavigation)
+    virtual void didCommitProvisionalLoad(blink::WebLocalFrame* frame, bool isNewNavigation)
     {
         WebTestProxyBase::didCommitProvisionalLoad(frame, isNewNavigation);
         Base::didCommitProvisionalLoad(frame, isNewNavigation);
     }
-    virtual void didReceiveTitle(blink::WebFrame* frame, const blink::WebString& title, blink::WebTextDirection direction)
+    virtual void didReceiveTitle(blink::WebLocalFrame* frame, const blink::WebString& title, blink::WebTextDirection direction)
     {
         WebTestProxyBase::didReceiveTitle(frame, title, direction);
         Base::didReceiveTitle(frame, title, direction);
     }
-    virtual void didChangeIcon(blink::WebFrame* frame, blink::WebIconURL::Type iconType)
+    virtual void didChangeIcon(blink::WebLocalFrame* frame, blink::WebIconURL::Type iconType)
     {
         WebTestProxyBase::didChangeIcon(frame, iconType);
         Base::didChangeIcon(frame, iconType);
     }
-    virtual void didFinishDocumentLoad(blink::WebFrame* frame)
+    virtual void didFinishDocumentLoad(blink::WebLocalFrame* frame)
     {
         WebTestProxyBase::didFinishDocumentLoad(frame);
         Base::didFinishDocumentLoad(frame);
     }
-    virtual void didHandleOnloadEvents(blink::WebFrame* frame)
+    virtual void didHandleOnloadEvents(blink::WebLocalFrame* frame)
     {
         WebTestProxyBase::didHandleOnloadEvents(frame);
         Base::didHandleOnloadEvents(frame);
     }
-    virtual void didFailLoad(blink::WebFrame* frame, const blink::WebURLError& error)
+    virtual void didFailLoad(blink::WebLocalFrame* frame, const blink::WebURLError& error)
     {
         WebTestProxyBase::didFailLoad(frame, error);
         Base::didFailLoad(frame, error);
     }
-    virtual void didFinishLoad(blink::WebFrame* frame)
+    virtual void didFinishLoad(blink::WebLocalFrame* frame)
     {
         WebTestProxyBase::didFinishLoad(frame);
         Base::didFinishLoad(frame);
     }
-    virtual void didDetectXSS(blink::WebFrame* frame, const blink::WebURL& insecureURL, bool didBlockEntirePage)
+    virtual void didDetectXSS(blink::WebLocalFrame* frame, const blink::WebURL& insecureURL, bool didBlockEntirePage)
     {
         WebTestProxyBase::didDetectXSS(frame, insecureURL, didBlockEntirePage);
         Base::didDetectXSS(frame, insecureURL, didBlockEntirePage);
     }
-    virtual void willRequestResource(blink::WebFrame* frame, const blink::WebCachedURLRequest& request)
+    virtual void willRequestResource(blink::WebLocalFrame* frame, const blink::WebCachedURLRequest& request)
     {
         WebTestProxyBase::willRequestResource(frame, request);
         Base::willRequestResource(frame, request);
     }
-    virtual void willSendRequest(blink::WebFrame* frame, unsigned identifier, blink::WebURLRequest& request, const blink::WebURLResponse& redirectResponse)
+    virtual void willSendRequest(blink::WebLocalFrame* frame, unsigned identifier, blink::WebURLRequest& request, const blink::WebURLResponse& redirectResponse)
     {
         WebTestProxyBase::willSendRequest(frame, identifier, request, redirectResponse);
         Base::willSendRequest(frame, identifier, request, redirectResponse);
     }
-    virtual void didReceiveResponse(blink::WebFrame* frame, unsigned identifier, const blink::WebURLResponse& response)
+    virtual void didReceiveResponse(blink::WebLocalFrame* frame, unsigned identifier, const blink::WebURLResponse& response)
     {
         WebTestProxyBase::didReceiveResponse(frame, identifier, response);
         Base::didReceiveResponse(frame, identifier, response);
     }
-    virtual void didChangeResourcePriority(blink::WebFrame* frame, unsigned identifier, const blink::WebURLRequest::Priority& priority)
+    virtual void didChangeResourcePriority(blink::WebLocalFrame* frame, unsigned identifier, const blink::WebURLRequest::Priority& priority)
     {
         WebTestProxyBase::didChangeResourcePriority(frame, identifier, priority);
         Base::didChangeResourcePriority(frame, identifier, priority);
     }
-    virtual void didFinishResourceLoad(blink::WebFrame* frame, unsigned identifier)
+    virtual void didFinishResourceLoad(blink::WebLocalFrame* frame, unsigned identifier)
     {
         WebTestProxyBase::didFinishResourceLoad(frame, identifier);
         Base::didFinishResourceLoad(frame, identifier);
     }
-    virtual void runModalAlertDialog(blink::WebFrame* frame, const blink::WebString& message)
+    virtual void runModalAlertDialog(blink::WebLocalFrame* frame, const blink::WebString& message)
     {
         WebTestProxyBase::runModalAlertDialog(frame, message);
         Base::runModalAlertDialog(frame, message);
     }
-    virtual bool runModalConfirmDialog(blink::WebFrame* frame, const blink::WebString& message)
+    virtual bool runModalConfirmDialog(blink::WebLocalFrame* frame, const blink::WebString& message)
     {
         WebTestProxyBase::runModalConfirmDialog(frame, message);
         return Base::runModalConfirmDialog(frame, message);
     }
-    virtual bool runModalPromptDialog(blink::WebFrame* frame, const blink::WebString& message, const blink::WebString& defaultValue, blink::WebString* actualValue)
+    virtual bool runModalPromptDialog(blink::WebLocalFrame* frame, const blink::WebString& message, const blink::WebString& defaultValue, blink::WebString* actualValue)
     {
         WebTestProxyBase::runModalPromptDialog(frame, message, defaultValue, actualValue);
         return Base::runModalPromptDialog(frame, message, defaultValue, actualValue);
     }
-    virtual bool runModalBeforeUnloadDialog(blink::WebFrame* frame, const blink::WebString& message)
+    virtual bool runModalBeforeUnloadDialog(blink::WebLocalFrame* frame, const blink::WebString& message)
     {
         return WebTestProxyBase::runModalBeforeUnloadDialog(frame, message);
     }
-    virtual bool willCheckAndDispatchMessageEvent(blink::WebFrame* sourceFrame, blink::WebFrame* targetFrame, blink::WebSecurityOrigin target, blink::WebDOMMessageEvent event)
+    virtual bool willCheckAndDispatchMessageEvent(blink::WebLocalFrame* sourceFrame, blink::WebFrame* targetFrame, blink::WebSecurityOrigin target, blink::WebDOMMessageEvent event)
     {
         if (WebTestProxyBase::willCheckAndDispatchMessageEvent(sourceFrame, targetFrame, target, event))
             return true;
diff --git a/content/shell/renderer/webkit_test_runner.cc b/content/shell/renderer/webkit_test_runner.cc
index 4141520..1bf9883 100644
--- a/content/shell/renderer/webkit_test_runner.cc
+++ b/content/shell/renderer/webkit_test_runner.cc
@@ -55,10 +55,10 @@
 #include "third_party/WebKit/public/web/WebDevToolsAgent.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
-#include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebHistoryItem.h"
 #include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebLeakDetector.h"
+#include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebScriptSource.h"
 #include "third_party/WebKit/public/web/WebTestingSupport.h"
 #include "third_party/WebKit/public/web/WebView.h"
@@ -72,9 +72,10 @@ using blink::WebDevToolsAgent;
 using blink::WebDeviceMotionData;
 using blink::WebDeviceOrientationData;
 using blink::WebElement;
-using blink::WebFrame;
+using blink::WebLocalFrame;
 using blink::WebGamepads;
 using blink::WebHistoryItem;
+using blink::WebLocalFrame;
 using blink::WebPoint;
 using blink::WebRect;
 using blink::WebScriptSource;
@@ -570,7 +571,8 @@ void WebKitTestRunner::captureHistoryForWindow(
 
 // RenderViewObserver  --------------------------------------------------------
 
-void WebKitTestRunner::DidClearWindowObject(WebFrame* frame, int world_id) {
+void WebKitTestRunner::DidClearWindowObject(WebLocalFrame* frame,
+                                            int world_id) {
   WebTestingSupport::injectInternalsObject(frame);
   if (world_id == 0) {
     ShellRenderProcessObserver::GetInstance()->test_interfaces()->bindTo(frame);
@@ -605,7 +607,7 @@ void WebKitTestRunner::Navigate(const GURL& url) {
   }
 }
 
-void WebKitTestRunner::DidCommitProvisionalLoad(WebFrame* frame,
+void WebKitTestRunner::DidCommitProvisionalLoad(WebLocalFrame* frame,
                                                 bool is_new_navigation) {
   if (!focus_on_next_commit_)
     return;
@@ -613,7 +615,7 @@ void WebKitTestRunner::DidCommitProvisionalLoad(WebFrame* frame,
   render_view()->GetWebView()->setFocusedFrame(frame);
 }
 
-void WebKitTestRunner::DidFailProvisionalLoad(WebFrame* frame,
+void WebKitTestRunner::DidFailProvisionalLoad(WebLocalFrame* frame,
                                               const WebURLError& error) {
   focus_on_next_commit_ = false;
 }
@@ -638,7 +640,7 @@ void WebKitTestRunner::Reset() {
   // Resetting the internals object also overrides the WebPreferences, so we
   // have to sync them to WebKit again.
   WebTestingSupport::resetInternalsObject(
-      render_view()->GetWebView()->mainFrame());
+      render_view()->GetWebView()->mainFrame()->toWebLocalFrame());
   render_view()->SetWebkitPreferences(render_view()->GetWebkitPreferences());
 }
 
@@ -735,12 +737,12 @@ void WebKitTestRunner::OnTryLeakDetection() {
 }
 
 void WebKitTestRunner::TryLeakDetection() {
-  WebFrame* main_frame = render_view()->GetWebView()->mainFrame();
+  WebLocalFrame* main_frame =
+      render_view()->GetWebView()->mainFrame()->toWebLocalFrame();
   DCHECK_EQ(GURL(kAboutBlankURL), GURL(main_frame->document().url()));
   DCHECK(!main_frame->isLoading());
 
-  LeakDetectionResult result = leak_detector_->TryLeakDetection(
-      render_view()->GetWebView()->mainFrame());
+  LeakDetectionResult result = leak_detector_->TryLeakDetection(main_frame);
   Send(new ShellViewHostMsg_LeakDetectionDone(routing_id(), result));
 }
 
diff --git a/content/shell/renderer/webkit_test_runner.h b/content/shell/renderer/webkit_test_runner.h
index 0492d33..49c635d 100644
--- a/content/shell/renderer/webkit_test_runner.h
+++ b/content/shell/renderer/webkit_test_runner.h
@@ -44,13 +44,13 @@ class WebKitTestRunner : public RenderViewObserver,
 
   // RenderViewObserver implementation.
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
-  virtual void DidClearWindowObject(blink::WebFrame* frame,
+  virtual void DidClearWindowObject(blink::WebLocalFrame* frame,
                                     int world_id) OVERRIDE;
   virtual void Navigate(const GURL& url) OVERRIDE;
-  virtual void DidCommitProvisionalLoad(blink::WebFrame* frame,
+  virtual void DidCommitProvisionalLoad(blink::WebLocalFrame* frame,
                                         bool is_new_navigation) OVERRIDE;
-  virtual void DidFailProvisionalLoad(
-      blink::WebFrame* frame, const blink::WebURLError& error) OVERRIDE;
+  virtual void DidFailProvisionalLoad(blink::WebLocalFrame* frame,
+                                      const blink::WebURLError& error) OVERRIDE;
 
   // WebTestDelegate implementation.
   virtual void clearEditCommand() OVERRIDE;