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

content/renderer/render_widget.cc

Index: content/renderer/render_widget.cc
diff --git a/content/renderer/render_widget.cc b/content/renderer/render_widget.cc
index 82d7364658e253565bef5d04aeb5d9edc32f8548..c1be13ffe86ebc9f899f07cb5dbb0ed8b79cc525 100644
--- a/content/renderer/render_widget.cc
+++ b/content/renderer/render_widget.cc
@@ -588,6 +588,7 @@ void RenderWidget::OnEnableDeviceEmulation(
     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);
   }
@@ -1099,8 +1100,11 @@ void RenderWidget::Resize(const ResizeParams& params) {
                                    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.
@@ -1109,8 +1113,9 @@ void RenderWidget::Resize(const ResizeParams& params) {
   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_;
   }
@@ -1477,9 +1482,8 @@ void RenderWidget::OnImeConfirmComposition(const base::string16& text,
 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_);
 }
@@ -1570,7 +1574,7 @@ void RenderWidget::UpdateCompositionInfo(bool should_update_range) {
 
 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 =
@@ -1584,10 +1588,10 @@ void RenderWidget::convertViewportToWindow(blink::WebRect* rect) {
 
 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();
   }
 }
 
@@ -2118,4 +2122,11 @@ void RenderWidget::OnWaitNextFrameForTests(int 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