Separate RenderViewHost from RenderWidgetHost, part 4: delegate

content/browser/renderer_host/render_widget_host_impl.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_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_IMPL_H_
 #define CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_IMPL_H_
 
 #include <list>
 #include <map>
 #include <string>
@@ skipping 53 matching lines @@
 namespace gfx {
 class Range;
 }
 
 namespace content {
 
 class BrowserAccessibilityManager;
 class InputRouter;
 class MockRenderWidgetHost;
 class RenderWidgetHostDelegate;
+class RenderWidgetHostOwnerDelegate;
 class SyntheticGestureController;
 class TimeoutMonitor;
 class TouchEmulator;
 class WebCursor;
 struct EditCommand;
 
 // This implements the RenderWidgetHost interface that is exposed to
 // embedders of content, and adds things only visible to content.
 class CONTENT_EXPORT RenderWidgetHostImpl : public RenderWidgetHost,
                                             public InputRouterClient,
                                             public InputAckHandler,
                                             public TouchEmulatorClient,
                                             public IPC::Listener {
  public:
   // |routing_id| must not be MSG_ROUTING_NONE.
   // If this object outlives |delegate|, DetachDelegate() must be called when
   // |delegate| goes away.
   RenderWidgetHostImpl(RenderWidgetHostDelegate* delegate,
                        RenderProcessHost* process,
                        int32_t routing_id,
                        bool hidden);
   ~RenderWidgetHostImpl() override;
 
   // Similar to RenderWidgetHost::FromID, but returning the Impl object.
   static RenderWidgetHostImpl* FromID(int32_t process_id, int32_t routing_id);
 
   // Returns all RenderWidgetHosts including swapped out ones for
   // internal use. The public interface
-  // RendgerWidgetHost::GetRenderWidgetHosts only returns active ones.
+  // RenderWidgetHost::GetRenderWidgetHosts only returns active ones.
   static scoped_ptr<RenderWidgetHostIterator> GetAllRenderWidgetHosts();
 
-  // Use RenderWidgetHostImpl::From(rwh) to downcast a
-  // RenderWidgetHost to a RenderWidgetHostImpl.  Internally, this
-  // uses RenderWidgetHost::AsRenderWidgetHostImpl().
+  // Use RenderWidgetHostImpl::From(rwh) to downcast a RenderWidgetHost to a
+  // RenderWidgetHostImpl.
   static RenderWidgetHostImpl* From(RenderWidgetHost* rwh);
 
   void set_hung_renderer_delay(const base::TimeDelta& delay) {
     hung_renderer_delay_ = delay;
   }
 
   base::TimeDelta hung_renderer_delay() { return hung_renderer_delay_; }
 
   void set_new_content_rendering_delay_for_testing(
       const base::TimeDelta& delay) {
     new_content_rendering_delay_ = delay;
   }
 
   base::TimeDelta new_content_rendering_delay() {
     return new_content_rendering_delay_;
   }
+
+  void set_owner_delegate(RenderWidgetHostOwnerDelegate* owner_delegate) {
+    owner_delegate_ = owner_delegate;
+  }
+
+  RenderWidgetHostOwnerDelegate* owner_delegate() { return owner_delegate_; }
+
   // RenderWidgetHost implementation.
   void UpdateTextDirection(blink::WebTextDirection direction) override;
   void NotifyTextDirection() override;
   void Focus() override;
   void Blur() override;
   void SetActive(bool active) override;
   void CopyFromBackingStore(const gfx::Rect& src_rect,
                             const gfx::Size& accelerated_dst_size,
                             const ReadbackRequestCallback& callback,
                             const SkColorType preferred_color_type) override;
   bool CanCopyFromBackingStore() override;
 #if defined(OS_ANDROID)
   void LockBackingStore() override;
   void UnlockBackingStore() override;
 #endif
   void ForwardMouseEvent(const blink::WebMouseEvent& mouse_event) override;
   void ForwardWheelEvent(const blink::WebMouseWheelEvent& wheel_event) override;
   void ForwardKeyboardEvent(const NativeWebKeyboardEvent& key_event) override;
   RenderProcessHost* GetProcess() const override;
   int GetRoutingID() const override;
   RenderWidgetHostViewBase* GetView() const override;
   bool IsLoading() const override;
-  bool IsRenderView() const override;
   void ResizeRectChanged(const gfx::Rect& new_rect) override;
   void RestartHangMonitorTimeout() override;
   void SetIgnoreInputEvents(bool ignore_input_events) override;
   void WasResized() override;
   void AddKeyPressEventCallback(const KeyPressEventCallback& callback) override;
   void RemoveKeyPressEventCallback(
       const KeyPressEventCallback& callback) override;
   void AddMouseEventCallback(const MouseEventCallback& callback) override;
   void RemoveMouseEventCallback(const MouseEventCallback& callback) override;
   void GetWebScreenInfo(blink::WebScreenInfo* result) override;
@@ skipping 516 matching lines @@
 
   // true if a renderer has once been valid. We use this flag to display a sad
   // tab only when we lose our renderer and not if a paint occurs during
   // initialization.
   bool renderer_initialized_;
 
   // Our delegate, which wants to know mainly about keyboard events.
   // It will remain non-NULL until DetachDelegate() is called.
   RenderWidgetHostDelegate* delegate_;
 
+  // The delegate of the owner of this object.
+  RenderWidgetHostOwnerDelegate* owner_delegate_;
+
   // Created during construction and guaranteed never to be NULL, but its
   // channel may be NULL if the renderer crashed, so one must always check that.
   RenderProcessHost* const process_;
 
   // The ID of the corresponding object in the Renderer Instance.
   const int routing_id_;
 
   // Indicates whether a page is loading or not.
   bool is_loading_;
 
@@ skipping 151 matching lines @@
   base::TimeDelta new_content_rendering_delay_;
 
   base::WeakPtrFactory<RenderWidgetHostImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_IMPL_H_