Revert 34951 - Combine ViewHostMsg_{Paint,Scroll}Rect into one IPC....

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/gfx/canvas.h"
 #include "base/basictypes.h"
 #include "base/keyboard_codes.h"
 #include "base/scoped_ptr.h"
 #include "base/shared_memory.h"
 #include "build/build_config.h"
 #include "chrome/browser/renderer_host/backing_store.h"
 #include "chrome/browser/renderer_host/test/test_render_view_host.h"
 #include "chrome/common/render_messages.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using WebKit::WebInputEvent;
 
 // 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) {
+        current_paint_buf_(NULL),
+        paint_msg_should_reply_(false),
+        paint_msg_reply_flags_(0) {
     // DANGER! This is a hack. The RenderWidgetHost checks the channel to see
     // if the process is still alive, but it doesn't actually dereference it.
     // An IPC::SyncChannel is nontrivial, so we just fake it here. If you end up
     // crashing by dereferencing 1, then you'll have to make a real channel.
     channel_.reset(reinterpret_cast<IPC::SyncChannel*>(0x1));
   }
   ~RenderWidgetHostProcess() {
     // We don't want to actually delete the channel, since it's not a real
     // pointer.
     channel_.release();
-    delete current_update_buf_;
+    if (current_paint_buf_)
+      delete current_paint_buf_;
   }
 
-  void set_update_msg_should_reply(bool reply) {
-    update_msg_should_reply_ = reply;
+  void set_paint_msg_should_reply(bool reply) {
+    paint_msg_should_reply_ = reply;
   }
-  void set_update_msg_reply_flags(int flags) {
-    update_msg_reply_flags_ = flags;
+  void set_paint_msg_reply_flags(int flags) {
+    paint_msg_reply_flags_ = flags;
   }
 
   // Fills the given paint parameters with resonable default values.
-  void InitUpdateRectParams(ViewHostMsg_UpdateRect_Params* params);
+  void InitPaintRectParams(ViewHostMsg_PaintRect_Params* params);
 
  protected:
-  virtual bool WaitForUpdateMsg(int render_widget_id,
-                                const base::TimeDelta& max_delay,
-                                IPC::Message* msg);
+  virtual bool WaitForPaintMsg(int render_widget_id,
+                               const base::TimeDelta& max_delay,
+                               IPC::Message* msg);
 
-  TransportDIB* current_update_buf_;
+  TransportDIB* current_paint_buf_;
 
   // Set to true when WaitForPaintMsg should return a successful paint messaage
   // reply. False implies timeout.
-  bool update_msg_should_reply_;
+  bool paint_msg_should_reply_;
 
   // Indicates the flags that should be sent with a the repaint request. This
   // only has an effect when paint_msg_should_reply_ is true.
-  int update_msg_reply_flags_;
+  int paint_msg_reply_flags_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostProcess);
 };
 
