Conversion of content_shell target to use WebLocalFrame.

content/public/renderer/render_frame.h

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CONTENT_PUBLIC_RENDERER_RENDER_FRAME_H_
 #define CONTENT_PUBLIC_RENDERER_RENDER_FRAME_H_
 
 #include "base/strings/string16.h"
 #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"

[Charlie Reis, 2014/04/02 23:34:15]

Why is this needed for now?  And what will change to allow us to remove it
later?

[dcheng, 2014/04/02 23:47:08]

WebLocalFrame is currently a typedef, and you cannot forward declare typedefs.
However, I cannot make it a class either--the alternative was to temporarily
double up all the methods in public/web that are changing to take a
WebLocalFrame.

Once this conversion is complete, I will convert WebLocalFrame to be a subclass
so it can be forward declared in most places again.

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

I see, thanks.

 #include "third_party/WebKit/public/web/WebNavigationPolicy.h"
 
 struct WebPreferences;
 
 namespace blink {
 class WebFrame;
 class WebNode;
 class WebPlugin;
 class WebURLRequest;
 struct WebPluginParams;
 }
 
 namespace content {
 class ContextMenuClient;
 class RenderView;
 struct ContextMenuParams;
 struct WebPluginInfo;
 
 // This interface wraps functionality, which is specific to frames, such as
 // navigation. It provides communication with a corresponding RenderFrameHost
 // in the browser process.
 class CONTENT_EXPORT RenderFrame : public IPC::Listener,
                                    public IPC::Sender {
  public:
   // Returns the RenderFrame given a WebFrame.
   static RenderFrame* FromWebFrame(blink::WebFrame* web_frame);

[Charlie Reis, 2014/04/02 23:34:15]

I'm not sure why some uses of WebFrame are being replaced but not others.  For
example, this method wouldn't make sense to call on a WebRemoteFrame.

[dcheng, 2014/04/02 23:47:08]

Because this didn't fail to compile. It's true that this doesn't make sense to
call on remote frames; would you be OK if I change this in a separate patch? I'd
like to keep the patch size somewhat manageable.

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

Just to fill me in, what didn't compile?  I'd like to make sense of which things
need to get migrated.  Is it the set of places that call methods that won't
exist on WebRemoteFrame?
Yes, that's fine-- we definitely don't need to update them all at once.

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

For figuring out what needs to change, I changed WebLocalFrame from a typedef to
subclassing WebFrame. This patch addresses all the compile failures from trying
to down cast a WebFrame to a WebLocalFrame without going through
toWebLocalFrame().

I expect that I'll have to a second round of cleanups in Chrome as I move things
from WebFrame to WebLocalFrame, but it should be a lot smaller than these
initial patches.

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

I think the part that I was missing was that you have already chosen a set of
things to change from WebFrame to WebLocalFrame in WebFrameClient, and this CL
just echoes that change on the Chrome side.

In other words, you separately decided that things like frameDetached shouldn't
use WebLocalFrame, and this part is just mechanical.  (My original question was
more about how you made that decision, but I see that there's reasons for the
cases you left as WebFrame.)
Sure.

 
   // Returns the RenderView associated with this frame.
   virtual RenderView* GetRenderView() = 0;
 
   // Get the routing ID of the frame.
   virtual int GetRoutingID() = 0;
 
   // Returns the associated WebFrame.
   virtual blink::WebFrame* GetWebFrame() = 0;
 
@@ skipping 22 matching lines @@
   virtual blink::WebNode GetContextMenuNode() const = 0;
 
   // Create a new NPAPI/Pepper plugin depending on |info|. Returns NULL if no
   // plugin was found.
   virtual blink::WebPlugin* CreatePlugin(
       blink::WebFrame* frame,
       const WebPluginInfo& info,
       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;
 
  protected:
   virtual ~RenderFrame() {}
 
  private:
   // This interface should only be implemented inside content.
   friend class RenderFrameImpl;
   RenderFrame() {}
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_RENDERER_RENDER_FRAME_H_