SkImage-ify DragImage

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 50 matching lines @@
 #include "core/page/Page.h"
 #include "core/page/scrolling/ScrollingCoordinator.h"
 #include "core/paint/DeprecatedPaintLayer.h"
 #include "core/paint/TransformRecorder.h"
 #include "core/svg/SVGDocumentExtensions.h"
 #include "platform/DragImage.h"
 #include "platform/PluginScriptForbiddenScope.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/ScriptForbiddenScope.h"
 #include "platform/graphics/GraphicsContext.h"
-#include "platform/graphics/ImageBuffer.h"
+#include "platform/graphics/StaticBitmapImage.h"
 #include "platform/graphics/paint/ClipRecorder.h"
 #include "platform/graphics/paint/SkPictureBuilder.h"
 #include "platform/text/TextStream.h"
+#include "third_party/skia/include/core/SkImage.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/StdLibExtras.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 namespace {
 
 struct ScopedFramePaintingState {
@@ skipping 493 matching lines @@
 {
     if (!m_host)
         return 0;
 
     double ratio = m_host->deviceScaleFactor();
     ratio *= pageZoomFactor();
     return ratio;
 }
 
 PassOwnPtr<DragImage> LocalFrame::paintIntoDragImage(
-    const DisplayItemClientWrapper& displayItemClient, DisplayItem::Type clipType, RespectImageOrientationEnum shouldRespectImageOrientation, const GlobalPaintFlags globalPaintFlags, IntRect paintingRect)
+    const DisplayItemClientWrapper& displayItemClient,
+    RespectImageOrientationEnum shouldRespectImageOrientation,
+    const GlobalPaintFlags globalPaintFlags, IntRect paintingRect, float opacity)
 {
     ASSERT(document()->isActive());
     // Not flattening compositing layers will result in a broken image being painted.
     ASSERT(globalPaintFlags & GlobalPaintFlattenCompositingLayers);
 
     float deviceScaleFactor = m_host->deviceScaleFactor();
     paintingRect.setWidth(paintingRect.width() * deviceScaleFactor);
     paintingRect.setHeight(paintingRect.height() * deviceScaleFactor);
 
-    OwnPtr<ImageBuffer> buffer = ImageBuffer::create(paintingRect.size());
-    if (!buffer)
-        return nullptr;
-
     SkPictureBuilder pictureBuilder(paintingRect);
     {
         GraphicsContext& paintContext = pictureBuilder.context();
 
         AffineTransform transform;
         transform.scale(deviceScaleFactor, deviceScaleFactor);
         transform.translate(-paintingRect.x(), -paintingRect.y());
         TransformRecorder transformRecorder(paintContext, displayItemClient, transform);
 
-        ClipRecorder clipRecorder(paintContext, displayItemClient, clipType,
-            LayoutRect(0, 0, paintingRect.maxX(), paintingRect.maxY()));
-
         m_view->paintContents(&paintContext, globalPaintFlags, paintingRect);
 
     }
     RefPtr<const SkPicture> recording = pictureBuilder.endRecording();
-    buffer->canvas()->drawPicture(recording.get());
+    RefPtr<SkImage> skImage = adoptRef(SkImage::NewFromPicture(recording.get(),
+        SkISize::Make(paintingRect.width(), paintingRect.height()), nullptr, nullptr));
+    RefPtr<Image> image = StaticBitmapImage::create(skImage.release());
 
-    RefPtr<Image> image = buffer->newImageSnapshot();
-    return DragImage::create(image.get(), shouldRespectImageOrientation, deviceScaleFactor);
+    return DragImage::create(image.get(), shouldRespectImageOrientation, deviceScaleFactor,
+        InterpolationHigh, opacity);
 }
 
 PassOwnPtr<DragImage> LocalFrame::nodeImage(Node& node)
 {
     if (!node.layoutObject())
         return nullptr;
 
     const ScopedFramePaintingState state(this, &node);
 
     m_view->updateAllLifecyclePhases();
 
     m_view->setNodeToDraw(&node); // Enable special sub-tree drawing mode.
 
     // Document::updateLayout may have blown away the original LayoutObject.
     LayoutObject* layoutObject = node.layoutObject();
     if (!layoutObject)
         return nullptr;
 
     IntRect rect;
 
-    return paintIntoDragImage(*layoutObject, DisplayItem::ClipNodeImage, layoutObject->shouldRespectImageOrientation(), GlobalPaintFlattenCompositingLayers,
-        layoutObject->paintingRootRect(rect));
+    return paintIntoDragImage(*layoutObject, layoutObject->shouldRespectImageOrientation(),
+        GlobalPaintFlattenCompositingLayers, layoutObject->paintingRootRect(rect));
 }
 
-PassOwnPtr<DragImage> LocalFrame::dragImageForSelection()
+PassOwnPtr<DragImage> LocalFrame::dragImageForSelection(float opacity)
 {
     if (!selection().isRange())
         return nullptr;
 
     const ScopedFramePaintingState state(this, 0);
     m_view->updateAllLifecyclePhases();
 
-    return paintIntoDragImage(*this, DisplayItem::ClipSelectionImage, DoNotRespectImageOrientation, GlobalPaintSelectionOnly | GlobalPaintFlattenCompositingLayers, enclosingIntRect(selection().bounds()));
+    return paintIntoDragImage(*this, DoNotRespectImageOrientation,
+        GlobalPaintSelectionOnly | GlobalPaintFlattenCompositingLayers,
+        enclosingIntRect(selection().bounds()), opacity);
 }
 
 String LocalFrame::selectedText() const
 {
     return selection().selectedText();
 }
 
 String LocalFrame::selectedTextForClipboard() const
 {
     return selection().selectedTextForClipboard();
@@ skipping 179 matching lines @@
 {
     if (isLocalRoot())
         m_instrumentingAgents = InstrumentingAgents::create();
     else
         m_instrumentingAgents = localFrameRoot()->m_instrumentingAgents;
 }
 
 DEFINE_WEAK_IDENTIFIER_MAP(LocalFrame);
 
 } // namespace blink