Make LocalFrame::nodeImage() to take an image for the element with :-webkit-drag pseudo class

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>
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
@@ skipping 85 matching lines @@
 
 namespace {
 
 // Convenience class for initializing a GraphicsContext to build a DragImage from a specific
 // region specified by |bounds|. After painting the using context(), the DragImage returned from
 // createImage() will only contain the content in |bounds| with the appropriate device scale
 // factor included.
 class DragImageBuilder {
     STACK_ALLOCATED();
 public:
-    DragImageBuilder(const LocalFrame* localFrame, const FloatRect& bounds, Node* draggedNode, float opacity = 1)
+    DragImageBuilder(const LocalFrame* localFrame, const FloatRect& bounds, LayoutObject* layoutObject, float opacity = 1)
         : m_localFrame(localFrame)
-        , m_draggedNode(draggedNode)
+        , m_draggedLayoutObject(layoutObject)
         , m_bounds(bounds)
         , m_opacity(opacity)
     {
-        if (m_draggedNode && m_draggedNode->layoutObject())
-            m_draggedNode->layoutObject()->updateDragState(true);
+        DCHECK(!m_draggedLayoutObject || m_draggedLayoutObject->isDragging());
         // TODO(oshima): Remove this when all platforms are migrated to use-zoom-for-dsf.
         float deviceScaleFactor = m_localFrame->host()->deviceScaleFactorDeprecated();
         m_bounds.setWidth(m_bounds.width() * deviceScaleFactor);
         m_bounds.setHeight(m_bounds.height() * deviceScaleFactor);
         m_pictureBuilder = wrapUnique(new SkPictureBuilder(SkRect::MakeIWH(m_bounds.width(), m_bounds.height())));
 
         AffineTransform transform;
         transform.scale(deviceScaleFactor, deviceScaleFactor);
         transform.translate(-m_bounds.x(), -m_bounds.y());
         context().getPaintController().createAndAppend<BeginTransformDisplayItem>(*m_pictureBuilder, transform);
     }
 
+    ~DragImageBuilder()
+    {
+        if (!m_draggedLayoutObject)
+            return;
+        DCHECK(m_draggedLayoutObject->isDragging());
+        m_draggedLayoutObject->updateDragState(false);
+    }
+
     GraphicsContext& context() { return m_pictureBuilder->context(); }
 
     std::unique_ptr<DragImage> createImage()
     {
-        if (m_draggedNode && m_draggedNode->layoutObject())
-            m_draggedNode->layoutObject()->updateDragState(false);
         context().getPaintController().endItem<EndTransformDisplayItem>(*m_pictureBuilder);
         // TODO(fmalita): endRecording() should return a non-const SKP.
         sk_sp<SkPicture> recording(const_cast<SkPicture*>(m_pictureBuilder->endRecording().leakRef()));
         RefPtr<SkImage> skImage = fromSkSp(SkImage::MakeFromPicture(std::move(recording),
             SkISize::Make(m_bounds.width(), m_bounds.height()), nullptr, nullptr));
         RefPtr<Image> image = StaticBitmapImage::create(skImage.release());
         RespectImageOrientationEnum imageOrientation = DoNotRespectImageOrientation;
-        if (m_draggedNode && m_draggedNode->layoutObject())
-            imageOrientation = LayoutObject::shouldRespectImageOrientation(m_draggedNode->layoutObject());
+        if (m_draggedLayoutObject)
+            imageOrientation = LayoutObject::shouldRespectImageOrientation(m_draggedLayoutObject);
 
         float screenDeviceScaleFactor = m_localFrame->page()->chromeClient().screenInfo().deviceScaleFactor;
 
         return DragImage::create(image.get(), imageOrientation, screenDeviceScaleFactor, InterpolationHigh, m_opacity);
     }
 
 private:
     Member<const LocalFrame> m_localFrame;
-    Member<Node> m_draggedNode;
+    LayoutObject* const m_draggedLayoutObject;

[pdr., 2016/06/23 20:29:13]

Why "LayoutObject* const" instead of "const LayoutObject*"?

[yosin_UTC9, 2016/06/24 06:02:57]

|m_layoutObject| is read-only member and |LayoutObject::updateDragState()| is
non-const.

     FloatRect m_bounds;
-    float m_opacity;
+    float const m_opacity;
     std::unique_ptr<SkPictureBuilder> m_pictureBuilder;
 };
 
 inline float parentPageZoomFactor(LocalFrame* frame)
 {
     Frame* parent = frame->tree().parent();
     if (!parent || !parent->isLocalFrame())
         return 1;
     return toLocalFrame(parent)->pageZoomFactor();
 }
@@ skipping 429 matching lines @@
     if (!m_host)
         return 0;
 
     double ratio = m_host->deviceScaleFactorDeprecated();
     ratio *= pageZoomFactor();
     return ratio;
 }
 
 std::unique_ptr<DragImage> LocalFrame::nodeImage(Node& node)
 {
+    // TODO(yosin): We should handle pseudo-class ":drag" as similar as

[pdr., 2016/06/23 20:29:13]

I was a little confused by ":drag", I think we use ":-webkit-drag"

[yosin_UTC9, 2016/06/24 06:02:57]

Done.

+    // ":hover" and ":active", rather than using flag in |LayoutObject|, to
+    // avoid update layout tree here.
     m_view->updateAllLifecyclePhasesExceptPaint();
     LayoutObject* layoutObject = node.layoutObject();
     if (!layoutObject)
         return nullptr;
 
+    // Update layout object for |node| with pseudo-class ":drag".
+    layoutObject->updateDragState(true);

[pdr., 2016/06/23 20:29:13]

Previously, calling updateDragState was the responsibility of DragImageBuilder
but now it's split in two places. Can these be unified (either all in this
function or all in DragImageBuilder)? This will make it harder to forget to call
updateDragState.

