Refactor RenderWidgetHost::set_paint_observer()

chrome/browser/renderer_host/render_widget_host.h

 // Copyright (c) 2009 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 CHROME_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_H_
 #define CHROME_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_H_
 #pragma once
 
 #include <deque>
 #include <string>
@@ skipping 24 matching lines @@
 class WebInputEvent;
 class WebMouseEvent;
 struct WebCompositionUnderline;
 struct WebScreenInfo;
 }
 
 class BackingStore;
 class PaintObserver;
 class RenderProcessHost;
 class RenderWidgetHostView;
-class RenderWidgetHostPaintingObserver;
 class TransportDIB;
 class WebCursor;
 struct ViewHostMsg_UpdateRect_Params;
 
 // 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.
 //
@@ skipping 61 matching lines @@
 // 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.
 //
 class RenderWidgetHost : public IPC::Channel::Listener,
                          public IPC::Channel::Sender {
  public:
-  // An interface that gets called before and after a paint.
-  class PaintObserver {
-   public:
-    virtual ~PaintObserver() {}
-    virtual void RenderWidgetHostWillPaint(RenderWidgetHost* rhw) = 0;
-    virtual void RenderWidgetHostDidPaint(RenderWidgetHost* rwh) = 0;
-  };
-
   // routing_id can be MSG_ROUTING_NONE, in which case the next available
   // routing id is taken from the RenderProcessHost.
   RenderWidgetHost(RenderProcessHost* process, int routing_id);
   virtual ~RenderWidgetHost();
 
   // Gets/Sets 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.
   void set_view(RenderWidgetHostView* view) { view_ = view; }
   RenderWidgetHostView* view() const { return view_; }
 
   RenderProcessHost* process() const { return process_; }
   int routing_id() const { return routing_id_; }
   bool renderer_accessible() { return renderer_accessible_; }
 
-  // Set the PaintObserver on this object. Takes ownership.
-  void set_paint_observer(PaintObserver* paint_observer) {
-    paint_observer_.reset(paint_observer);
-  }
-
   // 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 PropertyBag* property_bag() const { return &property_bag_; }
   PropertyBag* property_bag() { return &property_bag_; }
 
-  // The painting observer that will be called for paint events. This
-  // pointer's ownership will remain with the caller and must remain valid
-  // until this class is destroyed or the observer is replaced.
-  RenderWidgetHostPaintingObserver* painting_observer() const {
-    return painting_observer_;
-  }
-  void set_painting_observer(RenderWidgetHostPaintingObserver* observer) {
-    painting_observer_ = observer;
-  }
-
   // 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;
@@ skipping 30 matching lines @@
   void ViewDestroyed();
 
   // Indicates if the page has finished loading.
   void SetIsLoading(bool is_loading);
 
   // 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 the painting
-  // observer is notified.  Note that this bypasses most of the update
-  // logic that is normally invoked, and doesn't put the results into
-  // the backing store.
+  // 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.
   void PaintAtSize(TransportDIB::Handle dib_handle,
                    int tag,
                    const gfx::Size& page_size,
                    const gfx::Size& desired_size);
 
   // 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
@@ skipping 165 matching lines @@
   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();
 
+  // Used as the details object for a
+  // RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK notification.
+  struct PaintAtSizeAckDetails {
+    int tag;

[sky, 2011/01/04 17:06:54]

Document what tag is.

[DaveMoore, 2011/01/07 19:04:05]

Done.

+    gfx::Size size;
+  };
+
  protected:
   // Internal implementation of the public Forward*Event() methods.
   void ForwardInputEvent(const WebKit::WebInputEvent& input_event,
                          int event_size, bool is_keyboard_shortcut);
 
   // Called when we receive a notification indicating that the renderer
   // process has gone. This will reset our state so that our state will be
   // consistent if a new renderer is created.
   void RendererExited(base::TerminationStatus status, int exit_code);
 
@@ skipping 126 matching lines @@
   RenderWidgetHostView* view_;
 
   // 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.
   RenderProcessHost* process_;
 
   // Stores random bits of data for others to associate with this object.
   PropertyBag property_bag_;
 
-  // Observer that will be called for paint events. This may be NULL. The
-  // pointer is not owned by this class.
-  RenderWidgetHostPaintingObserver* painting_observer_;
-
   // The ID of the corresponding object in the Renderer Instance.
   int routing_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 59 matching lines @@
   // This is true if the renderer is currently unresponsive.
   bool is_unresponsive_;
 
   // The following value indicates a time in the future when we would consider
   // the renderer hung if it does not generate an appropriate response message.
   base::Time time_when_considered_hung_;
 
   // This timer runs to check if time_when_considered_hung_ has past.
   base::OneShotTimer<RenderWidgetHost> hung_renderer_timer_;
 
-  // Optional observer that listens for notifications of painting.
-  scoped_ptr<PaintObserver> paint_observer_;
-
   // Flag to detect recursive calls to GetBackingStore().
   bool in_get_backing_store_;
 
   // Set when we call DidPaintRect/DidScrollRect on the view.
   bool view_being_painted_;
 
   // Used for UMA histogram logging to measure the time for a repaint view
   // operation to finish.
   base::TimeTicks repaint_start_time_;
 
@@ skipping 31 matching lines @@
   // switching back to the original tab, because the content may already be
   // changed.
   bool suppress_next_char_events_;
 
   std::vector<gfx::PluginWindowHandle> deferred_plugin_handles_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHost);
 };
 
 #endif  // CHROME_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_H_