content: Rename virtual method on RenderView to not (ab)use blink style

content/renderer/render_view_impl.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_view_impl.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/auto_reset.h"
@@ skipping 1940 matching lines @@
   focus_url_ = GURL(url);
   UpdateTargetURL(focus_url_, mouse_over_url_);
 }
 
 void RenderViewImpl::startDragging(WebLocalFrame* frame,
                                    const WebDragData& data,
                                    WebDragOperationsMask mask,
                                    const WebImage& image,
                                    const WebPoint& webImageOffset) {
   blink::WebRect offset_in_window(webImageOffset.x, webImageOffset.y, 0, 0);
-  convertViewportToWindow(&offset_in_window);
+  ConvertViewportToWindowViaWidget(&offset_in_window);
   DropData drop_data(DropDataBuilder::Build(data));
   drop_data.referrer_policy = frame->document().referrerPolicy();
   gfx::Vector2d imageOffset(offset_in_window.x, offset_in_window.y);
   Send(new DragHostMsg_StartDragging(routing_id(), drop_data, mask,
                                      image.getSkBitmap(), imageOffset,
                                      possible_drag_event_info_));
 }
 
 bool RenderViewImpl::acceptsLoadDrops() {
   return renderer_preferences_.can_accept_load_drops;
@@ skipping 10 matching lines @@
 // TODO(esprehn): Blink only ever passes Elements, this should take WebElement.
 void RenderViewImpl::focusedNodeChanged(const WebNode& fromNode,
                                         const WebNode& toNode) {
   has_scrolled_focused_editable_node_into_rect_ = false;
 
   gfx::Rect node_bounds;
   bool is_editable = false;
   if (!toNode.isNull() && toNode.isElementNode()) {
     WebElement element = const_cast<WebNode&>(toNode).to<WebElement>();
     blink::WebRect rect = element.boundsInViewport();
-    convertViewportToWindow(&rect);
+    ConvertViewportToWindowViaWidget(&rect);
     node_bounds = gfx::Rect(rect);
     is_editable = element.isEditable();
   }
   Send(new ViewHostMsg_FocusedNodeChanged(routing_id(), is_editable,
                                           node_bounds));
 
   // TODO(estade): remove.
   FOR_EACH_OBSERVER(RenderViewObserver, observers_, FocusedNodeChanged(toNode));
 
   RenderFrameImpl* previous_frame = nullptr;
@@ skipping 177 matching lines @@
 
   SSLStatus result;
   CHECK(DeserializeSecurityInfo(security_info, &result));
   return result;
 }
 
 const std::string& RenderViewImpl::GetAcceptLanguages() const {
   return renderer_preferences_.accept_languages;
 }
 
-void RenderViewImpl::convertViewportToWindow(blink::WebRect* rect) {
-  RenderWidget::convertViewportToWindow(rect);
+void RenderViewImpl::ConvertViewportToWindowViaWidget(blink::WebRect* rect) {
+  convertViewportToWindow(rect);

[danakj, 2016/03/09 23:17:24]

In future, this could be GetWidget()->convert...() if this class stops
inheriting from RenderWidget.

 }
 
 gfx::RectF RenderViewImpl::ElementBoundsInWindow(
     const blink::WebElement& element) {
   blink::WebRect bounding_box_in_window = element.boundsInViewport();
-  convertViewportToWindow(&bounding_box_in_window);
+  ConvertViewportToWindowViaWidget(&bounding_box_in_window);
   return gfx::RectF(bounding_box_in_window);
 }
 
 float RenderViewImpl::GetDeviceScaleFactorForTest() const {
   return device_scale_factor_;
 }
 
 gfx::Point RenderViewImpl::ConvertWindowPointToViewport(
     const gfx::Point& point) {
   blink::WebFloatRect point_in_viewport(point.x(), point.y(), 0, 0);
@@ skipping 861 matching lines @@
 }
 
 void RenderViewImpl::GetSelectionBounds(gfx::Rect* start, gfx::Rect* end) {
 #if defined(ENABLE_PLUGINS)
   if (focused_pepper_plugin_) {
     // TODO(kinaba) http://crbug.com/101101
     // Current Pepper IME API does not handle selection bounds. So we simply
     // use the caret position as an empty range for now. It will be updated
     // after Pepper API equips features related to surrounding text retrieval.
     blink::WebRect caret(focused_pepper_plugin_->GetCaretBounds());
-    convertViewportToWindow(&caret);
+    ConvertViewportToWindowViaWidget(&caret);
     *start = caret;
     *end = caret;
     return;
   }
 #endif
   RenderWidget::GetSelectionBounds(start, end);
 }
 
 void RenderViewImpl::GetCompositionCharacterBounds(
     std::vector<gfx::Rect>* bounds_in_window) {
@@ skipping 20 matching lines @@
     return;
 
   bounds_in_window->reserve(character_count);
   blink::WebRect webrect;
   for (size_t i = 0; i < character_count; ++i) {
     if (!frame->firstRectForCharacterRange(start_offset + i, 1, webrect)) {
       DLOG(ERROR) << "Could not retrieve character rectangle at " << i;
       bounds_in_window->clear();
       return;
     }
-    convertViewportToWindow(&webrect);
+    ConvertViewportToWindowViaWidget(&webrect);
     bounds_in_window->push_back(webrect);
   }
 }
 
 void RenderViewImpl::GetCompositionRange(gfx::Range* range) {
 #if defined(ENABLE_PLUGINS)
   if (focused_pepper_plugin_) {
     return;
   }
 #endif
@@ skipping 409 matching lines @@
   if (IsUseZoomForDSFEnabled()) {
     webview()->setZoomFactorForDeviceScaleFactor(device_scale_factor_);
   } else {
     webview()->setDeviceScaleFactor(device_scale_factor_);
   }
   webview()->settings()->setPreferCompositingToLCDTextEnabled(
       PreferCompositingToLCDText(compositor_deps_, device_scale_factor_));
 }
 
 }  // namespace content