Fix race between DPI and window size

Because the display scale factor and the window size are sent in two different
IPCs, and because the window size (ViewMsg_Resize) may be delayed (to avoid
spamming the renderer with resize messages while dragging), the renderer can
think it's using a different resolution than it is.

This merges the ViewMsg_ScreenInfoChanged and ViewMsg_Resize messages,
so that the renderer cannot not have a consistent view of the window size and
DPI.

BUG=239624

Review URL: https://chromiumcodereview.appspot.com/16048003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@202814 0039d316-1c4b-4281-b951-d872f2087c98

13 files changed, 109 insertions, 108 deletions

diff --git a/content/browser/renderer_host/render_widget_host_impl.cc b/content/browser/renderer_host/render_widget_host_impl.cc
index d0637ac..5cb74b8 100644
--- a/content/browser/renderer_host/render_widget_host_impl.cc
+++ b/content/browser/renderer_host/render_widget_host_impl.cc
@@ -147,6 +147,7 @@ RenderWidgetHostImpl::RenderWidgetHostImpl(RenderWidgetHostDelegate* delegate,
       is_accelerated_compositing_active_(false),
       repaint_ack_pending_(false),
       resize_ack_pending_(false),
+      screen_info_out_of_date_(false),
       overdraw_bottom_height_(0.f),
       should_auto_resize_(false),
       waiting_for_screen_rects_ack_(false),
@@ -526,6 +527,7 @@ void RenderWidgetHostImpl::WasResized() {
 
   bool size_changed = new_size != current_size_;
   bool side_payload_changed =
+      screen_info_out_of_date_ ||
       old_physical_backing_size != physical_backing_size_ ||
       was_fullscreen != is_fullscreen_ ||
       old_overdraw_bottom_height != overdraw_bottom_height_;
@@ -537,14 +539,24 @@ void RenderWidgetHostImpl::WasResized() {
       !side_payload_changed)
     return;
 
+  if (!screen_info_) {
+    screen_info_.reset(new WebKit::WebScreenInfo);
+    GetWebScreenInfo(screen_info_.get());
+  }
+
   // We don't expect to receive an ACK when the requested size or the physical
   // backing size is empty, or when the main viewport size didn't change.
   if (!new_size.IsEmpty() && !physical_backing_size_.IsEmpty() && size_changed)
     resize_ack_pending_ = true;
 
-  if (!Send(new ViewMsg_Resize(routing_id_, new_size, physical_backing_size_,
-                               overdraw_bottom_height_,
-                               GetRootWindowResizerRect(), is_fullscreen_))) {
+  ViewMsg_Resize_Params params;
+  params.screen_info = *screen_info_;
+  params.new_size = new_size;
+  params.physical_backing_size = physical_backing_size_;
+  params.overdraw_bottom_height = overdraw_bottom_height_;
+  params.resizer_rect = GetRootWindowResizerRect();
+  params.is_fullscreen = is_fullscreen_;
+  if (!Send(new ViewMsg_Resize(routing_id_, params))) {
     resize_ack_pending_ = false;
   } else {
     in_flight_size_ = new_size;
@@ -1334,9 +1346,12 @@ const NativeWebKeyboardEvent*
 }
 
 void RenderWidgetHostImpl::NotifyScreenInfoChanged() {
-  WebKit::WebScreenInfo screen_info;
-  GetWebScreenInfo(&screen_info);
-  Send(new ViewMsg_ScreenInfoChanged(GetRoutingID(), screen_info));
+  // The resize message (which may not happen immediately) will carry with it
+  // the screen info as well as the new size (if the screen has changed scale
+  // factor).
+  screen_info_.reset();
+  screen_info_out_of_date_ = true;
+  WasResized();
 }
 
 void RenderWidgetHostImpl::GetSnapshotFromRenderer(
diff --git a/content/browser/renderer_host/render_widget_host_impl.h b/content/browser/renderer_host/render_widget_host_impl.h
index 534933b..0d67af1 100644
--- a/content/browser/renderer_host/render_widget_host_impl.h
+++ b/content/browser/renderer_host/render_widget_host_impl.h
@@ -738,6 +738,14 @@ class CONTENT_EXPORT RenderWidgetHostImpl : virtual public RenderWidgetHost,
   // True when waiting for RESIZE_ACK.
   bool resize_ack_pending_;
 
+  // Cached copy of the screen info so that it doesn't need to be updated every
+  // time the window is resized.
+  scoped_ptr<WebKit::WebScreenInfo> screen_info_;
+
+  // Set if screen_info_ may have changed and should be recomputed and force a
+  // resize message.
+  bool screen_info_out_of_date_;
+
   // The current size of the RenderWidget.
   gfx::Size current_size_;
 
diff --git a/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc b/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc
index 9d2a15b..8fd6f08 100644
--- a/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc
+++ b/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc
@@ -383,8 +383,9 @@ TEST_F(RenderWidgetHostViewAuraTest, PhysicalBackingSizeWithScale) {
     EXPECT_EQ(ViewMsg_Resize::ID, msg->type());
     ViewMsg_Resize::Param params;
     ViewMsg_Resize::Read(msg, &params);
-    EXPECT_EQ("100x100", params.a.ToString());  // dip size
-    EXPECT_EQ("100x100", params.b.ToString());  // backing size
+    EXPECT_EQ("100x100", params.a.new_size.ToString());  // dip size
+    EXPECT_EQ("100x100",
+        params.a.physical_backing_size.ToString());  // backing size
   }
 
   widget_host_->ResetSizeAndRepaintPendingFlags();
@@ -393,22 +394,16 @@ TEST_F(RenderWidgetHostViewAuraTest, PhysicalBackingSizeWithScale) {
   aura_test_helper_->test_screen()->SetDeviceScaleFactor(2.0f);
   EXPECT_EQ("200x200", view_->GetPhysicalBackingSize().ToString());
   // Extra ScreenInfoChanged message for |parent_view_|.
-  EXPECT_EQ(3u, sink_->message_count());
-  EXPECT_EQ(ViewMsg_ScreenInfoChanged::ID, sink_->GetMessageAt(0)->type());
-  {
-    const IPC::Message* msg = sink_->GetMessageAt(1);
-    EXPECT_EQ(ViewMsg_ScreenInfoChanged::ID, msg->type());
-    ViewMsg_ScreenInfoChanged::Param params;
-    ViewMsg_ScreenInfoChanged::Read(msg, &params);
-    EXPECT_EQ(2.0f, params.a.deviceScaleFactor);
-  }
+  EXPECT_EQ(1u, sink_->message_count());
   {
-    const IPC::Message* msg = sink_->GetMessageAt(2);
+    const IPC::Message* msg = sink_->GetMessageAt(0);
     EXPECT_EQ(ViewMsg_Resize::ID, msg->type());
     ViewMsg_Resize::Param params;
     ViewMsg_Resize::Read(msg, &params);
-    EXPECT_EQ("100x100", params.a.ToString());  // dip size
-    EXPECT_EQ("200x200", params.b.ToString());  // backing size
+    EXPECT_EQ(2.0f, params.a.screen_info.deviceScaleFactor);
+    EXPECT_EQ("100x100", params.a.new_size.ToString());  // dip size
+    EXPECT_EQ("200x200",
+        params.a.physical_backing_size.ToString());  // backing size
   }
 
   widget_host_->ResetSizeAndRepaintPendingFlags();
@@ -416,23 +411,17 @@ TEST_F(RenderWidgetHostViewAuraTest, PhysicalBackingSizeWithScale) {
 
   aura_test_helper_->test_screen()->SetDeviceScaleFactor(1.0f);
   // Extra ScreenInfoChanged message for |parent_view_|.
-  EXPECT_EQ(3u, sink_->message_count());
+  EXPECT_EQ(1u, sink_->message_count());
   EXPECT_EQ("100x100", view_->GetPhysicalBackingSize().ToString());
-  EXPECT_EQ(ViewMsg_ScreenInfoChanged::ID, sink_->GetMessageAt(0)->type());
-  {
-    const IPC::Message* msg = sink_->GetMessageAt(1);
-    EXPECT_EQ(ViewMsg_ScreenInfoChanged::ID, msg->type());
-    ViewMsg_ScreenInfoChanged::Param params;
-    ViewMsg_ScreenInfoChanged::Read(msg, &params);
-    EXPECT_EQ(1.0f, params.a.deviceScaleFactor);
-  }
   {
-    const IPC::Message* msg = sink_->GetMessageAt(2);
+    const IPC::Message* msg = sink_->GetMessageAt(0);
     EXPECT_EQ(ViewMsg_Resize::ID, msg->type());
     ViewMsg_Resize::Param params;
     ViewMsg_Resize::Read(msg, &params);
-    EXPECT_EQ("100x100", params.a.ToString());  // dip size
-    EXPECT_EQ("100x100", params.b.ToString());  // backing size
+    EXPECT_EQ(1.0f, params.a.screen_info.deviceScaleFactor);
+    EXPECT_EQ("100x100", params.a.new_size.ToString());  // dip size
+    EXPECT_EQ("100x100",
+        params.a.physical_backing_size.ToString());  // backing size
   }
 }
 
diff --git a/content/browser/renderer_host/render_widget_host_view_base.cc b/content/browser/renderer_host/render_widget_host_view_base.cc
index 89e436c..c084f2e 100644
--- a/content/browser/renderer_host/render_widget_host_view_base.cc
+++ b/content/browser/renderer_host/render_widget_host_view_base.cc
@@ -457,15 +457,10 @@ void RenderWidgetHostViewBase::UpdateScreenInfo(gfx::NativeView view) {
       current_device_scale_factor_ == display.device_scale_factor()) {
     return;
   }
-  bool device_scale_factor_changed =
-      current_device_scale_factor_ != display.device_scale_factor();
   current_display_area_ = display.work_area();
   current_device_scale_factor_ = display.device_scale_factor();
-  if (impl) {
+  if (impl)
     impl->NotifyScreenInfoChanged();
-    if (device_scale_factor_changed)
-      impl->WasResized();
-  }
 }
 
 SmoothScrollGesture* RenderWidgetHostViewBase::CreateSmoothScrollGesture(
diff --git a/content/common/view_messages.h b/content/common/view_messages.h
index 48378ab..40dc6be 100644
--- a/content/common/view_messages.h
+++ b/content/common/view_messages.h
@@ -804,17 +804,22 @@ IPC_MESSAGE_ROUTED0(ViewMsg_TimezoneChange)
 // Tells the render view to close.
 IPC_MESSAGE_ROUTED0(ViewMsg_Close)
 
-// Tells the render view to change its size.  A ViewHostMsg_PaintRect message
+IPC_STRUCT_BEGIN(ViewMsg_Resize_Params)
+  IPC_STRUCT_MEMBER(WebKit::WebScreenInfo, screen_info)
+  IPC_STRUCT_MEMBER(gfx::Size, new_size)
+  IPC_STRUCT_MEMBER(gfx::Size, physical_backing_size)
+  IPC_STRUCT_MEMBER(float, overdraw_bottom_height)
+  IPC_STRUCT_MEMBER(gfx::Rect, resizer_rect)
+  IPC_STRUCT_MEMBER(bool, is_fullscreen)
+IPC_STRUCT_END()
+
+// Tells the render view to change its size.  A ViewHostMsg_UpdateRect message
 // is generated in response provided new_size is not empty and not equal to
-// the view's current size.  The generated ViewHostMsg_PaintRect message will
+// the view's current size.  The generated ViewHostMsg_UpdateRect message will
 // have the IS_RESIZE_ACK flag set. It also receives the resizer rect so that
 // we don't have to fetch it every time WebKit asks for it.
-IPC_MESSAGE_ROUTED5(ViewMsg_Resize,
-                    gfx::Size /* new_size */,
-                    gfx::Size /* physical_backing_size */,
-                    float /* overdraw_bottom_height */,
-                    gfx::Rect /* resizer_rect */,
-                    bool /* is_fullscreen */)
+IPC_MESSAGE_ROUTED1(ViewMsg_Resize,
+                    ViewMsg_Resize_Params /* params */)
 
 // Tells the render view that the resize rect has changed.
 IPC_MESSAGE_ROUTED1(ViewMsg_ChangeResizeRect,
@@ -826,7 +831,7 @@ IPC_MESSAGE_ROUTED0(ViewMsg_WasHidden)
 
 // Tells the render view that it is no longer hidden (see WasHidden), and the
 // render view is expected to respond with a full repaint if needs_repainting
-// is true.  In that case, the generated ViewHostMsg_PaintRect message will
+// is true.  In that case, the generated ViewHostMsg_UpdateRect message will
 // have the IS_RESTORE_ACK flag set.  If needs_repainting is false, then this
 // message does not trigger a message in response.
 IPC_MESSAGE_ROUTED1(ViewMsg_WasShown,
@@ -1125,9 +1130,6 @@ IPC_MESSAGE_ROUTED1(ViewMsg_Repaint,
 // started.
 IPC_MESSAGE_ROUTED0(ViewMsg_MoveOrResizeStarted)
 
-IPC_MESSAGE_ROUTED1(ViewMsg_ScreenInfoChanged,
-                    WebKit::WebScreenInfo /* screen_info */)
-
 IPC_MESSAGE_ROUTED2(ViewMsg_UpdateScreenRects,
                     gfx::Rect /* view_screen_rect */,
                     gfx::Rect /* window_screen_rect */)
diff --git a/content/public/test/render_view_test.cc b/content/public/test/render_view_test.cc
index c1dfe26..25b55f4 100644
--- a/content/public/test/render_view_test.cc
+++ b/content/public/test/render_view_test.cc
@@ -317,8 +317,14 @@ uint32 RenderViewTest::GetNavigationIPCType() {
 void RenderViewTest::Resize(gfx::Size new_size,
                             gfx::Rect resizer_rect,
                             bool is_fullscreen) {
-  scoped_ptr<IPC::Message> resize_message(new ViewMsg_Resize(
-      0, new_size, new_size, 0.f, resizer_rect, is_fullscreen));
+  ViewMsg_Resize_Params params;
+  params.screen_info = WebKit::WebScreenInfo();
+  params.new_size = new_size;
+  params.physical_backing_size = new_size;
+  params.overdraw_bottom_height = 0.f;
+  params.resizer_rect = resizer_rect;
+  params.is_fullscreen = is_fullscreen;
+  scoped_ptr<IPC::Message> resize_message(new ViewMsg_Resize(0, params));
   OnMessageReceived(*resize_message);
 }
 
diff --git a/content/public/test/render_widget_test.cc b/content/public/test/render_widget_test.cc
index 9e19bc3..6f85052 100644
--- a/content/public/test/render_widget_test.cc
+++ b/content/public/test/render_widget_test.cc
@@ -153,17 +153,27 @@ void RenderWidgetTest::TestOnResize() {
 
   // The initial bounds is empty, so setting it to the same thing should do
   // nothing.
-  widget->OnResize(gfx::Size(), gfx::Size(), 0, gfx::Rect(), false);
+  ViewMsg_Resize_Params resize_params;
+  resize_params.screen_info = WebKit::WebScreenInfo();
+  resize_params.new_size = gfx::Size();
+  resize_params.physical_backing_size = gfx::Size();
+  resize_params.overdraw_bottom_height = 0.f;
+  resize_params.resizer_rect = gfx::Rect();
+  resize_params.is_fullscreen = false;
+  widget->OnResize(resize_params);
   EXPECT_FALSE(widget->next_paint_is_resize_ack());
 
   // Setting empty physical backing size should not send the ack.
-  widget->OnResize(gfx::Size(10, 10), gfx::Size(), 0, gfx::Rect(), false);
+  resize_params.new_size = gfx::Size(10, 10);
+  widget->OnResize(resize_params);
   EXPECT_FALSE(widget->next_paint_is_resize_ack());
 
   // Setting the bounds to a "real" rect should send the ack.
   render_thread_->sink().ClearMessages();
   gfx::Size size(100, 100);
-  widget->OnResize(size, size, 0, gfx::Rect(), false);
+  resize_params.new_size = size;
+  resize_params.physical_backing_size = size;
+  widget->OnResize(resize_params);
   EXPECT_TRUE(widget->next_paint_is_resize_ack());
   widget->DoDeferredUpdate();
   ProcessPendingMessages();
@@ -173,18 +183,22 @@ void RenderWidgetTest::TestOnResize() {
           render_thread_->sink().GetUniqueMessageMatching(
               ViewHostMsg_UpdateRect::ID));
   ASSERT_TRUE(msg);
-  ViewHostMsg_UpdateRect::Schema::Param params;
-  EXPECT_TRUE(ViewHostMsg_UpdateRect::Read(msg, &params));
-  EXPECT_TRUE(ViewHostMsg_UpdateRect_Flags::is_resize_ack(params.a.flags));
-  EXPECT_EQ(size, params.a.view_size);
+  ViewHostMsg_UpdateRect::Schema::Param update_rect_params;
+  EXPECT_TRUE(ViewHostMsg_UpdateRect::Read(msg, &update_rect_params));
+  EXPECT_TRUE(ViewHostMsg_UpdateRect_Flags::is_resize_ack(
+      update_rect_params.a.flags));
+  EXPECT_EQ(size,
+      update_rect_params.a.view_size);
   render_thread_->sink().ClearMessages();
 
   // Setting the same size again should not send the ack.
-  widget->OnResize(size, size, 0, gfx::Rect(), false);
+  widget->OnResize(resize_params);
   EXPECT_FALSE(widget->next_paint_is_resize_ack());
 
   // Resetting the rect to empty should not send the ack.
-  widget->OnResize(gfx::Size(), gfx::Size(), 0, gfx::Rect(), false);
+  resize_params.new_size = gfx::Size();
+  resize_params.physical_backing_size = gfx::Size();
+  widget->OnResize(resize_params);
   EXPECT_FALSE(widget->next_paint_is_resize_ack());
 }
 
diff --git a/content/renderer/render_view_impl.cc b/content/renderer/render_view_impl.cc
index 63938f9..a53c5a1 100644
--- a/content/renderer/render_view_impl.cc
+++ b/content/renderer/render_view_impl.cc
@@ -5603,22 +5603,18 @@ void RenderViewImpl::OnMoveOrResizeStarted() {
     webview()->hidePopups();
 }
 
-void RenderViewImpl::OnResize(const gfx::Size& new_size,
-                              const gfx::Size& physical_backing_size,
-                              float overdraw_bottom_height,
-                              const gfx::Rect& resizer_rect,
-                              bool is_fullscreen) {
+void RenderViewImpl::OnResize(const ViewMsg_Resize_Params& params) {
   if (webview()) {
     webview()->hidePopups();
     if (send_preferred_size_changes_) {
       webview()->mainFrame()->setCanHaveScrollbars(
-          ShouldDisplayScrollbars(new_size.width(), new_size.height()));
+          ShouldDisplayScrollbars(params.new_size.width(),
+                                  params.new_size.height()));
     }
     UpdateScrollState(webview()->mainFrame());
   }
 
-  RenderWidget::OnResize(new_size, physical_backing_size,
-                         overdraw_bottom_height, resizer_rect, is_fullscreen);
+  RenderWidget::OnResize(params);
 }
 
 void RenderViewImpl::WillInitiatePaint() {
diff --git a/content/renderer/render_view_impl.h b/content/renderer/render_view_impl.h
index 3bef002..28fec34 100644
--- a/content/renderer/render_view_impl.h
+++ b/content/renderer/render_view_impl.h
@@ -770,11 +770,7 @@ class CONTENT_EXPORT RenderViewImpl
  protected:
   // RenderWidget overrides:
   virtual void Close() OVERRIDE;
-  virtual void OnResize(const gfx::Size& new_size,
-                        const gfx::Size& physical_backing_size,
-                        float overdraw_bottom_height,
-                        const gfx::Rect& resizer_rect,
-                        bool is_fullscreen) OVERRIDE;
+  virtual void OnResize(const ViewMsg_Resize_Params& params) OVERRIDE;
   virtual void WillInitiatePaint() OVERRIDE;
   virtual void DidInitiatePaint() OVERRIDE;
   virtual void DidFlushPaint() OVERRIDE;
diff --git a/content/renderer/render_widget.cc b/content/renderer/render_widget.cc
index d1ece39..d85a131 100644
--- a/content/renderer/render_widget.cc
+++ b/content/renderer/render_widget.cc
@@ -339,7 +339,6 @@ bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
     IPC_MESSAGE_HANDLER(ViewMsg_SmoothScrollCompleted, OnSmoothScrollCompleted)
     IPC_MESSAGE_HANDLER(ViewMsg_SetTextDirection, OnSetTextDirection)
     IPC_MESSAGE_HANDLER(ViewMsg_Move_ACK, OnRequestMoveAck)
-    IPC_MESSAGE_HANDLER(ViewMsg_ScreenInfoChanged, OnScreenInfoChanged)
     IPC_MESSAGE_HANDLER(ViewMsg_UpdateScreenRects, OnUpdateScreenRects)
 #if defined(OS_ANDROID)
     IPC_MESSAGE_HANDLER(ViewMsg_ImeBatchStateChanged, OnImeBatchStateChanged)
@@ -464,14 +463,13 @@ void RenderWidget::OnCreatingNewAck() {
   CompleteInit();
 }
 
-void RenderWidget::OnResize(const gfx::Size& new_size,
-                            const gfx::Size& physical_backing_size,
-                            float overdraw_bottom_height,
-                            const gfx::Rect& resizer_rect,
-                            bool is_fullscreen) {
-  Resize(new_size, physical_backing_size, overdraw_bottom_height, resizer_rect,
-         is_fullscreen, SEND_RESIZE_ACK);
-  size_browser_expects_ = new_size;
+void RenderWidget::OnResize(const ViewMsg_Resize_Params& params) {
+  screen_info_ = params.screen_info;
+  SetDeviceScaleFactor(screen_info_.deviceScaleFactor);
+  Resize(params.new_size, params.physical_backing_size,
+         params.overdraw_bottom_height, params.resizer_rect,
+         params.is_fullscreen, SEND_RESIZE_ACK);
+  size_browser_expects_ = params.new_size;
 }
 
 void RenderWidget::OnChangeResizeRect(const gfx::Rect& resizer_rect) {
@@ -1953,12 +1951,6 @@ void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
   webwidget_->setTextDirection(direction);
 }
 
-void RenderWidget::OnScreenInfoChanged(
-    const WebKit::WebScreenInfo& screen_info) {
-  screen_info_ = screen_info;
-  SetDeviceScaleFactor(screen_info.deviceScaleFactor);
-}
-
 void RenderWidget::OnUpdateScreenRects(const gfx::Rect& view_screen_rect,
                                        const gfx::Rect& window_screen_rect) {
   view_screen_rect_ = view_screen_rect;
diff --git a/content/renderer/render_widget.h b/content/renderer/render_widget.h
index 1d68065..24fa7f3 100644
--- a/content/renderer/render_widget.h
+++ b/content/renderer/render_widget.h
@@ -38,6 +38,7 @@
 #include "webkit/glue/webcursor.h"
 
 struct ViewHostMsg_UpdateRect_Params;
+struct ViewMsg_Resize_Params;
 class ViewHostMsg_UpdateRect;
 
 namespace IPC {
@@ -298,11 +299,7 @@ class CONTENT_EXPORT RenderWidget
   virtual void OnSetFocus(bool enable);
   void OnClose();
   void OnCreatingNewAck();
-  virtual void OnResize(const gfx::Size& new_size,
-                        const gfx::Size& physical_backing_size,
-                        float overdraw_bottom_height,
-                        const gfx::Rect& resizer_rect,
-                        bool is_fullscreen);
+  virtual void OnResize(const ViewMsg_Resize_Params& params);
   void OnChangeResizeRect(const gfx::Rect& resizer_rect);
   virtual void OnWasHidden();
   virtual void OnWasShown(bool needs_repainting);
@@ -327,7 +324,6 @@ class CONTENT_EXPORT RenderWidget
   void OnSmoothScrollCompleted();
   void OnSetTextDirection(WebKit::WebTextDirection direction);
   void OnGetFPS();
-  void OnScreenInfoChanged(const WebKit::WebScreenInfo& screen_info);
   void OnUpdateScreenRects(const gfx::Rect& view_screen_rect,
                            const gfx::Rect& window_screen_rect);
 #if defined(OS_ANDROID)
diff --git a/content/renderer/render_widget_fullscreen_pepper.cc b/content/renderer/render_widget_fullscreen_pepper.cc
index 7839f4f..9341a91 100644
--- a/content/renderer/render_widget_fullscreen_pepper.cc
+++ b/content/renderer/render_widget_fullscreen_pepper.cc
@@ -501,15 +501,11 @@ RenderWidgetFullscreenPepper::GetBitmapForOptimizedPluginPaint(
   return NULL;
 }
 
-void RenderWidgetFullscreenPepper::OnResize(const gfx::Size& size,
-    const gfx::Size& physical_backing_size,
-    float overdraw_bottom_height,
-    const gfx::Rect& resizer_rect,
-    bool is_fullscreen) {
+void RenderWidgetFullscreenPepper::OnResize(
+    const ViewMsg_Resize_Params& params) {
   if (layer_)
-    layer_->setBounds(WebKit::WebSize(size));
-  RenderWidget::OnResize(size, physical_backing_size, overdraw_bottom_height,
-                         resizer_rect, is_fullscreen);
+    layer_->setBounds(WebKit::WebSize(params.new_size));
+  RenderWidget::OnResize(params);
 }
 
 WebWidget* RenderWidgetFullscreenPepper::CreateWebWidget() {
diff --git a/content/renderer/render_widget_fullscreen_pepper.h b/content/renderer/render_widget_fullscreen_pepper.h
index c62837e..952c54b 100644
--- a/content/renderer/render_widget_fullscreen_pepper.h
+++ b/content/renderer/render_widget_fullscreen_pepper.h
@@ -80,11 +80,7 @@ class RenderWidgetFullscreenPepper :
       gfx::Rect* location,
       gfx::Rect* clip,
       float* scale_factor) OVERRIDE;
-  virtual void OnResize(const gfx::Size& new_size,
-                        const gfx::Size& physical_backing_size,
-                        float overdraw_bottom_height,
-                        const gfx::Rect& resizer_rect,
-                        bool is_fullscreen) OVERRIDE;
+  virtual void OnResize(const ViewMsg_Resize_Params& params) OVERRIDE;
 
   // RenderWidgetFullscreen API.
   virtual WebKit::WebWidget* CreateWebWidget() OVERRIDE;