Compute the popup location/size correctly when use-zoom-for-dsf is enabled.

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"
@@ skipping 861 matching lines @@
     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_widget_size);
   }
   WebSize visual_viewport_size;
 
   if (IsUseZoomForDSFEnabled()) {
-    gfx::SizeF scaled_visible_viewport_size =
-        gfx::ScaleSize(gfx::SizeF(visible_viewport_size), device_scale_factor_);
-    visual_viewport_size = gfx::ToCeiledSize(scaled_visible_viewport_size);
+    visual_viewport_size =
+        gfx::ScaleToCeiledSize(visible_viewport_size, device_scale_factor_);
   } else {
     visual_viewport_size = visible_viewport_size_;
   }
 
   webwidget()->resizeVisualViewport(visual_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.
@@ skipping 554 matching lines @@
   physical_backing_size_ = gfx::ScaleToCeiledSize(size_, device_scale_factor_);
   if (compositor_)
     compositor_->setViewportSize(physical_backing_size_);
 }
 
 void RenderWidget::initializeLayerTreeView() {
   DCHECK(!host_closing_);
 
   compositor_ = RenderWidgetCompositor::Create(this, compositor_deps_);
   compositor_->setViewportSize(physical_backing_size_);
-
+  OnDeviceScaleFactorChanged();
   // 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() {
   if (host_closing_)
@@ skipping 235 matching lines @@
     return pending_window_rect_;
 
   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;
+void RenderWidget::setWindowRect(const WebRect& rect_in_screen) {
+  WebRect window_rect = rect_in_screen;
   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()) {
     if (did_show_) {
@@ skipping 57 matching lines @@
   if (text.length())
     webwidget_->confirmComposition(text);
   else if (keep_selection)
     webwidget_->confirmComposition(WebWidget::KeepSelection);
   else
     webwidget_->confirmComposition(WebWidget::DoNotKeepSelection);
   handling_input_event_ = false;
   UpdateCompositionInfo(true);
 }
 
+void RenderWidget::OnDeviceScaleFactorChanged() {
+  DCHECK(compositor_);
+  if (IsUseZoomForDSFEnabled())
+    compositor_->SetPaintedDeviceScaleFactor(device_scale_factor_);
+  else
+    compositor_->setDeviceScaleFactor(device_scale_factor_);
+}
+
 void RenderWidget::OnRepaint(gfx::Size size_to_paint) {
   // During shutdown we can just ignore this message.
   if (!webwidget_)
     return;
 
   // Even if the browser provides an empty damage rect, it's still expecting to
   // receive a repaint ack so just damage the entire widget bounds.
   if (size_to_paint.IsEmpty()) {
     size_to_paint = size_;
   }
@@ skipping 38 matching lines @@
     compositor_->OnHandleCompositorProto(proto);
 }
 
 void RenderWidget::showImeIfNeeded() {
   OnShowImeIfNeeded();
 }
 
 void RenderWidget::convertViewportToWindow(blink::WebRect* rect) {
   if (IsUseZoomForDSFEnabled()) {
     float reverse = 1 / device_scale_factor_;
-    // TODO(oshima): We may wait to allow pixel precision here as the the
+    // 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 =
         gfx::ScaleToEnclosedRect(gfx::Rect(*rect), reverse);
     rect->x = window_rect.x();
     rect->y = window_rect.y();
     rect->width = window_rect.width();
     rect->height = window_rect.height();
   }
 }
 
@@ skipping 56 matching lines @@
 
 void RenderWidget::IgnoreAckForMouseMoveFromDebugger() {
   ignore_ack_for_mouse_move_from_debugger_ = true;
 }
 
 void RenderWidget::SetDeviceScaleFactor(float device_scale_factor) {
   if (device_scale_factor_ == device_scale_factor)
     return;
 
   device_scale_factor_ = device_scale_factor;
+
+  OnDeviceScaleFactorChanged();
+
   ScheduleComposite();
 }
 
 bool RenderWidget::SetDeviceColorProfile(
     const std::vector<char>& color_profile) {
   if (device_color_profile_ == color_profile)
     return false;
 
   device_color_profile_ = color_profile;
   return true;
@@ skipping 603 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