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/render_widget_scheduling_state.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 747 matching lines @@
     // 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;
 
-  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;
   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;
   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);
+  }
+  WebSize pinch_viewport_size;
+
+  if (IsUseZoomForDSFEnabled()) {
+    gfx::SizeF scaled_visible_viewport_size =
+        gfx::ScaleSize(gfx::SizeF(visible_viewport_size), device_scale_factor_);
+    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
     // 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_);
+    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.
   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 330 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 127 matching lines @@
 #endif
 
 bool RenderWidget::CanComposeInline() {
   return true;
 }
 
 WebScreenInfo RenderWidget::screenInfo() {
   return screen_info_;
 }
 
-float RenderWidget::deviceScaleFactor() {
-  return device_scale_factor_;
-}
-
 void RenderWidget::resetInputMethod() {
   ImeEventGuard guard(this);
   // If the last text input type is not None, then we should finish any
   // ongoing composition regardless of the new text input type.
   if (text_input_type_ != ui::TEXT_INPUT_TYPE_NONE) {
     // If a composition text exists, then we need to let the browser process
     // to cancel the input method's ongoing composition session.
     if (webwidget_->confirmComposition())
       Send(new InputHostMsg_ImeCancelComposition(routing_id()));
   }
@@ skipping 274 matching lines @@
 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