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..46efe467d01ea9c844b76923909a6da3002fd6f9 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"
@@ -767,15 +768,23 @@ void RenderWidget::Resize(const gfx::Size& new_size,
   // Ignore this during shutdown.
   if (!webwidget_)
     return;
+  bool resized = size_ != new_size ||
+      physical_backing_size_ != physical_backing_size;
 
-  if (compositor_) {
-    compositor_->setViewportSize(new_size, physical_backing_size);
-  }
-
+  size_ = new_size;
   physical_backing_size_ = physical_backing_size;
+
+  UpdateCompositorViewportSize();
+
   top_controls_shrink_blink_size_ = top_controls_shrink_blink_size;
   top_controls_height_ = top_controls_height;
-  visible_viewport_size_ = visible_viewport_size;
+  if (IsUseZoomForDSFEnabled()) {
+    gfx::SizeF scaled_visible_viewport_size =
+        gfx::ScaleSize(gfx::SizeF(visible_viewport_size), device_scale_factor_);

[danakj, 2015/10/22 23:15:29]

It seems odd that you're scaling things here.  And I'm not sure about the
WebWidget having a different size depending on the mode, but I think +enne
should have a look at this part.

[oshima, 2015/10/23 18:05:36]

visible_viewport_size is in DIP so we have to multiple by dsf for this mode
(otherwise, I get 1/4 visible contents)

[piman, 2015/10/23 19:30:33]

If you look at RenderViewImpl::OnDisableAutoResize, it will call Resize with
visible_viewport_size_, which means we would scale it again every time it's
called. That seems wrong. It also seems confusing that the space (DIP vs pixels)
of that variable depends on the flag.

Shouldn't resizePinchViewport be the one doing the scaling?

[oshima, 2015/10/23 23:50:05]

You're right. It takes blink's coord (WebRect). I changed to convert it only for
resizePinchViewport.

+    visible_viewport_size_ = gfx::ToCeiledSize(scaled_visible_viewport_size);
+  } else {
+    visible_viewport_size_ = visible_viewport_size;
+  }
   resizer_rect_ = resizer_rect;
 
   // NOTE: We may have entered fullscreen mode without changing our size.
@@ -786,18 +795,18 @@ 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_;
     // 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);
   }
 
   webwidget()->resizePinchViewport(gfx::Size(
-      visible_viewport_size.width(),
-      visible_viewport_size.height()));
+      visible_viewport_size_.width(),
+      visible_viewport_size_.height()));
 
   if (new_size.IsEmpty() || physical_backing_size.IsEmpty()) {
     // In this case there is no paint/composite and therefore no
@@ -1310,6 +1319,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;
 
@@ -1331,15 +1341,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_);
+  UpdateCompositorViewportSize();
 }
 
 void RenderWidget::initializeLayerTreeView() {
   DCHECK(!host_closing_);
 
   compositor_ = RenderWidgetCompositor::Create(this, compositor_deps_);
-  compositor_->setViewportSize(size_, physical_backing_size_);
+  UpdateCompositorViewportSize();
 
   // For background pages and certain tests, we don't want to trigger
   // OutputSurface creation.
@@ -1597,6 +1606,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 +1954,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()) {
+    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() {
@@ -2362,6 +2380,17 @@ RenderWidget::CreateGraphicsContext3D(bool compositor) {
   return context.Pass();
 }
 
+void RenderWidget::UpdateCompositorViewportSize() {
+  if (!compositor_)
+    return;
+  if (IsUseZoomForDSFEnabled()) {
+    compositor_->setViewportSize(size_, physical_backing_size_);

[danakj, 2015/10/22 23:15:29]

The function that takes 2 args here should probably not exist anymore, and it
always ignores the first argument entirely. So this is all equivalent to always
just passing the physical_backing_size_

[oshima, 2015/10/23 18:05:36]

Ah, I didn't know about that. Changed to use single arg and removed two arg
method.

+  } else {
+    compositor_->setViewportSize(physical_backing_size_,
+                                 physical_backing_size_);
+  }
+}
+
 void RenderWidget::RegisterRenderFrameProxy(RenderFrameProxy* proxy) {
   render_frame_proxies_.AddObserver(proxy);
 }