Fix main thread top controls scrolling to mirror CC.

content/renderer/render_widget.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 "content/renderer/render_widget.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 200 matching lines @@
                            blink::WebPopupType popup_type,
                            const blink::WebScreenInfo& screen_info,
                            bool swapped_out,
                            bool hidden,
                            bool never_visible)
     : routing_id_(MSG_ROUTING_NONE),
       compositor_deps_(compositor_deps),
       webwidget_(nullptr),
       owner_delegate_(nullptr),
       opener_id_(MSG_ROUTING_NONE),
-      top_controls_shrink_blink_size_(false),
-      top_controls_height_(0.f),
       next_paint_flags_(0),
       auto_resize_mode_(false),
       need_update_rect_for_auto_resize_(false),
       did_show_(false),
       is_hidden_(hidden),
       compositor_never_visible_(never_visible),
       is_fullscreen_granted_(false),
       display_mode_(blink::WebDisplayModeUndefined),
       ime_event_guard_(nullptr),
       closing_(false),
@@ skipping 275 matching lines @@
   return RenderThread::Get()->Send(message);
 }
 
 void RenderWidget::SetWindowRectSynchronously(
     const gfx::Rect& new_window_rect) {
   ResizeParams params;
   params.screen_info = screen_info_;
   params.new_size = new_window_rect.size();
   params.physical_backing_size =
       gfx::ScaleToCeiledSize(new_window_rect.size(), device_scale_factor_);
-  params.top_controls_shrink_blink_size = top_controls_shrink_blink_size_;
-  params.top_controls_height = top_controls_height_;
   params.visible_viewport_size = new_window_rect.size();
   params.resizer_rect = gfx::Rect();
   params.is_fullscreen_granted = is_fullscreen_granted_;
   params.display_mode = display_mode_;
   params.needs_resize_ack = false;
   Resize(params);
 
   view_screen_rect_ = new_window_rect;
   window_screen_rect_ = new_window_rect;
   if (!did_show_)
@@ skipping 47 matching lines @@
 }
 
 void RenderWidget::OnEnableDeviceEmulation(
    const blink::WebDeviceEmulationParams& params) {
   if (!screen_metrics_emulator_) {
     ResizeParams resize_params;
     resize_params.screen_info = screen_info_;
     resize_params.new_size = size_;
     resize_params.physical_backing_size = physical_backing_size_;
     resize_params.visible_viewport_size = visible_viewport_size_;
-    resize_params.top_controls_shrink_blink_size =
-        top_controls_shrink_blink_size_;
-    resize_params.top_controls_height = top_controls_height_;
     resize_params.resizer_rect = resizer_rect_;
     resize_params.is_fullscreen_granted = is_fullscreen_granted_;
     resize_params.display_mode = display_mode_;
     screen_metrics_emulator_.reset(new RenderWidgetScreenMetricsEmulator(
         this, params, resize_params, view_screen_rect_, window_screen_rect_));
     screen_metrics_emulator_->Apply();
   } else {
     screen_metrics_emulator_->ChangeEmulationParams(params);
   }
 }
@@ skipping 491 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetScreenMetricsDelegate
 
 void RenderWidget::Redraw() {
   set_next_paint_is_resize_ack();
   if (compositor_)
     compositor_->SetNeedsRedrawRect(gfx::Rect(size_));
 }
 
+void RenderWidget::ResizeWebWidget(const ResizeParams& params) {
+    bool resized = size_ != params.new_size ||
+                   physical_backing_size_ != params.physical_backing_size;

[no sievers, 2016/04/13 18:40:24]

I'm wondering: If physical backing size changed to we really need to call
webwidget_->resize()? We're not passing the physical size to it, that's only
meant for the compositor, right?

This was introduced as a behavioral change in
https://codereview.chromium.org/1412663005/diff/220001/content/renderer/rende...,
not sure why, but became definitely obsolete in
https://codereview.chromium.org/1737733002/diff/420001/content/renderer/rende....

Maybe then line 1099 could also stay in the call site.

[bokan, 2016/04/13 20:29:25]

sgtm. I'll put up a new patch with that change (and maybe put the early out into
all the WebWidget descendants) and land that first. Will put up soon...

[no sievers, 2016/04/13 23:04:31]

