This adds in the ability for Chrome to generate windows with snapshots of all...

chrome/browser/renderer_host/render_widget_host_unittest.cc

 // 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.
 
 #include "base/basictypes.h"
 #include "base/keyboard_codes.h"
 #include "base/scoped_ptr.h"
 #include "base/shared_memory.h"
 #include "base/timer.h"
 #include "build/build_config.h"
 #include "chrome/browser/renderer_host/backing_store.h"
+#include "chrome/browser/renderer_host/render_widget_host_painting_observer.h"
 #include "chrome/browser/renderer_host/test/test_render_view_host.h"
 #include "chrome/common/render_messages.h"
 #include "gfx/canvas.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeDelta;
 
 using WebKit::WebInputEvent;
 using WebKit::WebMouseWheelEvent;
 
+namespace gfx {
+class Size;
+}
+
 // RenderWidgetHostProcess -----------------------------------------------------
 
 class RenderWidgetHostProcess : public MockRenderProcessHost {
  public:
   explicit RenderWidgetHostProcess(Profile* profile)
       : MockRenderProcessHost(profile),
         current_update_buf_(NULL),
         update_msg_should_reply_(false),
         update_msg_reply_flags_(0) {
     // DANGER! This is a hack. The RenderWidgetHost checks the channel to see
@@ skipping 152 matching lines @@
   bool prehandle_keyboard_event_;
   bool prehandle_keyboard_event_called_;
   WebInputEvent::Type prehandle_keyboard_event_type_;
 
   bool unhandled_keyboard_event_called_;
   WebInputEvent::Type unhandled_keyboard_event_type_;
 
   bool unresponsive_timer_fired_;
 };
 
+// MockPaintingObserver --------------------------------------------------------
+
+class MockPaintingObserver : public RenderWidgetHostPaintingObserver {
+ public:
+  void WidgetWillDestroyBackingStore(RenderWidgetHost* widget,
+                                     BackingStore* backing_store) {}
+  void WidgetDidUpdateBackingStore(RenderWidgetHost* widget) {}
+  void WidgetDidReceivePaintAtSizeAck(RenderWidgetHost* host,
+                                      const TransportDIB::Handle& dib_handle,
+                                      const gfx::Size& size) {
+    host_ = reinterpret_cast<MockRenderWidgetHost*>(host);
+    dib_handle_ = dib_handle;
+    size_ = size;
+  }
+
+  MockRenderWidgetHost* host() const { return host_; }
+  TransportDIB::Handle dib_handle() const { return dib_handle_; }
+  gfx::Size size() const { return size_; }
+
+ private:
+  MockRenderWidgetHost* host_;
+  TransportDIB::Handle dib_handle_;
+  gfx::Size size_;
+};
+
+
 // RenderWidgetHostTest --------------------------------------------------------
 
 class RenderWidgetHostTest : public testing::Test {
  public:
   RenderWidgetHostTest() : process_(NULL) {
   }
   ~RenderWidgetHostTest() {
   }
 
  protected:
@@ skipping 293 matching lines @@
 
   // It should have sent out a restored message with a request to paint.
   const IPC::Message* restored = process_->sink().GetUniqueMessageMatching(
       ViewMsg_WasRestored::ID);
   ASSERT_TRUE(restored);
   Tuple1<bool> needs_repaint;
   ViewMsg_WasRestored::Read(restored, &needs_repaint);
   EXPECT_TRUE(needs_repaint.a);
 }
 
+TEST_F(RenderWidgetHostTest, PaintAtSize) {
+  host_->PaintAtSize(TransportDIB::GetFakeHandleForTest(), gfx::Size(20, 30));
+  EXPECT_TRUE(
+      process_->sink().GetUniqueMessageMatching(ViewMsg_PaintAtSize::ID));
+
+  MockPaintingObserver observer;
+  host_->set_painting_observer(&observer);
+
+  // Need to generate a fake handle value on all platforms.
+  TransportDIB::Handle handle = TransportDIB::GetFakeHandleForTest();
+  host_->OnMsgPaintAtSizeAck(handle, gfx::Size(20, 30));
+  EXPECT_TRUE(host_ == observer.host());
+  EXPECT_TRUE(handle == observer.dib_handle());
+  EXPECT_EQ(20, observer.size().width());
+  EXPECT_EQ(30, observer.size().height());
+  host_->set_painting_observer(NULL);
+}
+
 TEST_F(RenderWidgetHostTest, HandleKeyEventsWeSent) {
   // Simulate a keyboard event.
   SimulateKeyboardEvent(WebInputEvent::RawKeyDown);
 
   // Make sure we sent the input event to the renderer.
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
                   ViewMsg_HandleInputEvent::ID));
   process_->sink().ClearMessages();
 
   // Send the simulated response from the renderer back.
@@ skipping 125 matching lines @@
   // Start it again to ensure it still works.
   EXPECT_FALSE(host_->unresponsive_timer_fired());
   host_->StartHangMonitorTimeout(TimeDelta::FromMilliseconds(10));
 
   // Wait long enough for first timeout and see if it fired.
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
                                           new MessageLoop::QuitTask(), 10);
   MessageLoop::current()->Run();
   EXPECT_TRUE(host_->unresponsive_timer_fired());
 }
-