Adds kind-of-live thumbnail generation for a potential tab switcher. This...

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_
 
 #include <queue>
 #include <vector>
 
 #include "base/gfx/native_widget_types.h"
 #include "base/gfx/size.h"
 #include "base/scoped_ptr.h"
 #include "base/timer.h"
 #include "chrome/common/ipc_channel.h"
 #include "chrome/common/native_web_keyboard_event.h"
+#include "chrome/common/property_bag.h"
 #include "testing/gtest/include/gtest/gtest_prod.h"
 #include "webkit/glue/webtextdirection.h"
 
 namespace gfx {
 class Rect;
 }
 
 namespace WebKit {
 class WebInputEvent;
 class WebMouseEvent;
 class WebMouseWheelEvent;
 }
 
 class BackingStore;
 class PaintObserver;
 class RenderProcessHost;
 class RenderWidgetHostView;
+class RenderWidgetHostPaintingObserver;
 class TransportDIB;
 class WebCursor;
 struct ViewHostMsg_PaintRect_Params;
 struct ViewHostMsg_ScrollRect_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 89 matching lines @@
   RenderWidgetHostView* view() const { return view_; }
 
   RenderProcessHost* process() const { return process_; }
   int routing_id() const { return routing_id_; }
 
   // 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() { return false; }
@@ skipping 17 matching lines @@
   void LostCapture();
 
   // Notifies the RenderWidgetHost that the View was destroyed.
   void ViewDestroyed();
 
   // Indicates if the page has finished loading.
   void SetIsLoading(bool is_loading);
 
   // 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.  This method returns NULL if the backing store could
-  // not be created.
-  BackingStore* GetBackingStore();
+  // 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);
 
   // Checks to see if we can give up focus to this widget through a JS call.
   virtual bool CanBlur() const { return true; }
 
   // 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
@@ skipping 153 matching lines @@
   // 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).
   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_;
 
   // Set if we are waiting for a repaint ack for the view.
@@ skipping 59 matching lines @@
 
   // Set when we cancel updating the text direction.
   // This flag also ignores succeeding update requests until we call
   // NotifyTextDirection().
   bool text_direction_canceled_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHost);
 };
 
 #endif  // CHROME_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_H_