Revert "Remove a few conversion methods on WebWidgetClient."

This reverts commit 08741021.

Reason for revert: Breaks TabSearch on Mac. See http://crbug.com/1131162 .

Original change's description:
> 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/+/2419129
> Reviewed-by: danakj <danakj@chromium.org>
> Commit-Queue: Dave Tapuska <dtapuska@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#809421}

TBR=danakj@chromium.org,dtapuska@chromium.org

Change-Id: I4a5f560c73177acfa6d01464bc37eade2a87af62
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: 1097816, 1131162
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2424494Reviewed-by: Robert Liao <robliao@chromium.org>
Commit-Queue: Robert Liao <robliao@chromium.org>
Cr-Commit-Position: refs/heads/master@{#809488}

content/renderer/render_widget.cc

@@ -714,6 +714,17 @@ 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,6 +216,8 @@ 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,6 +59,7 @@ class SkBitmap;
 
 namespace gfx {
 class Point;
+class PointF;
 }
 
 namespace ui {
@@ -155,6 +156,12 @@ 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,10 +489,11 @@ void WebFrameWidgetBase::StartDragging(const WebDragData& drag_data,
     return;
   }
 
-  gfx::Point offset_in_dips = widget_base_->BlinkSpaceToDIPs(drag_image_offset);
+  WebRect offset_in_window(drag_image_offset.x(), drag_image_offset.y(), 0, 0);
+  Client()->ConvertViewportToWindow(&offset_in_window);
   GetAssociatedFrameWidgetHost()->StartDragging(
       drag_data, operations_allowed, drag_image,
-      gfx::Vector2d(offset_in_dips.x(), offset_in_dips.y()),
+      gfx::Vector2d(offset_in_window.x, offset_in_window.y),
       possible_drag_event_info_.Clone());
 }
 
@@ -1559,11 +1560,11 @@ void WebFrameWidgetBase::GetEditContextBoundsInWindow(
   WebRect control_bounds;
   WebRect selection_bounds;
   controller->GetLayoutBounds(&control_bounds, &selection_bounds);
-  *edit_context_control_bounds =
-      widget_base_->BlinkSpaceToDIPs(gfx::Rect(control_bounds));
+  client_->ConvertViewportToWindow(&control_bounds);
+  edit_context_control_bounds->emplace(control_bounds);
   if (controller->IsEditContextActive()) {
-    *edit_context_selection_bounds =
-        widget_base_->BlinkSpaceToDIPs(gfx::Rect(selection_bounds));
+    client_->ConvertViewportToWindow(&selection_bounds);
+    edit_context_selection_bounds->emplace(selection_bounds);
   }
 }
 
@@ -1604,16 +1605,15 @@ bool WebFrameWidgetBase::GetSelectionBoundsInWindow(
   WebRect focus_webrect;
   WebRect anchor_webrect;
   SelectionBounds(focus_webrect, 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));
+  client_->ConvertViewportToWindow(&focus_webrect);
+  client_->ConvertViewportToWindow(&anchor_webrect);
 
   // if the bounds are the same return false.
-  if (focus_rect_in_dips == *focus && anchor_rect_in_dips == *anchor)
+  if (gfx::Rect(focus_webrect) == *focus &&
+      gfx::Rect(anchor_webrect) == *anchor)
     return false;
-  *focus = focus_rect_in_dips;
-  *anchor = anchor_rect_in_dips;
+  *focus = gfx::Rect(focus_webrect);
+  *anchor = gfx::Rect(anchor_webrect);
 
   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
   if (!focused_frame)
@@ -1759,9 +1759,9 @@ bool WebFrameWidgetBase::IsProvisional() {
 }
 
 uint64_t WebFrameWidgetBase::GetScrollableContainerIdAt(
-    const gfx::PointF& point_in_dips) {
-  gfx::PointF point = widget_base_->DIPsToBlinkSpace(point_in_dips);
-  return HitTestResultAt(point).GetScrollableContainerId();
+    const gfx::PointF& point) {
+  gfx::PointF point_in_pixel = Client()->ConvertWindowPointToViewport(point);
+  return HitTestResultAt(point_in_pixel).GetScrollableContainerId();
 }
 
 void WebFrameWidgetBase::SetEditCommandsForNextKeyEvent(
@@ -1860,7 +1860,7 @@ gfx::Range WebFrameWidgetBase::CompositionRange() {
 }
 
 void WebFrameWidgetBase::GetCompositionCharacterBoundsInWindow(
-    Vector<gfx::Rect>* bounds_in_dips) {
+    Vector<gfx::Rect>* bounds) {
   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
   if (!focused_frame)
     return;
@@ -1870,11 +1870,13 @@ void WebFrameWidgetBase::GetCompositionCharacterBoundsInWindow(
   if (!controller->GetCompositionCharacterBounds(bounds_from_blink))
     return;
 
-  for (auto& rect : bounds_from_blink) {
-    bounds_in_dips->push_back(widget_base_->BlinkSpaceToDIPs(gfx::Rect(rect)));
+  for (size_t i = 0; i < bounds_from_blink.size(); ++i) {
+    Client()->ConvertViewportToWindow(&bounds_from_blink[i]);
+    bounds->push_back(bounds_from_blink[i]);
   }
 }
 
+
 void WebFrameWidgetBase::AddImeTextSpansToExistingText(
     uint32_t start,
     uint32_t end,
@@ -1899,9 +1901,10 @@ 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, widget_base_->BlinkSpaceToDIPs(gfx::Rect(webrect))));
+        ime_text_span, gfx::Rect(webrect)));
   }
   return ime_text_spans_info;
 }