-void RenderWidgetHostProcess::InitUpdateRectParams(
-    ViewHostMsg_UpdateRect_Params* params) {
+void RenderWidgetHostProcess::InitPaintRectParams(
+    ViewHostMsg_PaintRect_Params* params) {
   // Create the shared backing store.
   const int w = 100, h = 100;
   const size_t pixel_size = w * h * 4;
 
-  if (!current_update_buf_)
-    current_update_buf_ = TransportDIB::Create(pixel_size, 0);
-  params->bitmap = current_update_buf_->id();
+  if (!current_paint_buf_)
+    current_paint_buf_ = TransportDIB::Create(pixel_size, 0);
+  params->bitmap = current_paint_buf_->id();
   params->bitmap_rect = gfx::Rect(0, 0, w, h);
-  params->dx = 0;
-  params->dy = 0;
-  params->copy_rects.push_back(params->bitmap_rect);
+  params->update_rects.push_back(params->bitmap_rect);
   params->view_size = gfx::Size(w, h);
-  params->flags = update_msg_reply_flags_;
+  params->flags = paint_msg_reply_flags_;
 }
 
-bool RenderWidgetHostProcess::WaitForUpdateMsg(int render_widget_id,
-                                               const base::TimeDelta& max_delay,
-                                               IPC::Message* msg) {
-  if (!update_msg_should_reply_)
+bool RenderWidgetHostProcess::WaitForPaintMsg(int render_widget_id,
+                                              const base::TimeDelta& max_delay,
+                                              IPC::Message* msg) {
+  if (!paint_msg_should_reply_)
     return false;
 
   // Construct a fake paint reply.
-  ViewHostMsg_UpdateRect_Params params;
-  InitUpdateRectParams(&params);
+  ViewHostMsg_PaintRect_Params params;
+  InitPaintRectParams(&params);
 
-  ViewHostMsg_UpdateRect message(render_widget_id, params);
+  ViewHostMsg_PaintRect message(render_widget_id, params);
   *msg = message;
   return true;
 }
 
 // TestView --------------------------------------------------------------------
 
 // This test view allows us to specify the size.
 class TestView : public TestRenderWidgetHostView {
  public:
   explicit TestView(RenderWidgetHost* rwh) : TestRenderWidgetHostView(rwh) {}
@@ skipping 139 matching lines @@
   gfx::Rect original_size(0, 0, 100, 100);
   process_->sink().ClearMessages();
   view_->set_bounds(original_size);
   host_->WasResized();
   EXPECT_TRUE(host_->resize_ack_pending_);
   EXPECT_EQ(original_size.size(), host_->in_flight_size_);
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(ViewMsg_Resize::ID));
 
   // Send out a paint that's not a resize ack. This should not clean the
   // resize ack pending flag.
-  ViewHostMsg_UpdateRect_Params params;
-  process_->InitUpdateRectParams(&params);
-  host_->OnMsgUpdateRect(params);
+  ViewHostMsg_PaintRect_Params params;
+  process_->InitPaintRectParams(&params);
+  host_->OnMsgPaintRect(params);
   EXPECT_TRUE(host_->resize_ack_pending_);
   EXPECT_EQ(original_size.size(), host_->in_flight_size_);
 
   // Sending out a new notification should NOT send out a new IPC message since
   // a resize ACK is pending.
   gfx::Rect second_size(0, 0, 90, 90);
   process_->sink().ClearMessages();
   view_->set_bounds(second_size);
   host_->WasResized();
   EXPECT_TRUE(host_->resize_ack_pending_);
   EXPECT_EQ(original_size.size(), host_->in_flight_size_);
   EXPECT_FALSE(process_->sink().GetUniqueMessageMatching(ViewMsg_Resize::ID));
 
   // Send a paint that's a resize ack, but for the original_size we sent. Since
   // this isn't the second_size, the message handler should immediately send
   // a new resize message for the new size to the renderer.
   process_->sink().ClearMessages();
-  params.flags = ViewHostMsg_UpdateRect_Flags::IS_RESIZE_ACK;
+  params.flags = ViewHostMsg_PaintRect_Flags::IS_RESIZE_ACK;
   params.view_size = original_size.size();
-  host_->OnMsgUpdateRect(params);
+  host_->OnMsgPaintRect(params);
   EXPECT_TRUE(host_->resize_ack_pending_);
   EXPECT_EQ(second_size.size(), host_->in_flight_size_);
   ASSERT_TRUE(process_->sink().GetUniqueMessageMatching(ViewMsg_Resize::ID));
 
   // Send the resize ack for the latest size.
   process_->sink().ClearMessages();
   params.view_size = second_size.size();
-  host_->OnMsgUpdateRect(params);
+  host_->OnMsgPaintRect(params);
   EXPECT_FALSE(host_->resize_ack_pending_);
   EXPECT_EQ(gfx::Size(), host_->in_flight_size_);
   ASSERT_FALSE(process_->sink().GetFirstMessageMatching(ViewMsg_Resize::ID));
 
   // Now clearing the bounds should send out a notification but we shouldn't
   // expect a resize ack (since the renderer won't ack empty sizes). The message
   // should contain the new size (0x0) and not the previous one that we skipped
   process_->sink().ClearMessages();
   view_->set_bounds(gfx::Rect());
   host_->WasResized();
@@ skipping 96 matching lines @@
   // TODO(aa): It would be nice to factor out the painting logic so that we
   // could test that, but it appears that would mean painting everything twice
   // since windows HDC structures are opaque.
 }
 
 // Tests getting the backing store with the renderer not setting repaint ack
 // flags.
 TEST_F(RenderWidgetHostTest, GetBackingStore_NoRepaintAck) {
   // We don't currently have a backing store, and if the renderer doesn't send
   // one in time, we should get nothing.
-  process_->set_update_msg_should_reply(false);
+  process_->set_paint_msg_should_reply(false);
   BackingStore* backing = host_->GetBackingStore(true);
   EXPECT_FALSE(backing);
   // The widget host should have sent a request for a repaint, and there should
   // be no paint ACK.
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(ViewMsg_Repaint::ID));
   EXPECT_FALSE(process_->sink().GetUniqueMessageMatching(
-      ViewMsg_UpdateRect_ACK::ID));
+      ViewMsg_PaintRect_ACK::ID));
 
   // Allowing the renderer to reply in time should give is a backing store.
   process_->sink().ClearMessages();
