Make RenderFrameProxy a WebRemoteFrameClient

content/renderer/render_frame_proxy.h

 // Copyright 2014 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_RENDERER_RENDER_FRAME_PROXY_H_
 #define CONTENT_RENDERER_RENDER_FRAME_PROXY_H_
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "content/common/content_export.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_sender.h"
 
-#include "third_party/WebKit/public/web/WebFrameClient.h"
 #include "third_party/WebKit/public/web/WebRemoteFrame.h"
+#include "third_party/WebKit/public/web/WebRemoteFrameClient.h"
 
 struct FrameMsg_BuffersSwapped_Params;
 struct FrameMsg_CompositorFrameSwapped_Params;
 
 namespace content {
 
 class ChildFrameCompositingHelper;
 class RenderFrameImpl;
 class RenderViewImpl;
 
@@ skipping 13 matching lines @@
 // Long term, RenderFrameProxy will be created to replace the RenderFrame in the
 // frame tree and the RenderFrame will be deleted after its unload handler has
 // finished executing. It will still be responsible for routing IPC messages
 // which are valid for cross-site interactions between frames.
 // RenderFrameProxy will be deleted when the node in the frame tree is deleted
 // or when navigating the frame causes it to return to this process and a new
 // RenderFrame is created for it.
 class CONTENT_EXPORT RenderFrameProxy
     : public IPC::Listener,
       public IPC::Sender,
-      NON_EXPORTED_BASE(public blink::WebFrameClient) {
+      NON_EXPORTED_BASE(public blink::WebRemoteFrameClient) {
  public:
   // This method should be used to create a RenderFrameProxy, which will replace
   // an existing RenderFrame during its cross-process navigation from the
   // current process to a different one. |routing_id| will be ID of the newly
   // created RenderFrameProxy. |frame_to_replace| is the frame that the new
   // proxy will eventually swap places with.
   static RenderFrameProxy* CreateProxyToReplaceFrame(
       RenderFrameImpl* frame_to_replace,
       int routing_id);
 
@@ skipping 26 matching lines @@
   virtual bool Send(IPC::Message* msg) OVERRIDE;
 
   // Out-of-process child frames receive a signal from RenderWidgetCompositor
   // when a compositor frame has committed.
   void DidCommitCompositorFrame();
 
   int routing_id() { return routing_id_; }
   RenderViewImpl* render_view() { return render_view_; }
   blink::WebRemoteFrame* web_frame() { return web_frame_; }
 
+  // blink::WebRemoteFrameClient implementation:
+  virtual void postMessageEvent(
+      blink::WebLocalFrame* sourceFrame,
+      blink::WebRemoteFrame* targetFrame,
+      blink::WebSecurityOrigin target,
+      blink::WebDOMMessageEvent event);
+
  private:
   RenderFrameProxy(int routing_id, int frame_routing_id);
 
   void Init(blink::WebRemoteFrame* frame, RenderViewImpl* render_view);
 
   // IPC::Listener
   virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
 
   // IPC handlers
   void OnDeleteProxy();
@@ skipping 14 matching lines @@
   scoped_refptr<ChildFrameCompositingHelper> compositing_helper_;
 
   RenderViewImpl* render_view_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderFrameProxy);
 };
 
 }  // namespace
 
 #endif  // CONTENT_RENDERER_RENDER_FRAME_PROXY_H_