One option would be to just update the return statement:
auto image = dragImageBuilder.createImage();
if (layoutObject)
    layoutObject->updateDragState(false);
return image;

[yosin_UTC9, 2016/06/24 06:02:57]

I introduce |NodeImageBuilder| class and make its ctor/dtor manage
|updateDragState|.

+    m_view->updateAllLifecyclePhasesExceptPaint();
+    // |node| with pseudo-class ":drag" may blow away layout object.
+    layoutObject = node.layoutObject();
+    if (!layoutObject)
+        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 = layoutObject->enclosingLayer();
     if (!layer->stackingNode()->isStackingContext())
         layer = layer->stackingNode()->ancestorStackingContextNode()->layer();
     IntRect absoluteBoundingBox = layoutObject->absoluteBoundingBoxRectIncludingDescendants();
     FloatRect boundingBox = layer->layoutObject()->absoluteToLocalQuad(FloatQuad(absoluteBoundingBox), UseTransforms).boundingBox();
-    DragImageBuilder dragImageBuilder(this, boundingBox, &node);
+    DragImageBuilder dragImageBuilder(this, boundingBox, layoutObject);
     {
         PaintLayerPaintingInfo paintingInfo(layer, LayoutRect(boundingBox), GlobalPaintFlattenCompositingLayers, LayoutSize());
         PaintLayerFlags flags = PaintLayerHaveTransparency | PaintLayerAppliedTransform | PaintLayerUncachedClipRects;
         PaintLayerPainter(*layer).paintLayer(dragImageBuilder.context(), paintingInfo, flags);
     }
     return dragImageBuilder.createImage();
 }
 
 std::unique_ptr<DragImage> LocalFrame::dragImageForSelection(float opacity)
 {
@@ skipping 205 matching lines @@
         m_frame->client()->frameBlameContext()->Enter();
 }
 
 ScopedFrameBlamer::~ScopedFrameBlamer()
 {
     if (m_frame && m_frame->client() && m_frame->client()->frameBlameContext())
         m_frame->client()->frameBlameContext()->Leave();
 }
 
 } // namespace blink