@@ -2060,13 +2063,13 @@ void WebFrameWidgetBase::ReplaceMisspelling(const String& word) {
   focused_frame->ReplaceMisspelledRange(word);
 }
 
-void WebFrameWidgetBase::SelectRange(const gfx::Point& base_in_dips,
-                                     const gfx::Point& extent_in_dips) {
+void WebFrameWidgetBase::SelectRange(const gfx::Point& base,
+                                     const gfx::Point& extent) {
   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
   if (!focused_frame)
     return;
-  focused_frame->SelectRange(widget_base_->DIPsToBlinkSpace(base_in_dips),
-                             widget_base_->DIPsToBlinkSpace(extent_in_dips));
+  focused_frame->SelectRange(Client()->ConvertWindowPointToViewport(base),
+                             Client()->ConvertWindowPointToViewport(extent));
 }
 
 void WebFrameWidgetBase::AdjustSelectionByCharacterOffset(
@@ -2094,17 +2097,16 @@ void WebFrameWidgetBase::AdjustSelectionByCharacterOffset(
                              selection_menu_behavior);
 }
 
-void WebFrameWidgetBase::MoveRangeSelectionExtent(
-    const gfx::Point& extent_in_dips) {
+void WebFrameWidgetBase::MoveRangeSelectionExtent(const gfx::Point& extent) {
   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
   if (!focused_frame)
     return;
   focused_frame->MoveRangeSelectionExtent(
-      widget_base_->DIPsToBlinkSpace(extent_in_dips));
+      Client()->ConvertWindowPointToViewport(extent));
 }
 
 void WebFrameWidgetBase::ScrollFocusedEditableNodeIntoRect(
-    const gfx::Rect& rect_in_dips) {
+    const gfx::Rect& rect) {
   WebLocalFrame* local_frame = FocusedWebLocalFrameInWidget();
   if (!local_frame)
     return;
@@ -2114,15 +2116,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_in_dips);
+  local_frame->Client()->ScrollFocusedEditableElementIntoRect(rect);
 }
 
-void WebFrameWidgetBase::MoveCaret(const gfx::Point& point_in_dips) {
+void WebFrameWidgetBase::MoveCaret(const gfx::Point& point) {
   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
   if (!focused_frame)
     return;
   focused_frame->MoveCaretSelection(
-      widget_base_->DIPsToBlinkSpace(point_in_dips));
+      Client()->ConvertWindowPointToViewport(point));
 }
 
 #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_in_dips) override;
+      Vector<gfx::Rect>* bounds) override;
   gfx::Range CompositionRange() override;
   WebTextInputInfo TextInputInfo() override;
   ui::mojom::VirtualKeyboardVisibilityRequest
@@ -179,8 +179,7 @@ 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_in_dips) override;
+  uint64_t GetScrollableContainerIdAt(const gfx::PointF& point) override;
   void SetEditCommandsForNextKeyEvent(
       Vector<mojom::blink::EditCommandPtr> edit_commands) override;
 
@@ -215,16 +214,14 @@ 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_in_dips,
-                   const gfx::Point& extent_in_dips) override;
+  void SelectRange(const gfx::Point& base, const gfx::Point& extent) override;
   void AdjustSelectionByCharacterOffset(
       int32_t start,
       int32_t end,
       mojom::blink::SelectionMenuBehavior behavior) 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;
+  void MoveRangeSelectionExtent(const gfx::Point& extent) override;
+  void ScrollFocusedEditableNodeIntoRect(const gfx::Rect& rect) override;
+  void MoveCaret(const gfx::Point& point) 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_in_dips) = 0;
+      Vector<gfx::Rect>* bounds) = 0;
 
   virtual gfx::Range CompositionRange() = 0;
   // Returns ime_text_spans and corresponding window coordinates for the list
@@ -170,8 +170,7 @@ class PLATFORM_EXPORT FrameWidget
   virtual void FinishComposingText(bool keep_selection) = 0;
 
   virtual bool IsProvisional() = 0;
-  virtual uint64_t GetScrollableContainerIdAt(
-      const gfx::PointF& point_in_dips) = 0;
+  virtual uint64_t GetScrollableContainerIdAt(const gfx::PointF& point) = 0;
 
   virtual bool ShouldHandleImeEvents() { return false; }
 

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

@@ -1259,14 +1259,6 @@ 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;
@@ -1274,15 +1266,6 @@ 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;
@@ -1297,11 +1280,4 @@ 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,15 +270,18 @@ 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);
-  gfx::Point DIPsToBlinkSpace(const gfx::Point& 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::Size DIPsToBlinkSpace(const gfx::Size& size);
 
-  // Converts from Blink coordinate (ie. Viewport/Physical pixels) space to
+  // Converts from Blink coordinate space (ie. Viewport/Physical pixels) 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_; }