Refactor RenderWidgetHost::set_paint_observer()

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 "app/keyboard_codes.h"
 #include "base/basictypes.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/notification_details.h"
+#include "chrome/common/notification_source.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/render_messages_params.h"
 #include "chrome/test/testing_profile.h"
 #include "gfx/canvas_skia.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeDelta;
 
 using WebKit::WebInputEvent;
 using WebKit::WebMouseWheelEvent;
@@ skipping 169 matching lines @@
   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 {
+class MockPaintingObserver : public NotificationObserver {
  public:
-  void WidgetWillDestroyBackingStore(RenderWidgetHost* widget,
-                                     BackingStore* backing_store) {}
-  void WidgetDidUpdateBackingStore(RenderWidgetHost* widget) {}
   void WidgetDidReceivePaintAtSizeAck(RenderWidgetHost* host,
                                       int tag,
                                       const gfx::Size& size) {
     host_ = reinterpret_cast<MockRenderWidgetHost*>(host);
     tag_ = tag;
     size_ = size;
   }
 
+  void Observe(NotificationType type,
+               const NotificationSource& source,
+               const NotificationDetails& details) {
+    if (type ==
+        NotificationType::RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK) {
+      RenderWidgetHost::PaintAtSizeAckDetails* size_ack_details =
+          Details<RenderWidgetHost::PaintAtSizeAckDetails>(details).ptr();
+      WidgetDidReceivePaintAtSizeAck(
+          Source<RenderWidgetHost>(source).ptr(),
+          size_ack_details->tag,
+          size_ack_details->size);
+    }
+  }
+
   MockRenderWidgetHost* host() const { return host_; }
   int tag() const { return tag_; }
   gfx::Size size() const { return size_; }
 
  private:
   MockRenderWidgetHost* host_;
   int tag_;
   gfx::Size size_;
 };
 
@@ skipping 316 matching lines @@
   EXPECT_TRUE(needs_repaint.a);
 }
 
 TEST_F(RenderWidgetHostTest, PaintAtSize) {
   const int kPaintAtSizeTag = 42;
   host_->PaintAtSize(TransportDIB::GetFakeHandleForTest(), kPaintAtSizeTag,
                      gfx::Size(40, 60), gfx::Size(20, 30));
   EXPECT_TRUE(
       process_->sink().GetUniqueMessageMatching(ViewMsg_PaintAtSize::ID));
 
+  NotificationRegistrar registrar;
   MockPaintingObserver observer;
-  host_->set_painting_observer(&observer);
+  registrar.Add(
+      &observer,
+      NotificationType::RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK,
+      Source<RenderWidgetHost>(host_.get()));
 
   host_->OnMsgPaintAtSizeAck(kPaintAtSizeTag, gfx::Size(20, 30));
   EXPECT_EQ(host_.get(), observer.host());
   EXPECT_EQ(kPaintAtSizeTag, observer.tag());
   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();
@@ skipping 133 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());
 }