[DevTools] Handle emulated device scale factor and original device scale factor properly.

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 570 matching lines @@
     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);
   }
 }
 
 void RenderWidget::OnDisableDeviceEmulation() {
   screen_metrics_emulator_.reset();
 }
 
 void RenderWidget::OnColorProfile(const std::vector<char>& color_profile) {
@@ skipping 491 matching lines @@
   // 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_);
 
   if (resized) {
-    gfx::Size new_widget_size =
-        IsUseZoomForDSFEnabled() ? physical_backing_size_ : 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.
     webwidget_->resize(new_widget_size);
   }
   WebSize visual_viewport_size;
 
   if (IsUseZoomForDSFEnabled()) {
-    visual_viewport_size = gfx::ScaleToCeiledSize(params.visible_viewport_size,
-                                                  device_scale_factor_);
+    visual_viewport_size = gfx::ScaleToCeiledSize(
+        params.visible_viewport_size,
+        GetOriginalDeviceScaleFactor());
   } else {
     visual_viewport_size = visible_viewport_size_;
   }
 
   webwidget()->resizeVisualViewport(visual_viewport_size);
 
   if (params.new_size.IsEmpty() || params.physical_backing_size.IsEmpty()) {
     // In this case there is no paint/composite and therefore no
     // ViewHostMsg_UpdateRect to send the resize ack with. We'd need to send the
     // ack through a fake ViewHostMsg_UpdateRect or a different message.
@@ skipping 346 matching lines @@
     webwidget_->confirmComposition(WebWidget::KeepSelection);
   else
     webwidget_->confirmComposition(WebWidget::DoNotKeepSelection);
   input_handler_->set_handling_input_event(false);
   UpdateCompositionInfo(true);
 }
 
 void RenderWidget::OnDeviceScaleFactorChanged() {
   if (!compositor_)
     return;
-
   if (IsUseZoomForDSFEnabled())
-    compositor_->SetPaintedDeviceScaleFactor(device_scale_factor_);
+    compositor_->SetPaintedDeviceScaleFactor(GetOriginalDeviceScaleFactor());

[dgozman, 2016/02/29 20:26:20]

These calls start to look messy. When do I use |device_scale_factor_| and when
do I use original one? It's unclear. Can we clean this up a little bit? For
example, having |device_scale_factor_| and |screenInfo_.deviceScaleFactor|
sounds strange. Killing the former could simplify quite a few places, and maybe
then we could use a |painted_device_scale_factor| or
|compositor_device_scale_factor| to make everything clear?

[oshima, 2016/02/29 21:28:03]

Compositor should always use the original scale factor. It may not clear because
the compositor's
scale_factor_ here can be overridden by setCompositorDeviceScaleFactorOverride. 

I think we can make it clearer by always using the original scale factor to
compositor here, and
then explicitly set the emulated scale factor to WebView in
RenderWidgetScreenMetricsEmulator::Apply.
(as we briefly discussed offline last week) What do you think?

I can also look into killing device_scale_factor_ but let me do this refactoring
in a separate CL because
I need to merge this to 50 and I want to keep the change not to affect the
regular code path (for use-zoom-for-dsf is disabled)

[dgozman, 2016/02/29 21:38:41]

Are you sure about merging this into 50? Sounds scary. Perhaps, we can bake the
new mode for one more release (and just disable it in 50)? Since it's a
refactoring, users won't notice.

[oshima, 2016/02/29 22:59:50]

This one isn't refactoreing, and we need this to merge to 50 for ChromeOS.
That's why I made this change specific to this mode (This is enabled only on
ChroemOS and disabled on all other platforms).
In worst case, we still have an option to disable it in 50 by the flag
(enable-use-zoom-for-dsf).

   else
     compositor_->setDeviceScaleFactor(device_scale_factor_);
 }
 
 void RenderWidget::OnRepaint(gfx::Size size_to_paint) {
   // During shutdown we can just ignore this message.
   if (!webwidget_)
     return;
 
   // Even if the browser provides an empty damage rect, it's still expecting to
@@ skipping 70 matching lines @@
     return;
   composition_character_bounds_ = character_bounds;
   composition_range_ = range;
   Send(new InputHostMsg_ImeCompositionRangeChanged(
       routing_id(), composition_range_, composition_character_bounds_));
 #endif
 }
 
 void RenderWidget::convertViewportToWindow(blink::WebRect* rect) {
   if (IsUseZoomForDSFEnabled()) {
-    float reverse = 1 / device_scale_factor_;
+    float reverse = 1 / GetOriginalDeviceScaleFactor();
     // TODO(oshima): We may need to allow pixel precision here as the the
     // anchor element can be placed at half pixel.
     gfx::Rect window_rect =
         gfx::ScaleToEnclosedRect(gfx::Rect(*rect), reverse);
     rect->x = window_rect.x();
     rect->y = window_rect.y();
     rect->width = window_rect.width();
     rect->height = window_rect.height();
   }
 }
 
 void RenderWidget::convertWindowToViewport(blink::WebFloatRect* rect) {
   if (IsUseZoomForDSFEnabled()) {
-    rect->x *= device_scale_factor_;
-    rect->y *= device_scale_factor_;
-    rect->width *= device_scale_factor_;
-    rect->height *= device_scale_factor_;
+    rect->x *= GetOriginalDeviceScaleFactor();
+    rect->y *= GetOriginalDeviceScaleFactor();
+    rect->width *= GetOriginalDeviceScaleFactor();
+    rect->height *= GetOriginalDeviceScaleFactor();
   }
 }
 
 void RenderWidget::OnShowImeIfNeeded() {
 #if defined(OS_ANDROID) || defined(USE_AURA)
   UpdateTextInputState(ShowIme::IF_NEEDED, ChangeSource::FROM_NON_IME);
 #endif
 
 // TODO(rouslan): Fix ChromeOS and Windows 8 behavior of autofill popup with
 // virtual keyboard.
@@ skipping 510 matching lines @@
 void RenderWidget::UnregisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.RemoveObserver(frame);
 }
 #endif  // defined(VIDEO_HOLE)
 
 void RenderWidget::OnWaitNextFrameForTests(int routing_id) {
   QueueMessage(new ViewHostMsg_WaitForNextFrameForTests_ACK(routing_id),
                MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE);
 }
 
+float RenderWidget::GetOriginalDeviceScaleFactor() const {
+  return
+      screen_metrics_emulator_ ?
+      screen_metrics_emulator_->original_screen_info().deviceScaleFactor :
+      device_scale_factor_;
+}
+
 }  // namespace content