Rename CreateDragImage to CreateDragImageForFrame to avoid name conflicts

third_party/WebKit/Source/core/frame/LocalFrame.cpp

 /*
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  *                     1999 Lars Knoll <knoll@kde.org>
  *                     1999 Antti Koivisto <koivisto@kde.org>
  *                     2000 Simon Hausmann <hausmann@kde.org>
  *                     2000 Stefan Schimanski <1Stein@gmx.de>
  *                     2001 George Staikos <staikos@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2005 Alexey Proskuryakov <ap@nypop.com>
@@ skipping 99 matching lines @@
 #include "third_party/skia/include/core/SkSurface.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 namespace {
 
 // Converts from bounds in CSS space to device space based on the given
 // frame.
+// TODO(tanvir.rizvi): DeviceSpaceBounds is used for drag related functionality
+// and is irrelevant to core functionality of LocalFrame. This should be moved
+// out of LocalFrame to appropriate place.
 static FloatRect DeviceSpaceBounds(const FloatRect css_bounds,
                                    const LocalFrame& frame) {
   float device_scale_factor = frame.GetPage()->DeviceScaleFactorDeprecated();
   float page_scale_factor = frame.GetPage()->GetVisualViewport().Scale();
   FloatRect device_bounds(css_bounds);
   device_bounds.SetWidth(css_bounds.Width() * device_scale_factor *
                          page_scale_factor);
   device_bounds.SetHeight(css_bounds.Height() * device_scale_factor *
                           page_scale_factor);
   return device_bounds;
 }
 
 // Returns a DragImage whose bitmap contains |contents|, positioned and scaled
 // in device space.
-static std::unique_ptr<DragImage> CreateDragImage(
+// TODO(tanvir.rizvi): CreateDragImageForFrame is used for drag related
+// functionality and is irrelevant to core functionality of LocalFrame. This
+// should be moved out of LocalFrame to appropriate place.
+static std::unique_ptr<DragImage> CreateDragImageForFrame(
     const LocalFrame& frame,
     float opacity,
     RespectImageOrientationEnum image_orientation,
     const FloatRect& css_bounds,
     PaintRecordBuilder& builder,
     const PropertyTreeState& property_tree_state) {
   float device_scale_factor = frame.GetPage()->DeviceScaleFactorDeprecated();
   float page_scale_factor = frame.GetPage()->GetVisualViewport().Scale();
 
   FloatRect device_bounds = DeviceSpaceBounds(css_bounds, frame);
@@ skipping 16 matching lines @@
 
   RefPtr<Image> image = StaticBitmapImage::Create(surface->makeImageSnapshot());
   float screen_device_scale_factor =
       frame.GetPage()->GetChromeClient().GetScreenInfo().device_scale_factor;
 
   return DragImage::Create(image.Get(), image_orientation,
                            screen_device_scale_factor, kInterpolationHigh,
                            opacity);
 }
 
+// TODO(tanvir.rizvi): DraggedNodeImageBuilder is used for drag related
+// functionality and is irrelevant to core functionality of LocalFrame. This
+// should be moved out of LocalFrame to appropriate place.
 class DraggedNodeImageBuilder {
   STACK_ALLOCATED();
 
  public:
   DraggedNodeImageBuilder(const LocalFrame& local_frame, Node& node)
       : local_frame_(&local_frame),
         node_(&node)
 #if DCHECK_IS_ON()
         ,
         dom_tree_version_(node.GetDocument().DomTreeVersion())
@@ skipping 40 matching lines @@
     PaintLayerFlags flags = kPaintLayerHaveTransparency |
                             kPaintLayerAppliedTransform |
                             kPaintLayerUncachedClipRects;
     PaintRecordBuilder builder(DeviceSpaceBounds(bounding_box, *local_frame_));
     PaintLayerPainter(*layer).Paint(builder.Context(), painting_info, flags);
     PropertyTreeState border_box_properties = PropertyTreeState::Root();
     if (RuntimeEnabledFeatures::SlimmingPaintV2Enabled()) {
       border_box_properties =
           *layer->GetLayoutObject().LocalBorderBoxProperties();
     }
-    return CreateDragImage(
+    return CreateDragImageForFrame(
         *local_frame_, 1.0f,
         LayoutObject::ShouldRespectImageOrientation(dragged_layout_object),
         bounding_box, builder, border_box_properties);
   }
 
  private:
   const Member<const LocalFrame> local_frame_;
   const Member<Node> node_;
 #if DCHECK_IS_ON()
   const uint64_t dom_tree_version_;
@@ skipping 500 matching lines @@
 
 double LocalFrame::DevicePixelRatio() const {
   if (!page_)
     return 0;
 
   double ratio = page_->DeviceScaleFactorDeprecated();
   ratio *= PageZoomFactor();
   return ratio;
 }
 
+// TODO(tanvir.rizvi): NodeImage is used only by DataTransfer,
+// and is irrelevant to LocalFrame core functionality, so it can be moved to
+// DataTransfer.
 std::unique_ptr<DragImage> LocalFrame::NodeImage(Node& node) {
   DraggedNodeImageBuilder image_node(*this, node);
   return image_node.CreateImage();
 }
 
+// TODO(tanvir.rizvi): DragImageForSelection is used only by DragController,
+// and is irrelevant to LocalFrame core functionality, so it can be moved to
+// DragController.
 std::unique_ptr<DragImage> LocalFrame::DragImageForSelection(float opacity) {
   if (!Selection().ComputeVisibleSelectionInDOMTreeDeprecated().IsRange())
     return nullptr;
 
   view_->UpdateAllLifecyclePhasesExceptPaint();
   DCHECK(GetDocument()->IsActive());
 
   FloatRect painting_rect = FloatRect(Selection().Bounds());
   GlobalPaintFlags paint_flags =
       kGlobalPaintSelectionOnly | kGlobalPaintFlattenCompositingLayers;
 
   PaintRecordBuilder builder(DeviceSpaceBounds(painting_rect, *this));
   view_->PaintContents(builder.Context(), paint_flags,
                        EnclosingIntRect(painting_rect));
-  return CreateDragImage(*this, opacity, kDoNotRespectImageOrientation,
-                         painting_rect, builder, PropertyTreeState::Root());
+  return CreateDragImageForFrame(*this, opacity, kDoNotRespectImageOrientation,
+                                 painting_rect, builder,
+                                 PropertyTreeState::Root());
 }
 
 String LocalFrame::SelectedText() const {
   return Selection().SelectedText();
 }
 
 String LocalFrame::SelectedTextForClipboard() const {
   if (!GetDocument())
     return g_empty_string;
   DCHECK(!GetDocument()->NeedsLayoutTreeUpdate());
@@ skipping 434 matching lines @@
 void LocalFrame::SetViewportIntersectionFromParent(
     const IntRect& viewport_intersection) {
   if (remote_viewport_intersection_ != viewport_intersection) {
     remote_viewport_intersection_ = viewport_intersection;
     if (View())
       View()->ScheduleAnimation();
   }
 }
 
 }  // namespace blink