-  process_->set_update_msg_should_reply(true);
-  process_->set_update_msg_reply_flags(0);
+  process_->set_paint_msg_should_reply(true);
+  process_->set_paint_msg_reply_flags(0);
   backing = host_->GetBackingStore(true);
   EXPECT_TRUE(backing);
   // The widget host should NOT have sent a request for a repaint, since there
   // was an ACK already pending.
   EXPECT_FALSE(process_->sink().GetUniqueMessageMatching(ViewMsg_Repaint::ID));
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
-      ViewMsg_UpdateRect_ACK::ID));
+      ViewMsg_PaintRect_ACK::ID));
 }
 
 // Tests getting the backing store with the renderer sending a repaint ack.
 TEST_F(RenderWidgetHostTest, GetBackingStore_RepaintAck) {
   // Doing a request request with the paint message allowed should work and
   // the repaint ack should work.
-  process_->set_update_msg_should_reply(true);
-  process_->set_update_msg_reply_flags(
-      ViewHostMsg_UpdateRect_Flags::IS_REPAINT_ACK);
+  process_->set_paint_msg_should_reply(true);
+  process_->set_paint_msg_reply_flags(
+      ViewHostMsg_PaintRect_Flags::IS_REPAINT_ACK);
   BackingStore* backing = host_->GetBackingStore(true);
   EXPECT_TRUE(backing);
   // We still should not have sent out a repaint request since the last flags
   // didn't have the repaint ack set, and the pending flag will still be set.
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(ViewMsg_Repaint::ID));
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
-      ViewMsg_UpdateRect_ACK::ID));
+      ViewMsg_PaintRect_ACK::ID));
 
   // Asking again for the backing store should just re-use the existing one
   // and not send any messagse.
   process_->sink().ClearMessages();
   backing = host_->GetBackingStore(true);
   EXPECT_TRUE(backing);
   EXPECT_FALSE(process_->sink().GetUniqueMessageMatching(ViewMsg_Repaint::ID));
   EXPECT_FALSE(process_->sink().GetUniqueMessageMatching(
-      ViewMsg_UpdateRect_ACK::ID));
+      ViewMsg_PaintRect_ACK::ID));
 }
 
 // Test that we don't paint when we're hidden, but we still send the ACK. Most
 // of the rest of the painting is tested in the GetBackingStore* ones.
 TEST_F(RenderWidgetHostTest, HiddenPaint) {
   // Hide the widget, it should have sent out a message to the renderer.
   EXPECT_FALSE(host_->is_hidden_);
   host_->WasHidden();
   EXPECT_TRUE(host_->is_hidden_);
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(ViewMsg_WasHidden::ID));
 
   // Send it a paint as from the renderer.
   process_->sink().ClearMessages();
-  ViewHostMsg_UpdateRect_Params params;
-  process_->InitUpdateRectParams(&params);
-  host_->OnMsgUpdateRect(params);
+  ViewHostMsg_PaintRect_Params params;
+  process_->InitPaintRectParams(&params);
+  host_->OnMsgPaintRect(params);
 
   // It should have sent out the ACK.
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
-      ViewMsg_UpdateRect_ACK::ID));
+      ViewMsg_PaintRect_ACK::ID));
 
   // Now unhide.
   process_->sink().ClearMessages();
   host_->WasRestored();
   EXPECT_FALSE(host_->is_hidden_);
 
   // 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);
@@ skipping 71 matching lines @@
   EXPECT_EQ(ViewMsg_HandleInputEvent::ID,
             process_->sink().GetMessageAt(0)->type());
   process_->sink().ClearMessages();
 
   // Send the simulated response from the renderer back.
   SendInputEventACK(WebInputEvent::KeyUp, false);
 
   EXPECT_TRUE(host_->unhandled_keyboard_event_called());
   EXPECT_EQ(WebInputEvent::KeyUp, host_->unhandled_keyboard_event_type());
 }