Remove a few conversion methods on WebWidgetClient.

Use the WidgetBase implementations instead of going via the
WebWidgetClient.

BUG=1097816

Change-Id: Ib08b5748806fe3862ac291d354043326d3172282
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2419129Reviewed-by: danakj <danakj@chromium.org>
Commit-Queue: Dave Tapuska <dtapuska@chromium.org>
Cr-Commit-Position: refs/heads/master@{#809421}

content/renderer/render_widget.cc

@@ -714,17 +714,6 @@ viz::FrameSinkId RenderWidget::GetFrameSinkId() {
   return viz::FrameSinkId(RenderThread::Get()->GetClientId(), routing_id());
 }
 
-gfx::PointF RenderWidget::ConvertWindowPointToViewport(
-    const gfx::PointF& point) {
-  blink::WebFloatRect point_in_viewport(point.x(), point.y(), 0, 0);
-  ConvertWindowToViewport(&point_in_viewport);
-  return gfx::PointF(point_in_viewport.x, point_in_viewport.y);
-}
-
-gfx::Point RenderWidget::ConvertWindowPointToViewport(const gfx::Point& point) {
-  return gfx::ToRoundedPoint(ConvertWindowPointToViewport(gfx::PointF(point)));
-}
-
 bool RenderWidget::RequestPointerLock(
     WebLocalFrame* requester_frame,
     blink::WebWidgetClient::PointerLockCallback callback,

content/renderer/render_widget.h

@@ -216,8 +216,6 @@ class CONTENT_EXPORT RenderWidget
   void ConvertViewportToWindow(blink::WebRect* rect) override;
   void ConvertViewportToWindow(blink::WebFloatRect* rect) override;
   void ConvertWindowToViewport(blink::WebFloatRect* rect) override;
-  gfx::Point ConvertWindowPointToViewport(const gfx::Point& point) override;
-  gfx::PointF ConvertWindowPointToViewport(const gfx::PointF& point) override;
   bool RequestPointerLock(blink::WebLocalFrame* requester_frame,
                           blink::WebWidgetClient::PointerLockCallback callback,
                           bool request_unadjusted_movement) override;

third_party/blink/public/web/web_widget_client.h

@@ -59,7 +59,6 @@ class SkBitmap;
 
 namespace gfx {
 class Point;
-class PointF;
 }
 
 namespace ui {
@@ -156,12 +155,6 @@ class WebWidgetClient {
   // is eanbled.  TODO(oshima): Update the comment when the
   // migration is completed.
   virtual void ConvertWindowToViewport(WebFloatRect* rect) {}
-  virtual gfx::Point ConvertWindowPointToViewport(const gfx::Point& point) {
-    return point;
-  }
-  virtual gfx::PointF ConvertWindowPointToViewport(const gfx::PointF& point) {
-    return point;
-  }
 
   // Called when a drag-and-drop operation should begin. Returns whether the
   // call has been handled.

third_party/blink/renderer/core/frame/web_frame_widget_base.cc

@@ -489,11 +489,10 @@ void WebFrameWidgetBase::StartDragging(const WebDragData& drag_data,
     return;
   }
 
-  WebRect offset_in_window(drag_image_offset.x(), drag_image_offset.y(), 0, 0);
-  Client()->ConvertViewportToWindow(&offset_in_window);
+  gfx::Point offset_in_dips = widget_base_->BlinkSpaceToDIPs(drag_image_offset);
   GetAssociatedFrameWidgetHost()->StartDragging(
       drag_data, operations_allowed, drag_image,
-      gfx::Vector2d(offset_in_window.x, offset_in_window.y),
+      gfx::Vector2d(offset_in_dips.x(), offset_in_dips.y()),
       possible_drag_event_info_.Clone());
 }
 
@@ -1560,11 +1559,11 @@ void WebFrameWidgetBase::GetEditContextBoundsInWindow(
   WebRect control_bounds;
   WebRect selection_bounds;
   controller->GetLayoutBounds(&control_bounds, &selection_bounds);
-  client_->ConvertViewportToWindow(&control_bounds);
-  edit_context_control_bounds->emplace(control_bounds);
+  *edit_context_control_bounds =
+      widget_base_->BlinkSpaceToDIPs(gfx::Rect(control_bounds));
   if (controller->IsEditContextActive()) {
-    client_->ConvertViewportToWindow(&selection_bounds);
-    edit_context_selection_bounds->emplace(selection_bounds);
+    *edit_context_selection_bounds =
+        widget_base_->BlinkSpaceToDIPs(gfx::Rect(selection_bounds));
   }
 }
 
@@ -1605,15 +1604,16 @@ bool WebFrameWidgetBase::GetSelectionBoundsInWindow(
   WebRect focus_webrect;
   WebRect anchor_webrect;
   SelectionBounds(focus_webrect, anchor_webrect);
-  client_->ConvertViewportToWindow(&focus_webrect);
-  client_->ConvertViewportToWindow(&anchor_webrect);
+  gfx::Rect focus_rect_in_dips =
+      widget_base_->BlinkSpaceToDIPs(gfx::Rect(focus_webrect));
+  gfx::Rect anchor_rect_in_dips =
+      widget_base_->BlinkSpaceToDIPs(gfx::Rect(anchor_webrect));
 
   // if the bounds are the same return false.
-  if (gfx::Rect(focus_webrect) == *focus &&
-      gfx::Rect(anchor_webrect) == *anchor)
+  if (focus_rect_in_dips == *focus && anchor_rect_in_dips == *anchor)
     return false;
-  *focus = gfx::Rect(focus_webrect);
-  *anchor = gfx::Rect(anchor_webrect);
+  *focus = focus_rect_in_dips;
+  *anchor = anchor_rect_in_dips;
 
   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
   if (!focused_frame)
@@ -1759,9 +1759,9 @@ bool WebFrameWidgetBase::IsProvisional() {
 }
 
 uint64_t WebFrameWidgetBase::GetScrollableContainerIdAt(
-    const gfx::PointF& point) {
-  gfx::PointF point_in_pixel = Client()->ConvertWindowPointToViewport(point);
-  return HitTestResultAt(point_in_pixel).GetScrollableContainerId();
+    const gfx::PointF& point_in_dips) {
+  gfx::PointF point = widget_base_->DIPsToBlinkSpace(point_in_dips);
+  return HitTestResultAt(point).GetScrollableContainerId();
 }
 
 void WebFrameWidgetBase::SetEditCommandsForNextKeyEvent(
@@ -1860,7 +1860,7 @@ gfx::Range WebFrameWidgetBase::CompositionRange() {
 }
 
 void WebFrameWidgetBase::GetCompositionCharacterBoundsInWindow(
-    Vector<gfx::Rect>* bounds) {
+    Vector<gfx::Rect>* bounds_in_dips) {
   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
   if (!focused_frame)
     return;
@@ -1870,13 +1870,11 @@ void WebFrameWidgetBase::GetCompositionCharacterBoundsInWindow(
   if (!controller->GetCompositionCharacterBounds(bounds_from_blink))
     return;
 
-  for (size_t i = 0; i < bounds_from_blink.size(); ++i) {
-    Client()->ConvertViewportToWindow(&bounds_from_blink[i]);
-    bounds->push_back(bounds_from_blink[i]);
+  for (auto& rect : bounds_from_blink) {
+    bounds_in_dips->push_back(widget_base_->BlinkSpaceToDIPs(gfx::Rect(rect)));
   }
 }
 
-
 void WebFrameWidgetBase::AddImeTextSpansToExistingText(
     uint32_t start,
     uint32_t end,
@@ -1901,10 +1899,9 @@ WebFrameWidgetBase::GetImeTextSpansInfo(
     unsigned length = ime_text_span.end_offset - ime_text_span.start_offset;
     focused_frame->FirstRectForCharacterRange(ime_text_span.start_offset,
                                               length, webrect);
-    Client()->ConvertViewportToWindow(&webrect);
 
     ime_text_spans_info.push_back(ui::mojom::blink::ImeTextSpanInfo::New(
-        ime_text_span, gfx::Rect(webrect)));
+        ime_text_span, widget_base_->BlinkSpaceToDIPs(gfx::Rect(webrect))));
   }
   return ime_text_spans_info;
 }
@@ -2063,13 +2060,13 @@ void WebFrameWidgetBase::ReplaceMisspelling(const String& word) {
   focused_frame->ReplaceMisspelledRange(word);
 }
 
-void WebFrameWidgetBase::SelectRange(const gfx::Point& base,
-                                     const gfx::Point& extent) {
+void WebFrameWidgetBase::SelectRange(const gfx::Point& base_in_dips,
+                                     const gfx::Point& extent_in_dips) {
   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
   if (!focused_frame)
     return;
-  focused_frame->SelectRange(Client()->ConvertWindowPointToViewport(base),
-                             Client()->ConvertWindowPointToViewport(extent));
+  focused_frame->SelectRange(widget_base_->DIPsToBlinkSpace(base_in_dips),
+                             widget_base_->DIPsToBlinkSpace(extent_in_dips));
 }
 
 void WebFrameWidgetBase::AdjustSelectionByCharacterOffset(
@@ -2097,16 +2094,17 @@ void WebFrameWidgetBase::AdjustSelectionByCharacterOffset(
                              selection_menu_behavior);
 }
 
-void WebFrameWidgetBase::MoveRangeSelectionExtent(const gfx::Point& extent) {
+void WebFrameWidgetBase::MoveRangeSelectionExtent(
+    const gfx::Point& extent_in_dips) {
   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
   if (!focused_frame)
     return;
   focused_frame->MoveRangeSelectionExtent(
-      Client()->ConvertWindowPointToViewport(extent));
+      widget_base_->DIPsToBlinkSpace(extent_in_dips));
 }
 
 void WebFrameWidgetBase::ScrollFocusedEditableNodeIntoRect(
-    const gfx::Rect& rect) {
+    const gfx::Rect& rect_in_dips) {
   WebLocalFrame* local_frame = FocusedWebLocalFrameInWidget();
   if (!local_frame)
     return;
@@ -2116,15 +2114,15 @@ void WebFrameWidgetBase::ScrollFocusedEditableNodeIntoRect(
   // DidChangeVisibleViewport to ensure that we don't assume the element
   // is already in view and ignore the scroll.
   local_frame->Client()->ResetHasScrolledFocusedEditableIntoView();
-  local_frame->Client()->ScrollFocusedEditableElementIntoRect(rect);
+  local_frame->Client()->ScrollFocusedEditableElementIntoRect(rect_in_dips);
 }
 
-void WebFrameWidgetBase::MoveCaret(const gfx::Point& point) {
+void WebFrameWidgetBase::MoveCaret(const gfx::Point& point_in_dips) {
   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
   if (!focused_frame)
     return;
   focused_frame->MoveCaretSelection(
-      Client()->ConvertWindowPointToViewport(point));
+      widget_base_->DIPsToBlinkSpace(point_in_dips));
 }
 
 #if defined(OS_ANDROID)

third_party/blink/renderer/core/frame/web_frame_widget_base.h

@@ -150,7 +150,7 @@ class CORE_EXPORT WebFrameWidgetBase
                                 WebInputEvent::Type injected_type) override;
   void DidChangeCursor(const ui::Cursor&) override;
   void GetCompositionCharacterBoundsInWindow(
-      Vector<gfx::Rect>* bounds) override;
+      Vector<gfx::Rect>* bounds_in_dips) override;
   gfx::Range CompositionRange() override;
   WebTextInputInfo TextInputInfo() override;
   ui::mojom::VirtualKeyboardVisibilityRequest
@@ -179,7 +179,8 @@ class CORE_EXPORT WebFrameWidgetBase
                   int relative_cursor_pos) override;
   void FinishComposingText(bool keep_selection) override;
   bool IsProvisional() override;
-  uint64_t GetScrollableContainerIdAt(const gfx::PointF& point) override;
+  uint64_t GetScrollableContainerIdAt(
+      const gfx::PointF& point_in_dips) override;
   void SetEditCommandsForNextKeyEvent(
       Vector<mojom::blink::EditCommandPtr> edit_commands) override;
 
@@ -214,14 +215,16 @@ class CORE_EXPORT WebFrameWidgetBase
   void CollapseSelection() override;
   void Replace(const String& word) override;
   void ReplaceMisspelling(const String& word) override;
-  void SelectRange(const gfx::Point& base, const gfx::Point& extent) override;
+  void SelectRange(const gfx::Point& base_in_dips,
+                   const gfx::Point& extent_in_dips) override;
   void AdjustSelectionByCharacterOffset(
       int32_t start,
       int32_t end,
       mojom::blink::SelectionMenuBehavior behavior) override;
-  void MoveRangeSelectionExtent(const gfx::Point& extent) override;
-  void ScrollFocusedEditableNodeIntoRect(const gfx::Rect& rect) override;
-  void MoveCaret(const gfx::Point& point) override;
+  void MoveRangeSelectionExtent(const gfx::Point& extent_in_dips) override;
+  void ScrollFocusedEditableNodeIntoRect(
+      const gfx::Rect& rect_in_dips) override;
+  void MoveCaret(const gfx::Point& point_in_dips) override;
 #if defined(OS_ANDROID)
   void SelectWordAroundCaret(SelectWordAroundCaretCallback callback) override;
 #endif

third_party/blink/renderer/platform/widget/frame_widget.h

@@ -121,7 +121,7 @@ class PLATFORM_EXPORT FrameWidget
 
   // Return the composition character in window coordinates.
   virtual void GetCompositionCharacterBoundsInWindow(
-      Vector<gfx::Rect>* bounds) = 0;
+      Vector<gfx::Rect>* bounds_in_dips) = 0;
 
   virtual gfx::Range CompositionRange() = 0;
   // Returns ime_text_spans and corresponding window coordinates for the list
@@ -170,7 +170,8 @@ class PLATFORM_EXPORT FrameWidget
   virtual void FinishComposingText(bool keep_selection) = 0;
 
   virtual bool IsProvisional() = 0;
-  virtual uint64_t GetScrollableContainerIdAt(const gfx::PointF& point) = 0;
+  virtual uint64_t GetScrollableContainerIdAt(
+      const gfx::PointF& point_in_dips) = 0;
 
   virtual bool ShouldHandleImeEvents() { return false; }
 

third_party/blink/renderer/platform/widget/widget_base.cc

@@ -1259,6 +1259,14 @@ gfx::PointF WidgetBase::DIPsToBlinkSpace(const gfx::PointF& point) {
       client_->GetOriginalScreenInfo().device_scale_factor, point);
 }
 
+gfx::Point WidgetBase::DIPsToBlinkSpace(const gfx::Point& point) {
+  if (!use_zoom_for_dsf_)
+    return point;
+  // TODO(danakj): Should this be GetScreenInfo() so it changes under emulation?
+  return gfx::ScaleToRoundedPoint(
+      point, client_->GetOriginalScreenInfo().device_scale_factor);
+}
+
 gfx::PointF WidgetBase::BlinkSpaceToDIPs(const gfx::PointF& point) {
   if (!use_zoom_for_dsf_)
     return point;
@@ -1266,6 +1274,15 @@ gfx::PointF WidgetBase::BlinkSpaceToDIPs(const gfx::PointF& point) {
       client_->GetOriginalScreenInfo().device_scale_factor, point);
 }
 
+gfx::Point WidgetBase::BlinkSpaceToDIPs(const gfx::Point& point) {
+  if (!use_zoom_for_dsf_)
+    return point;
+  // TODO(danakj): Should this be GetScreenInfo() so it changes under emulation?
+  // TODO(dtapuska): Determine if this should be a floor vs rounded.
+  return gfx::ScaleToFlooredPoint(
+      point, client_->GetOriginalScreenInfo().device_scale_factor);
+}
+
 gfx::Size WidgetBase::DIPsToBlinkSpace(const gfx::Size& size) {
   if (!use_zoom_for_dsf_)
     return size;
@@ -1280,4 +1297,11 @@ gfx::Size WidgetBase::BlinkSpaceToDIPs(const gfx::Size& size) {
   return gfx::ScaleToCeiledSize(size, reverse);
 }
 
+gfx::Rect WidgetBase::BlinkSpaceToDIPs(const gfx::Rect& rect) {
+  if (!use_zoom_for_dsf_)
+    return rect;
+  float reverse = 1 / client_->GetOriginalScreenInfo().device_scale_factor;
+  return gfx::ScaleToEnclosedRect(rect, reverse);
+}
+
 }  // namespace blink

third_party/blink/renderer/platform/widget/widget_base.h

@@ -270,18 +270,15 @@ class PLATFORM_EXPORT WidgetBase : public mojom::blink::Widget,
   // Converts from DIPs to Blink coordinate space (ie. Viewport/Physical
   // pixels).
   gfx::PointF DIPsToBlinkSpace(const gfx::PointF& point);
-
-  // Converts from Blink coordinate space (ie. Viewport/Physical pixels) to
-  // DIPS.
-  gfx::PointF BlinkSpaceToDIPs(const gfx::PointF& point);
-
-  // Converts from DIPs to Blink coordinate space (ie. Viewport/Physical
-  // pixels).
+  gfx::Point DIPsToBlinkSpace(const gfx::Point& point);
   gfx::Size DIPsToBlinkSpace(const gfx::Size& size);
 
-  // Converts from Blink coordinate space (ie. Viewport/Physical pixels) to
+  // Converts from Blink coordinate (ie. Viewport/Physical pixels) space to
   // DIPs.
+  gfx::PointF BlinkSpaceToDIPs(const gfx::PointF& point);
+  gfx::Point BlinkSpaceToDIPs(const gfx::Point& point);
   gfx::Size BlinkSpaceToDIPs(const gfx::Size& size);
+  gfx::Rect BlinkSpaceToDIPs(const gfx::Rect& rect);
 
   // Returns whether Zoom for DSF is enabled for the widget.
   bool UseZoomForDsf() { return use_zoom_for_dsf_; }