ok, lgtm if you want to do that in a separate patch as a follow-up then.

+
+    size_ = params.new_size;
+    physical_backing_size_ = params.physical_backing_size;
+
+    gfx::Size new_widget_size = size_;
+    if (IsUseZoomForDSFEnabled()) {

[no sievers, 2016/04/13 18:40:23]

nit: and maybe line 1102-1105 can just be a helper like:

void RenderWidget::ResizeWebWidget(const ResizeParams& params) {
  if (size_ == params.new_size)
    return;

  size_ = params.new_size;

  webwidget_->resize(GetSizeForWebWidget());
}

Then GetOriginalDeviceScaleFactor() can stay private too.

[bokan, 2016/04/13 20:29:25]

Done.

+      new_widget_size = gfx::ScaleToCeiledSize(new_widget_size,
+                                               GetOriginalDeviceScaleFactor());
+    }
+
+    if (resized)
+        webwidget_->resize(new_widget_size);
+}
+
 void RenderWidget::Resize(const ResizeParams& params) {
   bool orientation_changed =
       screen_info_.orientationAngle != params.screen_info.orientationAngle ||
       screen_info_.orientationType != params.screen_info.orientationType;
 
   screen_info_ = params.screen_info;
   SetDeviceScaleFactor(screen_info_.deviceScaleFactor);
 
   if (resizing_mode_selector_->NeverUsesSynchronousResize()) {
     // A resize ack shouldn't be requested if we have not ACK'd the previous
     // one.
     DCHECK(!params.needs_resize_ack || !next_paint_is_resize_ack());
   }
 
   // Ignore this during shutdown.
   if (!webwidget_)
     return;
 
   if (compositor_)
     compositor_->setViewportSize(params.physical_backing_size);
 
-  bool resized = size_ != params.new_size ||
-                 physical_backing_size_ != params.physical_backing_size;
-
-  size_ = params.new_size;
-  physical_backing_size_ = params.physical_backing_size;
-
-  top_controls_shrink_blink_size_ = params.top_controls_shrink_blink_size;
-  top_controls_height_ = params.top_controls_height;
   visible_viewport_size_ = params.visible_viewport_size;
   resizer_rect_ = params.resizer_rect;
 
   // NOTE: We may have entered fullscreen mode without changing our size.
   bool fullscreen_change =
       is_fullscreen_granted_ != params.is_fullscreen_granted;
   is_fullscreen_granted_ = params.is_fullscreen_granted;
   display_mode_ = params.display_mode;
 
-  webwidget_->setTopControlsHeight(params.top_controls_height,
-                                   top_controls_shrink_blink_size_);
+  // When resizing, we want to wait to paint before ACK'ing the resize.  This
+  // ensures that we only resize as fast as we can paint.  We only need to
+  // send an ACK if we are resized to a non-empty rect.

[no sievers, 2016/04/13 18:40:23]

nit: This comment was a bit out of place even before your change. Can you move
and consolidate it with the logic in lines 1158-1163 and 1166-1167 whwere it
belongs?

[bokan, 2016/04/13 20:29:25]

Done.

+  ResizeWebWidget(params);
 
-  if (resized) {
-    gfx::Size new_widget_size = size_;
-    if (IsUseZoomForDSFEnabled()) {
-      new_widget_size = gfx::ScaleToCeiledSize(new_widget_size,
-                                               GetOriginalDeviceScaleFactor());
-    }
-    // When resizing, we want to wait to paint before ACK'ing the resize.  This
-    // ensures that we only resize as fast as we can paint.  We only need to
-    // send an ACK if we are resized to a non-empty rect.
-    webwidget_->resize(new_widget_size);
-  }
   WebSize visual_viewport_size;
 
   if (IsUseZoomForDSFEnabled()) {
     visual_viewport_size = gfx::ScaleToCeiledSize(
         params.visible_viewport_size,
         GetOriginalDeviceScaleFactor());
   } else {
     visual_viewport_size = visible_viewport_size_;
   }
 
@@ skipping 985 matching lines @@
 }
 
 float RenderWidget::GetOriginalDeviceScaleFactor() const {
   return
       screen_metrics_emulator_ ?
       screen_metrics_emulator_->original_screen_info().deviceScaleFactor :
       device_scale_factor_;
 }
 
 }  // namespace content