Introduce painted-device-scale-factor and use it when --enable-use-zoom-for-dsf is specified.

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 121039660409f696b70c8ac37874b504498fb957..30dbcdf58a158a0579125eb5c0c6bfb2a8d08c35 100644
--- a/content/renderer/render_widget.cc
+++ b/content/renderer/render_widget.cc
@@ -24,6 +24,7 @@
 #include "cc/trees/layer_tree_host.h"
 #include "components/scheduler/renderer/renderer_scheduler.h"
 #include "content/child/npapi/webplugin.h"
+#include "content/common/content_switches_internal.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/common/gpu/gpu_process_launch_causes.h"
@@ -768,11 +769,15 @@ void RenderWidget::Resize(const gfx::Size& new_size,
   if (!webwidget_)
     return;
 
-  if (compositor_) {
-    compositor_->setViewportSize(new_size, physical_backing_size);
-  }
+  if (compositor_)
+    compositor_->setViewportSize(physical_backing_size);
 
+  bool resized = size_ != new_size ||
+      physical_backing_size_ != physical_backing_size;
+
+  size_ = new_size;

[aelias_OOO_until_Jul13, 2015/10/25 00:07:11]

size_ should match WebView::size().

   physical_backing_size_ = physical_backing_size;
+
   top_controls_shrink_blink_size_ = top_controls_shrink_blink_size;
   top_controls_height_ = top_controls_height;
   visible_viewport_size_ = visible_viewport_size;
@@ -786,18 +791,25 @@ void RenderWidget::Resize(const gfx::Size& new_size,
   webwidget_->setTopControlsHeight(top_controls_height,
                                    top_controls_shrink_blink_size_);
 
-  if (size_ != new_size) {
-    size_ = new_size;
-
+  if (resized) {
+    gfx::Size new_widget_size =
+        IsUseZoomForDSFEnabled() ?  physical_backing_size_ : size_;

[aelias_OOO_until_Jul13, 2015/10/25 00:07:11]

Please do this in/near RenderWidgetHostViewAura instead.

     // 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_size);
+    webwidget_->resize(new_widget_size);
+  }
+  WebSize pinch_viewport_size;
+
+  if (IsUseZoomForDSFEnabled()) {
+    gfx::SizeF scaled_visible_viewport_size =
+        gfx::ScaleSize(gfx::SizeF(visible_viewport_size), device_scale_factor_);

[aelias_OOO_until_Jul13, 2015/10/25 00:07:11]

Please set this in/near RenderWidgetHostViewAura (and please avoid the lossy
back-conversion from DIPs).

+    pinch_viewport_size = gfx::ToCeiledSize(scaled_visible_viewport_size);
+  } else {
+    pinch_viewport_size = visible_viewport_size_;
   }
 
-  webwidget()->resizePinchViewport(gfx::Size(
-      visible_viewport_size.width(),
-      visible_viewport_size.height()));
+  webwidget()->resizePinchViewport(pinch_viewport_size);
 
   if (new_size.IsEmpty() || physical_backing_size.IsEmpty()) {
     // In this case there is no paint/composite and therefore no
@@ -1310,6 +1322,7 @@ void RenderWidget::FlushPendingInputEventAck() {
 // WebWidgetClient
 
 void RenderWidget::didAutoResize(const WebSize& new_size) {
+  // TODO(oshima): support UseZoomForDSFEnabled()
   if (size_.width() != new_size.width || size_.height() != new_size.height) {
     size_ = new_size;
 
@@ -1332,14 +1345,14 @@ void RenderWidget::didAutoResize(const WebSize& new_size) {
 void RenderWidget::AutoResizeCompositor()  {
   physical_backing_size_ = gfx::ScaleToCeiledSize(size_, device_scale_factor_);
   if (compositor_)
-    compositor_->setViewportSize(size_, physical_backing_size_);
+    compositor_->setViewportSize(physical_backing_size_);
 }
 
 void RenderWidget::initializeLayerTreeView() {
   DCHECK(!host_closing_);
 
   compositor_ = RenderWidgetCompositor::Create(this, compositor_deps_);
-  compositor_->setViewportSize(size_, physical_backing_size_);
+  compositor_->setViewportSize(physical_backing_size_);
 
   // For background pages and certain tests, we don't want to trigger
   // OutputSurface creation.
@@ -1597,6 +1610,7 @@ void RenderWidget::setToolTipText(const blink::WebString& text,
 }
 
 void RenderWidget::setWindowRect(const WebRect& rect) {
+  // TODO(oshima): Scale back to DIP coordinates.
   WebRect window_rect = rect;
   if (popup_origin_scale_for_emulation_) {
     float scale = popup_origin_scale_for_emulation_;
@@ -1944,8 +1958,16 @@ void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
   WebRect focus_webrect;
   WebRect anchor_webrect;
   webwidget_->selectionBounds(focus_webrect, anchor_webrect);
-  *focus = focus_webrect;
-  *anchor = anchor_webrect;
+  if (IsUseZoomForDSFEnabled()) {

[aelias_OOO_until_Jul13, 2015/10/25 00:07:11]

This is pretty ugly and looks like it will spread.  It's really nonobvious from
the standpoint of RenderWidget why a conversion to DIP is appropriate here.  The
consumer of DIP is Aura so I think the conversion should be near Aura in the
browser-side.

[oshima, 2015/10/27 20:28:09]

Both Aura/Mac uses DIP at least. Android isn't using DIP here?

For the code itself, I was thinking of removing the implicit conversion between
WebRect and gfx:: and provide explicit functions to convert between blink <->
screen coordinates. That will make it clear in which coordinates
rects/size/points are in, and eliminate if block.

[danakj, 2015/10/27 20:33:47]

I'm not sure why Aura is coming up here, but I probably misunderstand. The
renderer (blink) is DIP on every platform today, and we'd like to do
layout/painting in physical pixels.

How come Aura is related to what we're doing in RenderWidget?

The browser (UI) is DIP on Aura and physical on Android. Android is moving
toward using Aura.. but Aura is moving toward using physical pixels for
paint/layout also (slower than blink is).

+    float inverse_scale = 1.f / device_scale_factor_;
+    gfx::RectF focus_rect(focus_webrect);
+    *focus = gfx::ToEnclosingRect(gfx::ScaleRect(focus_rect, inverse_scale));
+    gfx::RectF anchor_rect(anchor_webrect);
+    *anchor = gfx::ToEnclosingRect(gfx::ScaleRect(anchor_rect, inverse_scale));
+  } else {
+    *focus = focus_webrect;
+    *anchor = anchor_webrect;
+  }
 }
 
 void RenderWidget::UpdateSelectionBounds() {