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

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 "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_synthetic_delay.h"
 #include "build/build_config.h"
 #include "cc/base/switches.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/output/output_surface.h"
 #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"
 #include "content/common/input/synthetic_gesture_packet.h"
 #include "content/common/input/web_input_event_traits.h"
 #include "content/common/input_messages.h"
 #include "content/common/swapped_out_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/context_menu_params.h"
@@ skipping 723 matching lines @@
   if (resizing_mode_selector_->NeverUsesSynchronousResize()) {
     // A resize ack shouldn't be requested if we have not ACK'd the previous
     // one.
     DCHECK(resize_ack != SEND_RESIZE_ACK || !next_paint_is_resize_ack());
     DCHECK(resize_ack == SEND_RESIZE_ACK || resize_ack == NO_RESIZE_ACK);
   }
 
   // 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;
 
-  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.
   bool fullscreen_change = is_fullscreen_granted_ != is_fullscreen_granted;
   is_fullscreen_granted_ = is_fullscreen_granted;
   display_mode_ = display_mode;
 
   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
     // ViewHostMsg_UpdateRect to send the resize ack with. We'd need to send the
     // ack through a fake ViewHostMsg_UpdateRect or a different message.
     DCHECK_EQ(resize_ack, NO_RESIZE_ACK);
   }
 
   // Send the Resize_ACK flag once we paint again if requested.
   if (resize_ack == SEND_RESIZE_ACK)
@@ skipping 492 matching lines @@
                            pending_input_event_ack_.get());
     Send(pending_input_event_ack_.release());
   }
   total_input_handling_time_this_frame_ = base::TimeDelta();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // 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;
 
     if (resizing_mode_selector_->is_synchronous_mode()) {
       WebRect new_pos(rootWindowRect().x,
                       rootWindowRect().y,
                       new_size.width,
                       new_size.height);
       view_screen_rect_ = new_pos;
       window_screen_rect_ = new_pos;
     }
 
     AutoResizeCompositor();
 
     if (!resizing_mode_selector_->is_synchronous_mode())
       need_update_rect_for_auto_resize_ = true;
   }
 }
 
 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.
   if (compositor_never_visible_ || !RenderThreadImpl::current())
     compositor_->SetNeverVisible();
 
   StartCompositor();
 }
 
 void RenderWidget::WillCloseLayerTreeView() {
@@ skipping 237 matching lines @@
 
   return view_screen_rect_;
 }
 
 void RenderWidget::setToolTipText(const blink::WebString& text,
                                   WebTextDirection hint) {
   Send(new ViewHostMsg_SetTooltipText(routing_id_, text, hint));
 }
 
 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_;
     window_rect.x = popup_screen_origin_for_emulation_.x() +
         (window_rect.x - popup_view_origin_for_emulation_.x()) * scale;
     window_rect.y = popup_screen_origin_for_emulation_.y() +
         (window_rect.y - popup_view_origin_for_emulation_.y()) * scale;
   }
 
   if (!resizing_mode_selector_->is_synchronous_mode()) {
@@ skipping 327 matching lines @@
     text_input_mode_ = new_mode;
     can_compose_inline_ = new_can_compose_inline;
     text_input_flags_ = new_info.flags;
   }
 }
 
 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() {
   TRACE_EVENT0("renderer", "RenderWidget::UpdateSelectionBounds");
   if (!webwidget_)
     return;
   if (handling_ime_event_)
     return;
 
 #if defined(USE_AURA)
@@ skipping 396 matching lines @@
     limits.min_transfer_buffer_size = 64 * 1024;
   }
 
   scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context(
       new WebGraphicsContext3DCommandBufferImpl(
           0, GetURLForGraphicsContext3D(), gpu_channel_host.get(), attributes,
           lose_context_when_out_of_memory, limits, NULL));
   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);
 }
 
 void RenderWidget::UnregisterRenderFrameProxy(RenderFrameProxy* proxy) {
   render_frame_proxies_.RemoveObserver(proxy);
 }
 
 void RenderWidget::RegisterRenderFrame(RenderFrameImpl* frame) {
   render_frames_.AddObserver(frame);
 }
 
 void RenderWidget::UnregisterRenderFrame(RenderFrameImpl* frame) {
   render_frames_.RemoveObserver(frame);
 }
 
 #if defined(VIDEO_HOLE)
 void RenderWidget::RegisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.AddObserver(frame);
 }
 
 void RenderWidget::UnregisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.RemoveObserver(frame);
 }
 #endif  // defined(VIDEO_HOLE)
 
 }  // namespace content