Don't expect ack for ViewMsg_OnResize if backing size is empty

content/browser/renderer_host/render_widget_host_unittest.cc

 // Copyright (c) 2012 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/memory/scoped_ptr.h"
 #include "base/shared_memory.h"
 #include "base/timer.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/renderer_host/backing_store.h"
@@ skipping 474 matching lines @@
 }
 
 // TestView --------------------------------------------------------------------
 
 // This test view allows us to specify the size, and keep track of acked
 // touch-events.
 class TestView : public TestRenderWidgetHostView {
  public:
   explicit TestView(RenderWidgetHostImpl* rwh)
       : TestRenderWidgetHostView(rwh),
-        acked_event_count_(0) {
+        acked_event_count_(0),
+        use_fake_physical_backing_size_(false) {
   }
 
   // Sets the bounds returned by GetViewBounds.
   void set_bounds(const gfx::Rect& bounds) {
     bounds_ = bounds;
   }
 
   const WebTouchEvent& acked_event() const { return acked_event_; }
   int acked_event_count() const { return acked_event_count_; }
   void ClearAckedEvent() {
     acked_event_.type = WebKit::WebInputEvent::Undefined;
     acked_event_count_ = 0;
   }
 
   const WebMouseWheelEvent& unhandled_wheel_event() const {
     return unhandled_wheel_event_;
   }
 
+  void SetMockPhysicalBackingSize(const gfx::Size& mock_physical_backing_size) {
+    use_fake_physical_backing_size_ = true;
+    mock_physical_backing_size_ = mock_physical_backing_size;
+  }
+  void ClearMockPhysicalBackingSize() {
+    use_fake_physical_backing_size_ = false;
+  }
+
   // RenderWidgetHostView override.
   virtual gfx::Rect GetViewBounds() const OVERRIDE {
     return bounds_;
   }
   virtual void ProcessAckedTouchEvent(const WebTouchEvent& touch,
                                       InputEventAckState ack_result) OVERRIDE {
     acked_event_ = touch;
     ++acked_event_count_;
   }
   virtual void UnhandledWheelEvent(const WebMouseWheelEvent& event) OVERRIDE {
     unhandled_wheel_event_ = event;
   }
+  virtual gfx::Size GetPhysicalBackingSize() const OVERRIDE {
+    if (use_fake_physical_backing_size_)
+      return mock_physical_backing_size_;
+    return TestRenderWidgetHostView::GetPhysicalBackingSize();
+  }
 
  protected:
   WebMouseWheelEvent unhandled_wheel_event_;
   WebTouchEvent acked_event_;
   int acked_event_count_;
   gfx::Rect bounds_;
+  bool use_fake_physical_backing_size_;
+  gfx::Size mock_physical_backing_size_;
 
   DISALLOW_COPY_AND_ASSIGN(TestView);
 };
 
 // MockRenderWidgetHostDelegate --------------------------------------------
 
 class MockRenderWidgetHostDelegate : public RenderWidgetHostDelegate {
  public:
   MockRenderWidgetHostDelegate()
       : prehandle_keyboard_event_(false),
@@ skipping 322 matching lines @@
 
 TEST_F(RenderWidgetHostTest, Resize) {
   // The initial bounds is the empty rect, so setting it to the same thing
   // should do nothing.
   view_->set_bounds(gfx::Rect());
   host_->WasResized();
   EXPECT_FALSE(host_->resize_ack_pending_);
   EXPECT_EQ(gfx::Size(), host_->in_flight_size_);
   EXPECT_FALSE(process_->sink().GetUniqueMessageMatching(ViewMsg_Resize::ID));
 
-  // Setting the bounds to a "real" rect should send out the notification.
+  // Setting the bounds to a "real" rect should send out the notification,
+  // but should not expect ack for empty physical backing size.
   gfx::Rect original_size(0, 0, 100, 100);
   process_->sink().ClearMessages();
   view_->set_bounds(original_size);
+  view_->SetMockPhysicalBackingSize(gfx::Size());
+  host_->WasResized();
+  EXPECT_FALSE(host_->resize_ack_pending_);
+  EXPECT_EQ(original_size.size(), host_->in_flight_size_);
+  EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(ViewMsg_Resize::ID));
+
+  // Setting the bounds to a "real" rect should send out the notification.
+  process_->sink().ClearMessages();
+  view_->ClearMockPhysicalBackingSize();
   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 update that's not a resize ack. This should not clean the
   // resize ack pending flag.
   ViewHostMsg_UpdateRect_Params params;
   process_->InitUpdateRectParams(&params);
   host_->OnUpdateRect(params);
@@ skipping 2957 matching lines @@
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
                   InputMsg_HandleInputEvent::ID));
   process_->sink().ClearMessages();
 
   // Check that the correct unhandled wheel event was received.
   EXPECT_EQ(view_->unhandled_wheel_event().deltaY, -5);
 }
 
 }  // namespace content