Conversion of content_shell target to use WebLocalFrame.

content/public/renderer/render_view_observer.h

Index: content/public/renderer/render_view_observer.h
diff --git a/content/public/renderer/render_view_observer.h b/content/public/renderer/render_view_observer.h
index aed5a2f59d89384569a4e886871a112a8187366a..e0a4ee21bd05925a17ec37dcd461fcd28ba8c340 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) {}

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

Again, why FrameCreated but not FrameDetached, etc?

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

This is somewhat subtle and just a starting point. It may be incorrect and
change over time. Here's my current thoughts:

1) Actually creating a child frame is only going to happen in the parent's
renderer. So the parent is always local. But the child may be local or remote.
It's not clear to me yet that mirroring the frame tree should go through the
same callback. Maybe it should, and then we'd need to change it at that point.
It made sense at the Blink layer; maybe it doesn't make sense in content.

2) Our story for frame detach isn't yet clear. I think we may still want to do
the right thing and order frame detaches correctly. In that case, we could use
frameDetached()/frameWillClose() to implement that forwarding. It makes sense at
the Blink layer... but maybe it doesn't make sense to expose that outside of
content.

I expect both of these to become clearer with time. If we do have to change the
signatures later, it will be a lot more straightforward than these patches.

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

Yeah, guess I stumbled onto a pretty subtle one.  Hopefully this
created/detached distinction can be documented in the WebFrameClient API?

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

Once we figure it out, we'll document the differences. I'm hesitant to write
comments until we have frame mirroring completely implemented.

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

Ok in this case, but I disagree about skipping comments until we finish building
things.  We're never finished building, so we have to document as we go.

[dcheng, 2014/04/03 21:03:25]

Right, but currently it's completely unknown. Any comment I write will be at
best half accurate and at worst, completely wrong. It will require a high level
of coordination between Chrome and Blink, and I can't provide guidance to
implementations of WebFrameClient yet because there are still too many pieces
moving on both sides. Once we have something more solid, then it's easy enough
to add accurate comments.

   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() {}