Move drag related functionality out of LocalFrame

third_party/WebKit/Source/core/clipboard/DataTransfer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/clipboard/DataTransfer.h"
 
+#include <memory>
 #include "core/HTMLNames.h"
 #include "core/clipboard/DataObject.h"
 #include "core/clipboard/DataTransferItem.h"
 #include "core/clipboard/DataTransferItemList.h"
 #include "core/editing/EphemeralRange.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/serializers/Serialization.h"
 #include "core/fileapi/FileList.h"
 #include "core/frame/LocalFrame.h"
+#include "core/frame/VisualViewport.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/TextControlElement.h"
 #include "core/layout/LayoutImage.h"
 #include "core/layout/LayoutObject.h"
 #include "core/loader/resource/ImageResourceContent.h"
+#include "core/page/ChromeClient.h"
+#include "core/page/Page.h"
+#include "core/paint/PaintInfo.h"
+#include "core/paint/PaintLayer.h"
+#include "core/paint/PaintLayerPainter.h"
 #include "platform/DragImage.h"
 #include "platform/clipboard/ClipboardMimeTypes.h"
 #include "platform/clipboard/ClipboardUtilities.h"
+#include "platform/graphics/StaticBitmapImage.h"
+#include "platform/graphics/paint/PaintRecordBuilder.h"
 #include "platform/network/mime/MIMETypeRegistry.h"
-#include <memory>
+#include "public/platform/WebScreenInfo.h"
+#include "third_party/skia/include/core/SkSurface.h"
 
 namespace blink {
 
+namespace {
+
+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())
+#endif
+  {
+    for (Node& descendant : NodeTraversal::InclusiveDescendantsOf(*node_))
+      descendant.SetDragged(true);
+  }
+
+  ~DraggedNodeImageBuilder() {
+#if DCHECK_IS_ON()
+    DCHECK_EQ(dom_tree_version_, node_->GetDocument().DomTreeVersion());
+#endif
+    for (Node& descendant : NodeTraversal::InclusiveDescendantsOf(*node_))
+      descendant.SetDragged(false);
+  }
+
+  std::unique_ptr<DragImage> CreateImage() {
+#if DCHECK_IS_ON()
+    DCHECK_EQ(dom_tree_version_, node_->GetDocument().DomTreeVersion());
+#endif
+    // Construct layout object for |m_node| with pseudo class "-webkit-drag"
+    local_frame_->View()->UpdateAllLifecyclePhasesExceptPaint();
+    LayoutObject* const dragged_layout_object = node_->GetLayoutObject();
+    if (!dragged_layout_object)
+      return nullptr;
+    // Paint starting at the nearest stacking context, clipped to the object
+    // itself. This will also paint the contents behind the object if the
+    // object contains transparency and there are other elements in the same
+    // stacking context which stacked below.
+    PaintLayer* layer = dragged_layout_object->EnclosingLayer();
+    if (!layer->StackingNode()->IsStackingContext())
+      layer = layer->StackingNode()->AncestorStackingContextNode()->Layer();
+    IntRect absolute_bounding_box =
+        dragged_layout_object->AbsoluteBoundingBoxRectIncludingDescendants();
+    FloatRect bounding_box =
+        layer->GetLayoutObject()
+            .AbsoluteToLocalQuad(FloatQuad(absolute_bounding_box),
+                                 kUseTransforms)
+            .BoundingBox();
+    PaintLayerPaintingInfo painting_info(layer, LayoutRect(bounding_box),
+                                         kGlobalPaintFlattenCompositingLayers,
+                                         LayoutSize());
+    PaintLayerFlags flags = kPaintLayerHaveTransparency |
+                            kPaintLayerAppliedTransform |
+                            kPaintLayerUncachedClipRects;
+    PaintRecordBuilder builder(
+        DataTransfer::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 DataTransfer::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_;
+#endif
+};
+}
+
 static DragOperation ConvertEffectAllowedToDragOperation(const String& op) {
   // Values specified in
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/dnd.html#dom-datatransfer-effectallowed
   if (op == "uninitialized")
     return kDragOperationEvery;
   if (op == "none")
     return kDragOperationNone;
   if (op == "copy")
     return kDragOperationCopy;
   if (op == "link")
@@ skipping 59 matching lines @@
 }
 
 DataTransfer* DataTransfer::Create(DataTransferType type,
                                    DataTransferAccessPolicy policy,
                                    DataObject* data_object) {
   return new DataTransfer(type, policy, data_object);
 }
 
 DataTransfer::~DataTransfer() {}
 
+// Converts from bounds in CSS space to device space based on the given
+// frame.
+FloatRect DataTransfer::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.
+std::unique_ptr<DragImage> DataTransfer::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);
+
+  AffineTransform transform;
+  transform.Scale(device_scale_factor * page_scale_factor);
+  transform.Translate(-device_bounds.X(), -device_bounds.Y());
+
+  // Rasterize upfront, since DragImage::create() is going to do it anyway
+  // (SkImage::asLegacyBitmap).
+  SkSurfaceProps surface_props(0, kUnknown_SkPixelGeometry);
+  sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(
+      device_bounds.Width(), device_bounds.Height(), &surface_props);
+  if (!surface)
+    return nullptr;
+
+  SkiaPaintCanvas skia_paint_canvas(surface->getCanvas());
+  skia_paint_canvas.concat(AffineTransformToSkMatrix(transform));
+  builder.EndRecording(skia_paint_canvas, property_tree_state);
+
+  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);
+}
+
 void DataTransfer::setDropEffect(const String& effect) {
   if (!IsForDragAndDrop())
     return;
 
   // The attribute must ignore any attempts to set it to a value other than
   // none, copy, link, and move.
   if (effect != "none" && effect != "copy" && effect != "link" &&
       effect != "move")
     return;
 
@@ skipping 109 matching lines @@
 
 void DataTransfer::SetDragImageResource(ImageResourceContent* img,
                                         const IntPoint& loc) {
   setDragImage(img, 0, loc);
 }
 
 void DataTransfer::SetDragImageElement(Node* node, const IntPoint& loc) {
   setDragImage(0, node, loc);
 }
 
+std::unique_ptr<DragImage> DataTransfer::NodeImage(const LocalFrame& frame,
+                                                   Node& node) {
+  DraggedNodeImageBuilder image_node(frame, node);
+  return image_node.CreateImage();
+}
+
 std::unique_ptr<DragImage> DataTransfer::CreateDragImage(
     IntPoint& loc,
     LocalFrame* frame) const {
   if (drag_image_element_) {
     loc = drag_loc_;
 
-    return frame->NodeImage(*drag_image_element_);
+    return NodeImage(*frame, *drag_image_element_);
   }
   if (drag_image_) {
     loc = drag_loc_;
     return DragImage::Create(drag_image_->GetImage());
   }
   return nullptr;
 }
 
 static ImageResourceContent* GetImageResourceContent(Element* element) {
   // Attempt to pull ImageResourceContent from element
@@ skipping 223 matching lines @@
   }
 }
 
 DEFINE_TRACE(DataTransfer) {
   visitor->Trace(data_object_);
   visitor->Trace(drag_image_);
   visitor->Trace(drag_image_element_);
 }
 
 }  // namespace blink