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 gfx::Size& new_size, bool resized) {
+    if (resized)

[no sievers, 2016/04/12 22:44:12]

Hmm, weird pattern with passing a bool to a function that tells it to not
perform the function. Can you leave that check with the caller?

[bokan, 2016/04/13 17:25:39]

Agree that its odd but I'm not sure there's a clean way without doing some
rearranging. The reason I put it there is because if only the top controls
height changes, we still want to call resize in RenderView's version.
Unfortunately, RenderWidget can't check the current top control height.

I made ResizeWebWidget take the ResizeParams and make it set the various private
vars like size_ and physical_backing_size_. That way it can calculate whether a
resize occurred itself and the RenderView version can also check for a change in
top_controls_height_. I uploaded a new CL that does this. It's not ideal IMO
since there's quite a bit of duplication. The other alternative is to make more
virtual methods that RenderView overrides but then we'd need bool
NeedsWebWidgetResize(ResizeParams), void StoreResizeParams(ResizeParams),
ResizeWebWidget(ResizeParams) which seems like overkill.

Ideally, we could get rid of the resized check altogether and rely on WebWidget
implementations not to do anything unless something's changed. It seems just
plugins and popups are missing an early out right now, maybe it'd make sense to
add that there in a pre/post patch? Let me know your preference.

+        webwidget_->resize(new_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_);
+  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.
+  ResizeWebWidget(new_widget_size, resized);
 
-  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