Conversion of content_shell target to use WebLocalFrame.

content/shell/renderer/test_runner/WebFrameTestProxy.h

Index: content/shell/renderer/test_runner/WebFrameTestProxy.h
diff --git a/content/shell/renderer/test_runner/WebFrameTestProxy.h b/content/shell/renderer/test_runner/WebFrameTestProxy.h
index fef3218e7c148fb51c2897b52955d2d2d7b56597..249e798d31d876517d1196dabd0da73ab9d5bd2d 100644
--- a/content/shell/renderer/test_runner/WebFrameTestProxy.h
+++ b/content/shell/renderer/test_runner/WebFrameTestProxy.h
@@ -33,8 +33,8 @@ public:
         m_version = version;
     }
 
-    blink::WebPlugin* createPlugin(blink::WebFrame* frame, const blink::WebPluginParams& params)

[Charlie Reis, 2014/04/03 00:37:11]

Jochen: Why are these files using Blink style inside content?  I'm guessing that
Daniel is using clang-format, which is wrapping all these parameter lines like
we would do in Chromium style, but I also noticed there's a 4 space indent here.
 What's the right thing to do?

[dcheng, 2014/04/03 20:39:57]

Yeah, I used clang-format to wrap overly long lines. This file is in Blink style
because we copied them directly over from Blink and it's not been updated since
then. Not sure what to do =/

[Charlie Reis, 2014/04/03 20:56:31]

I defer to Jochen there.  I expect they should be left in the old style until
(unless?) we move the whole file into the new style.  Having a mix of styles
doesn't make sense to me.

[jochen (gone - plz use gerrit), 2014/04/04 09:01:39]

agreed.

Please consider moving files in test_runner you touch to the content namespace,
rename variables and methods to match chromium style and clang format. This
would be greatly appreciated!

-    {
+    blink::WebPlugin* createPlugin(blink::WebLocalFrame* frame,
+                                   const blink::WebPluginParams& params) {
         blink::WebPlugin* plugin = m_baseProxy->createPlugin(frame, params);
         if (plugin)
             return plugin;
@@ -49,47 +49,44 @@ 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);
     }
     virtual void didChangeSelection(bool is_selection_empty) {
@@ -97,65 +94,82 @@ 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)
             return policy;
 
         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;
         return Base::willCheckAndDispatchMessageEvent(sourceFrame, targetFrame, target, event);