Conversion of content_shell target to use WebLocalFrame.

content/public/renderer/render_view_observer.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CONTENT_PUBLIC_RENDERER_RENDER_VIEW_OBSERVER_H_
 #define CONTENT_PUBLIC_RENDERER_RENDER_VIEW_OBSERVER_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "content/common/content_export.h"
 #include "ipc/ipc_listener.h"
 #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;
 
 namespace ppapi {
 namespace host {
 class PpapiHost;
 }
 }
 
 namespace blink {
@@ skipping 20 matching lines @@
 class CONTENT_EXPORT RenderViewObserver : public IPC::Listener,
                                           public IPC::Sender {
  public:
   // By default, observers will be deleted when the RenderView goes away.  If
   // they want to outlive it, they can override this function.
   virtual void OnDestruct();
 
   // 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() {}
 
   // These match the RenderView methods.
   virtual void DidHandleMouseEvent(const blink::WebMouseEvent& event) {}
   virtual void DidHandleTouchEvent(const blink::WebTouchEvent& event) {}
 
   // This matches the RenderWidget method.
   virtual void WillProcessUserGesture() {}
@@ skipping 40 matching lines @@
   RenderView* render_view_;
   // The routing ID of the associated RenderView.
   int routing_id_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderViewObserver);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_RENDERER_RENDER_VIEW_OBSERVER_H_