Extract minimal RenderViewHost interface for embedders, leaving

content/browser/renderer_host/render_widget_host.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_H_
 #define CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_H_
 #pragma once
 
 #include <deque>
 #include <string>
@@ skipping 21 matching lines @@
 
 #if defined(TOOLKIT_GTK)
 #include "ui/base/x/x11_util.h"
 #elif defined(OS_MACOSX)
 #include "skia/ext/platform_device.h"
 #endif
 
 class BackingStore;
 struct EditCommand;
 class RenderViewHost;
+class RenderWidgetHostImpl;
 class TransportDIB;
 struct ViewHostMsg_UpdateRect_Params;
 class WebCursor;
 
 namespace base {
 class TimeTicks;
 }
 
 namespace content {
 class RenderProcessHost;
@@ skipping 20 matching lines @@
 struct WebScreenInfo;
 }
 
 // TODO(joi): Extract relevant bit of class documentation from
 // RenderWidgetHostImpl documentation.  TODO(joi): Move to
 // content/public/browser/render_widget_host.h
 //
 // TODO(joi): Once I finish defining this interface (once
 // RenderViewHost interface is also in place), group together
 // implementation functions in subclasses.
-class CONTENT_EXPORT RenderWidgetHost {
+//
+// TODO(joi): Move to file render_widget_host_impl.h
+class CONTENT_EXPORT RenderWidgetHost : public IPC::Channel::Sender {
  public:
-  explicit RenderWidgetHost(content::RenderProcessHost* process);
   virtual ~RenderWidgetHost() {}
 
+  // Edit operations.
+  virtual void Undo() = 0;
+  virtual void Redo() = 0;
+  virtual void Cut() = 0;
+  virtual void Copy() = 0;
+  virtual void CopyToFindPboard() = 0;
+  virtual void Paste() = 0;
+  virtual void PasteAndMatchStyle() = 0;
+  virtual void Delete() = 0;
+  virtual void SelectAll() = 0;
+
+  // Update the text direction of the focused input element and notify it to a
+  // renderer process.
+  // These functions have two usage scenarios: changing the text direction
+  // from a menu (as Safari does), and; changing the text direction when a user
+  // presses a set of keys (as IE and Firefox do).
+  // 1. Change the text direction from a menu.
+  // In this scenario, we receive a menu event only once and we should update
+  // the text direction immediately when a user chooses a menu item. So, we
+  // should call both functions at once as listed in the following snippet.
+  //   void RenderViewHost::SetTextDirection(WebTextDirection direction) {
+  //     UpdateTextDirection(direction);
+  //     NotifyTextDirection();
+  //   }
+  // 2. Change the text direction when pressing a set of keys.
+  // Because of auto-repeat, we may receive the same key-press event many
+  // times while we presses the keys and it is nonsense to send the same IPC
+  // message every time when we receive a key-press event.
+  // To suppress the number of IPC messages, we just update the text direction
+  // when receiving a key-press event and send an IPC message when we release
+  // the keys as listed in the following snippet.
+  //   if (key_event.type == WebKeyboardEvent::KEY_DOWN) {
+  //     if (key_event.windows_key_code == 'A' &&
+  //         key_event.modifiers == WebKeyboardEvent::CTRL_KEY) {
+  //       UpdateTextDirection(dir);
+  //     } else {
+  //       CancelUpdateTextDirection();
+  //     }
+  //   } else if (key_event.type == WebKeyboardEvent::KEY_UP) {
+  //     NotifyTextDirection();
+  //   }
+  // Once we cancel updating the text direction, we have to ignore all
+  // succeeding UpdateTextDirection() requests until calling
+  // NotifyTextDirection(). (We may receive keydown events even after we
+  // canceled updating the text direction because of auto-repeat.)
+  // Note: we cannot undo this change for compatibility with Firefox and IE.
+  virtual void UpdateTextDirection(WebKit::WebTextDirection direction) = 0;
+  virtual void NotifyTextDirection() = 0;
+
+  virtual void Blur() = 0;
+
+  // Copies the contents of the backing store into the given (uninitialized)
+  // PlatformCanvas. Returns true on success, false otherwise.
+  virtual bool CopyFromBackingStore(skia::PlatformCanvas* output) = 0;
+
+#if defined(TOOLKIT_GTK)
+  // Paint the backing store into the target's |dest_rect|.
+  virtual bool CopyFromBackingStoreToGtkWindow(const gfx::Rect& dest_rect,
+                                               GdkWindow* target) = 0;
+#elif defined(OS_MACOSX)
+  virtual gfx::Size GetBackingStoreSize() = 0;
+  virtual bool CopyFromBackingStoreToCGContext(const CGRect& dest_rect,
+                                               CGContextRef target) = 0;
+#endif
+
+  // Enable renderer accessibility. This should only be called when a
+  // screenreader is detected.
+  virtual void EnableRendererAccessibility() = 0;
+
+  // Forwards the given message to the renderer. These are called by
+  // the view when it has received a message.
+  virtual void ForwardMouseEvent(
+      const WebKit::WebMouseEvent& mouse_event) = 0;
+  virtual void ForwardWheelEvent(
+      const WebKit::WebMouseWheelEvent& wheel_event) = 0;
+  virtual void ForwardKeyboardEvent(
+      const NativeWebKeyboardEvent& key_event) = 0;
+
+  virtual const gfx::Point& GetLastScrollOffset() const = 0;
+
+  virtual content::RenderProcessHost* GetProcess() const = 0;
+
+  virtual int GetRoutingID() const = 0;
+
+  // Gets the View of this RenderWidgetHost. Can be NULL, e.g. if the
+  // RenderWidget is being destroyed or the render process crashed. You should
+  // never cache this pointer since it can become NULL if the renderer crashes,
+  // instead you should always ask for it using the accessor.
+  virtual content::RenderWidgetHostView* GetView() const = 0;
+
+  // Returns true if this is a RenderViewHost, false if not.
+  virtual bool IsRenderView() const = 0;
+
   // Used as the details object for a
   // RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK notification.
   // TODO(joi): Switch out for a std::pair.
   struct PaintAtSizeAckDetails {
     // The tag that was passed to the PaintAtSize() call that triggered this
     // ack.
     int tag;
     gfx::Size size;
   };
 
   // This tells the renderer to paint into a bitmap and return it,
   // regardless of whether the tab is hidden or not.  It resizes the
   // web widget to match the |page_size| and then returns the bitmap
   // scaled so it matches the |desired_size|, so that the scaling
   // happens on the rendering thread.  When the bitmap is ready, the
   // renderer sends a PaintAtSizeACK to this host, and a
   // RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK notification is issued.
   // Note that this bypasses most of the update logic that is normally invoked,
   // and doesn't put the results into the backing store.
   virtual void PaintAtSize(TransportDIB::Handle dib_handle,
                            int tag,
                            const gfx::Size& page_size,
                            const gfx::Size& desired_size) = 0;
 
-  // Copies the contents of the backing store into the given (uninitialized)
-  // PlatformCanvas. Returns true on success, false otherwise.
-  virtual bool CopyFromBackingStore(skia::PlatformCanvas* output) = 0;
+  // Makes an IPC call to tell webkit to replace the currently selected word
+  // or a word around the cursor.
+  virtual void Replace(const string16& word) = 0;
 
-#if defined(TOOLKIT_GTK)
-  // Paint the backing store into the target's |dest_rect|.
-  virtual bool CopyFromBackingStoreToGtkWindow(const gfx::Rect& dest_rect,
-                                               GdkWindow* target) = 0;
-#elif defined(OS_MACOSX)
-  virtual gfx::Size GetBackingStoreSize() = 0;
-  virtual bool CopyFromBackingStoreToCGContext(const CGRect& dest_rect,
-                                               CGContextRef target) = 0;
-#endif
+  // Called to notify the RenderWidget that the resize rect has changed without
+  // the size of the RenderWidget itself changing.
+  virtual void ResizeRectChanged(const gfx::Rect& new_rect) = 0;
 
-  // Returns true if this is a RenderViewHost, false if not.
-  virtual bool IsRenderView() const = 0;
+  // Restart the active hang monitor timeout. Clears all existing timeouts and
+  // starts with a new one.  This can be because the renderer has become
+  // active, the tab is being hidden, or the user has chosen to wait some more
+  // to give the tab a chance to become active and we don't want to display a
+  // warning too soon.
+  virtual void RestartHangMonitorTimeout() = 0;
+
+  virtual void SetIgnoreInputEvents(bool ignore_input_events) = 0;
+
+  // Stops loading the page.
+  virtual void Stop() = 0;
 
   // Called to notify the RenderWidget that it has been resized.
   virtual void WasResized() = 0;
 
-  // TODO(joi): Get rid of these inline accessors and the associated
-  // data from the interface, make them into pure virtual GetFoo
-  // methods instead.
-  content::RenderProcessHost* process() const { return process_; }
+  // Access to the implementation's
+  // IPC::Channel::Listener::OnMessageReceived.  Intended only for
+  // test code.
 
-  // Gets the View of this RenderWidgetHost. Can be NULL, e.g. if the
-  // RenderWidget is being destroyed or the render process crashed. You should
-  // never cache this pointer since it can become NULL if the renderer crashes,
-  // instead you should always ask for it using the accessor.
-  content::RenderWidgetHostView* view() const;
+  // TODO(joi): Remove this and convert the single test using it to
+  // get the TabContentsWrapper from
+  // browser()->GetSelectedWebContents() and then call its
+  // translate_tab_helper() to get at the object that dispatches its
+  // method.
+  virtual bool OnMessageReceivedForTesting(const IPC::Message& msg) = 0;
+
+  // Retrieves the implementation class.  Intended only for code
+  // within content/.  This method is necessary because
+  // RenderWidgetHost is the root of a diamond inheritance pattern, so
+  // subclasses inherit it virtually, which removes our ability to
+  // static_cast to the subclass.
+  virtual RenderWidgetHostImpl* AsRWHImpl() = 0;

[darin (slow to review), 2012/03/01 23:15:39]

It is unfortunate that we need this, but I completely get why it exists.

A couple things that are unfortunate:
1-  RenderWidgetHost is abbreviated.  I realize AsRenderWidgetHostImpl() is a
mouthful.
2-  It might be nice if the public entry point to this down-casting
functionality were somehow defined on RenderWidgetHostImpl instead.  It could be
an inline helper that still calls some virtual method defined on
RenderWidgetHost, but the virtual method could be made private.  Not sure if
this helps.

RenderWidgetHostImpl* impl = RenderWidgetHostImpl::From(render_widget_host);

This is somewhat nice because it hides the function from public consumers of
RenderWidgetHost.

You could also have a globally defined function named toRenderWidgetHostImpl
that works just like the From method shown above.

[Jói, 2012/03/02 10:40:36]

I switched to a static RenderWidgetHostImpl::From method as suggested.  This
still calls a protected RenderWidgetHost::AsRenderWidgetHostImpl method, since
the cast can't be done statically (so we rely on a virtual method), but I agree
this hides things more nicely from embedders; before it was a public method and
I relied on our DEPS mechanism to make it unusable; now we also have a C++
mechanism to hide it.

 
   // Gets a RenderVidgetHost pointer from an IPC::Channel::Listener pointer.
   static RenderWidgetHost* FromIPCChannelListener(
       IPC::Channel::Listener* listener);
   static const RenderWidgetHost* FromIPCChannelListener(
       const IPC::Channel::Listener* listener);
 
   // Free all backing stores used for rendering to drop memory usage.
   static void RemoveAllBackingStores();
 
   // Returns the size of all the backing stores used for rendering
   static size_t BackingStoreMemorySize();
-
- protected:
-  // Created during construction but initialized during Init*(). Therefore, it
-  // is guaranteed never to be NULL, but its channel may be NULL if the
-  // renderer crashed, so you must always check that.
-  content::RenderProcessHost* process_;
-
-  // The View associated with the RenderViewHost. The lifetime of this object
-  // is associated with the lifetime of the Render process. If the Renderer
-  // crashes, its View is destroyed and this pointer becomes NULL, even though
-  // render_view_host_ lives on to load another URL (creating a new View while
-  // doing so).
-  content::RenderWidgetHostViewPort* view_;
 };
 
 // This class manages the browser side of a browser<->renderer HWND connection.
 // The HWND lives in the browser process, and windows events are sent over
 // IPC to the corresponding object in the renderer.  The renderer paints into
 // shared memory, which we transfer to a backing store and blit to the screen
 // when Windows sends us a WM_PAINT message.
 //
 // How Shutdown Works
 //
@@ skipping 57 matching lines @@
 //
 // It should be noted that the RenderViewHost, not the RenderWidgetHost,
 // handles IPC messages relating to the render process going away, since the
 // way a RenderViewHost (TabContents) handles the process dying is different to
 // the way a select popup does. As such the RenderWidgetHostView handles these
 // messages for select popups. This placement is more out of convenience than
 // anything else. When the view is live, these messages are forwarded to it by
 // the RenderWidgetHost's IPC message map.
 //
 // TODO(joi): Move to content namespace.
-class CONTENT_EXPORT RenderWidgetHostImpl : public RenderWidgetHost,
-                                            public IPC::Channel::Listener,
-                                            public IPC::Channel::Sender {
+class CONTENT_EXPORT RenderWidgetHostImpl : virtual public RenderWidgetHost,
+                                            public IPC::Channel::Listener {
  public:
   // routing_id can be MSG_ROUTING_NONE, in which case the next available
   // routing id is taken from the RenderProcessHost.
   RenderWidgetHostImpl(content::RenderProcessHost* process, int routing_id);
   virtual ~RenderWidgetHostImpl();
 
   static RenderWidgetHostImpl* FromRWHV(content::RenderWidgetHostView* rwhv);
 
+  // RenderWidgetHost implementation.
+  virtual void Undo() OVERRIDE;
+  virtual void Redo() OVERRIDE;
+  virtual void Cut() OVERRIDE;
+  virtual void Copy() OVERRIDE;
+  virtual void CopyToFindPboard() OVERRIDE;
+  virtual void Paste() OVERRIDE;
+  virtual void PasteAndMatchStyle() OVERRIDE;
+  virtual void Delete() OVERRIDE;
+  virtual void SelectAll() OVERRIDE;
+  virtual void UpdateTextDirection(WebKit::WebTextDirection direction) OVERRIDE;
+  virtual void NotifyTextDirection() OVERRIDE;
+  virtual void Blur() OVERRIDE;
+  virtual bool CopyFromBackingStore(skia::PlatformCanvas* output) OVERRIDE;
+#if defined(TOOLKIT_GTK)
+  virtual bool CopyFromBackingStoreToGtkWindow(const gfx::Rect& dest_rect,
+                                               GdkWindow* target) OVERRIDE;
+#elif defined(OS_MACOSX)
+  virtual gfx::Size GetBackingStoreSize() OVERRIDE;
+  virtual bool CopyFromBackingStoreToCGContext(const CGRect& dest_rect,
+                                               CGContextRef target) OVERRIDE;
+#endif
+  virtual void EnableRendererAccessibility() OVERRIDE;
+  virtual void ForwardMouseEvent(
+      const WebKit::WebMouseEvent& mouse_event) OVERRIDE;
+  virtual void ForwardWheelEvent(
+      const WebKit::WebMouseWheelEvent& wheel_event) OVERRIDE;
+  virtual void ForwardKeyboardEvent(
+      const NativeWebKeyboardEvent& key_event) OVERRIDE;
+  virtual const gfx::Point& GetLastScrollOffset() const OVERRIDE;
+  virtual content::RenderProcessHost* GetProcess() const OVERRIDE;
+  virtual int GetRoutingID() const OVERRIDE;
+  virtual content::RenderWidgetHostView* GetView() const OVERRIDE;
+  virtual bool IsRenderView() const OVERRIDE;
+  virtual void PaintAtSize(TransportDIB::Handle dib_handle,
+                           int tag,
+                           const gfx::Size& page_size,
+                           const gfx::Size& desired_size) OVERRIDE;
+  virtual void Replace(const string16& word) OVERRIDE;
+  virtual void ResizeRectChanged(const gfx::Rect& new_rect) OVERRIDE;
+  virtual void RestartHangMonitorTimeout() OVERRIDE;
+  virtual void SetIgnoreInputEvents(bool ignore_input_events) OVERRIDE;
+  virtual void Stop() OVERRIDE;
+  virtual void WasResized() OVERRIDE;
+  virtual bool OnMessageReceivedForTesting(const IPC::Message& msg) OVERRIDE;
+  virtual RenderWidgetHostImpl* AsRWHImpl() OVERRIDE;
+
   // Sets the View of this RenderWidgetHost.
   void SetView(content::RenderWidgetHostView* view);
 
-  int routing_id() const { return routing_id_; }
   int surface_id() const { return surface_id_; }
   bool renderer_accessible() { return renderer_accessible_; }
 
   bool empty() const { return current_size_.IsEmpty(); }
 
   // Returns the property bag for this widget, where callers can add extra data
   // they may wish to associate with it. Returns a pointer rather than a
   // reference since the PropertyAccessors expect this.
   const base::PropertyBag* property_bag() const { return &property_bag_; }
   base::PropertyBag* property_bag() { return &property_bag_; }
 
   // Called when a renderer object already been created for this host, and we
   // just need to be attached to it. Used for window.open, <select> dropdown
   // menus, and other times when the renderer initiates creating an object.
   void Init();
 
   // Tells the renderer to die and then calls Destroy().
   virtual void Shutdown();
 
-  // Manual RTTI FTW. We are not hosting a web page.
-  virtual bool IsRenderView() const OVERRIDE;
-
   // IPC::Channel::Listener
   virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
 
   // Sends a message to the corresponding object in the renderer.
   virtual bool Send(IPC::Message* msg) OVERRIDE;
 
   // Called to notify the RenderWidget that it has been hidden or restored from
   // having been hidden.
   void WasHidden();
   void WasRestored();
 
-  virtual void WasResized() OVERRIDE;
-
-  // Called to notify the RenderWidget that the resize rect has changed without
-  // the size of the RenderWidget itself changing.
-  void ResizeRectChanged(const gfx::Rect& new_rect);
-
   // Called to notify the RenderWidget that its associated native window got
   // focused.
   virtual void GotFocus();
 
   // Tells the renderer it got/lost focus.
   void Focus();
-  void Blur();
   virtual void LostCapture();
 
   // Sets whether the renderer should show controls in an active state.  On all
   // platforms except mac, that's the same as focused. On mac, the frontmost
   // window will show active controls even if the focus is not in the web
   // contents, but e.g. in the omnibox.
   void SetActive(bool active);
 
   // Called to notify the RenderWidget that it has lost the mouse lock.
   virtual void LostMouseLock();
 
   // Tells us whether the page is rendered directly via the GPU process.
   bool is_accelerated_compositing_active() {
     return is_accelerated_compositing_active_;
   }
 
   // Notifies the RenderWidgetHost that the View was destroyed.
   void ViewDestroyed();
 
   // Indicates if the page has finished loading.
   void SetIsLoading(bool is_loading);
 
-  virtual bool CopyFromBackingStore(skia::PlatformCanvas* output) OVERRIDE;
-#if defined(TOOLKIT_GTK)
-  virtual bool CopyFromBackingStoreToGtkWindow(const gfx::Rect& dest_rect,
-                                               GdkWindow* target) OVERRIDE;
-#elif defined(OS_MACOSX)
-  virtual gfx::Size GetBackingStoreSize() OVERRIDE;
-  virtual bool CopyFromBackingStoreToCGContext(const CGRect& dest_rect,
-                                               CGContextRef target) OVERRIDE;
-#endif
-  virtual void PaintAtSize(TransportDIB::Handle dib_handle,
-                           int tag,
-                           const gfx::Size& page_size,
-                           const gfx::Size& desired_size) OVERRIDE;
-
   // Get access to the widget's backing store.  If a resize is in progress,
   // then the current size of the backing store may be less than the size of
   // the widget's view.  If you pass |force_create| as true, then the backing
   // store will be created if it doesn't exist. Otherwise, NULL will be returned
   // if the backing store doesn't already exist. It will also return NULL if the
   // backing store could not be created.
   BackingStore* GetBackingStore(bool force_create);
 
   // Allocate a new backing store of the given size. Returns NULL on failure
   // (for example, if we don't currently have a RenderWidgetHostView.)
   BackingStore* AllocBackingStore(const gfx::Size& size);
 
   // When a backing store does asynchronous painting, it will call this function
   // when it is done with the DIB. We will then forward a message to the
   // renderer to send another paint.
   void DonePaintingToBackingStore();
 
   // GPU accelerated version of GetBackingStore function. This will
   // trigger a re-composite to the view. If a resize is pending, it will
   // block briefly waiting for an ack from the renderer.
   void ScheduleComposite();
 
   // Starts a hang monitor timeout. If there's already a hang monitor timeout
   // the new one will only fire if it has a shorter delay than the time
   // left on the existing timeouts.
   void StartHangMonitorTimeout(base::TimeDelta delay);
 
-  // Restart the active hang monitor timeout. Clears all existing timeouts and
-  // starts with a new one.  This can be because the renderer has become
-  // active, the tab is being hidden, or the user has chosen to wait some more
-  // to give the tab a chance to become active and we don't want to display a
-  // warning too soon.
-  void RestartHangMonitorTimeout();
-
   // Stops all existing hang monitor timeouts and assumes the renderer is
   // responsive.
   void StopHangMonitorTimeout();
 
   // Forwards the given message to the renderer. These are called by the view
   // when it has received a message.
-  virtual void ForwardMouseEvent(const WebKit::WebMouseEvent& mouse_event);
+  void ForwardGestureEvent(const WebKit::WebGestureEvent& gesture_event);
+  virtual void ForwardTouchEvent(const WebKit::WebTouchEvent& touch_event);
+
+  void CancelUpdateTextDirection();
+
   // Called when a mouse click activates the renderer.
   virtual void OnMouseActivate();
-  void ForwardWheelEvent(const WebKit::WebMouseWheelEvent& wheel_event);
-  void ForwardGestureEvent(const WebKit::WebGestureEvent& gesture_event);
-  virtual void ForwardKeyboardEvent(const NativeWebKeyboardEvent& key_event);
-  virtual void ForwardTouchEvent(const WebKit::WebTouchEvent& touch_event);
-
-  // Update the text direction of the focused input element and notify it to a
-  // renderer process.
-  // These functions have two usage scenarios: changing the text direction
-  // from a menu (as Safari does), and; changing the text direction when a user
-  // presses a set of keys (as IE and Firefox do).
-  // 1. Change the text direction from a menu.
-  // In this scenario, we receive a menu event only once and we should update
-  // the text direction immediately when a user chooses a menu item. So, we
-  // should call both functions at once as listed in the following snippet.
-  //   void RenderViewHost::SetTextDirection(WebTextDirection direction) {
-  //     UpdateTextDirection(direction);
-  //     NotifyTextDirection();
-  //   }
-  // 2. Change the text direction when pressing a set of keys.
-  // Because of auto-repeat, we may receive the same key-press event many
-  // times while we presses the keys and it is nonsense to send the same IPC
-  // message every time when we receive a key-press event.
-  // To suppress the number of IPC messages, we just update the text direction
-  // when receiving a key-press event and send an IPC message when we release
-  // the keys as listed in the following snippet.
-  //   if (key_event.type == WebKeyboardEvent::KEY_DOWN) {
-  //     if (key_event.windows_key_code == 'A' &&
-  //         key_event.modifiers == WebKeyboardEvent::CTRL_KEY) {
-  //       UpdateTextDirection(dir);
-  //     } else {
-  //       CancelUpdateTextDirection();
-  //     }
-  //   } else if (key_event.type == WebKeyboardEvent::KEY_UP) {
-  //     NotifyTextDirection();
-  //   }
-  // Once we cancel updating the text direction, we have to ignore all
-  // succeeding UpdateTextDirection() requests until calling
-  // NotifyTextDirection(). (We may receive keydown events even after we
-  // canceled updating the text direction because of auto-repeat.)
-  // Note: we cannot undo this change for compatibility with Firefox and IE.
-  void UpdateTextDirection(WebKit::WebTextDirection direction);
-  void CancelUpdateTextDirection();
-  void NotifyTextDirection();
 
   // Notifies the renderer whether or not the input method attached to this
   // process is activated.
   // When the input method is activated, a renderer process sends IPC messages
   // to notify the status of its composition node. (This message is mainly used
   // for notifying the position of the input cursor so that the browser can
   // display input method windows under the cursor.)
   void SetInputMethodActive(bool activate);
 
   // Update the composition node of the renderer (or WebKit).
@@ skipping 31 matching lines @@
   // SetComposition() call.
   void ImeConfirmComposition();
 
   // Cancels an ongoing composition.
   void ImeCancelComposition();
 
   // This is for derived classes to give us access to the resizer rect.
   // And to also expose it to the RenderWidgetHostView.
   virtual gfx::Rect GetRootWindowResizerRect() const;
 
-  // Makes an IPC call to tell webkit to replace the currently selected word
-  // or a word around the cursor.
-  void Replace(const string16& word);
-
-  // Enable renderer accessibility. This should only be called when a
-  // screenreader is detected.
-  void EnableRendererAccessibility();
-
-  void set_ignore_input_events(bool ignore_input_events) {
-    ignore_input_events_ = ignore_input_events;
-  }
   bool ignore_input_events() const {
     return ignore_input_events_;
   }
 
   // Activate deferred plugin handles.
   void ActivateDeferredPluginHandles();
 
-  const gfx::Point& last_scroll_offset() const { return last_scroll_offset_; }
-
   bool has_touch_handler() const { return has_touch_handler_; }
 
   // Notification that the user has made some kind of input that could
   // perform an action. See OnUserGesture for more details.
   void StartUserGesture();
 
-  // Stops loading the page.
-  void Stop();
-
   // Set the RenderView background.
   void SetBackground(const SkBitmap& background);
 
   // Notifies the renderer that the next key event is bound to one or more
   // pre-defined edit commands
   void SetEditCommandsForNextKeyEvent(
       const std::vector<EditCommand>& commands);
 
   // Relay a request from assistive technology to perform the default action
   // on a given node.
@@ skipping 24 matching lines @@
                           const std::string& value);
 
   // Tells the renderer to scroll the currently focused node into rect only if
   // the currently focused node is a Text node (textfield, text area or content
   // editable divs).
   void ScrollFocusedEditableNodeIntoRect(const gfx::Rect& rect);
 
   // Requests the renderer to select the region between two points.
   void SelectRange(const gfx::Point& start, const gfx::Point& end);
 
-  // Edit operations.
-  void Undo();
-  void Redo();
-  void Cut();
-  void Copy();
-  void CopyToFindPboard();
-  void Paste();
-  void PasteAndMatchStyle();
-  void Delete();
-  void SelectAll();
-
   // Called when the reponse to a pending mouse lock request has arrived.
   // Returns true if |allowed| is true and the mouse has been successfully
   // locked.
   bool GotResponseToLockMouseRequest(bool allowed);
 
   // Called by the view in response to AcceleratedSurfaceBuffersSwapped.
   static void AcknowledgeSwapBuffers(int32 route_id, int gpu_host_id);
   static void AcknowledgePostSubBuffer(int32 route_id, int gpu_host_id);
 
  protected:
@@ skipping 59 matching lines @@
   bool IsMouseLocked() const;
 
   // RenderViewHost overrides this method to report when in fullscreen mode.
   virtual bool IsFullscreen() const;
 
   // Indicates if the render widget host should track the render widget's size
   // as opposed to visa versa.
   void SetShouldAutoResize(bool enable);
 
  protected:
+  // The View associated with the RenderViewHost. The lifetime of this object
+  // is associated with the lifetime of the Render process. If the Renderer
+  // crashes, its View is destroyed and this pointer becomes NULL, even though
+  // render_view_host_ lives on to load another URL (creating a new View while
+  // doing so).
+  content::RenderWidgetHostViewPort* view_;
+
   // 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_;
 
   // This value indicates how long to wait before we consider a renderer hung.
   int hung_renderer_delay_ms_;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostTest, Resize);
@@ skipping 97 matching lines @@
   // Called by OnMsgInputEventAck() to process a wheel event ack message.
   // This could result in a task being posted to allow additional wheel
   // input messages to be coalesced.
   void ProcessWheelAck(bool processed);
 
   // Called on OnMsgInputEventAck() to process a touch event ack message.
   // This can result in a gesture event being generated and sent back to the
   // renderer.
   void ProcessTouchAck(bool processed);
 
+  // Created during construction but initialized during Init*(). Therefore, it
+  // is guaranteed never to be NULL, but its channel may be NULL if the
+  // renderer crashed, so you must always check that.
+  content::RenderProcessHost* process_;
+
+  // The ID of the corresponding object in the Renderer Instance.
+  int routing_id_;
+
   // True if renderer accessibility is enabled. This should only be set when a
   // screenreader is detected as it can potentially slow down Chrome.
   bool renderer_accessible_;
 
   // Stores random bits of data for others to associate with this object.
   base::PropertyBag property_bag_;
 
-  // The ID of the corresponding object in the Renderer Instance.
-  int routing_id_;
-
   // The ID of the surface corresponding to this render widget.
   int surface_id_;
 
   // Indicates whether a page is loading or not.
   bool is_loading_;
 
   // Indicates whether a page is hidden or not.
   bool is_hidden_;
 
   // True when a page is rendered directly via the GPU process.
@@ skipping 122 matching lines @@
   // then touch events are sent to the renderer. Otherwise, the touch events are
   // not sent to the renderer.
   bool has_touch_handler_;
 
   base::WeakPtrFactory<RenderWidgetHostImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostImpl);
 };
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_H_