Remove OwnPtr from Blink.

third_party/WebKit/Source/platform/DragImage.cpp

 /*
  * Copyright (C) 2007 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
@@ skipping 32 matching lines @@
 #include "platform/text/BidiTextRun.h"
 #include "platform/text/StringTruncator.h"
 #include "platform/text/TextRun.h"
 #include "platform/transforms/AffineTransform.h"
 #include "platform/weborigin/KURL.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkSurface.h"
-#include "wtf/PassOwnPtr.h"
+#include "wtf/PtrUtil.h"
 #include "wtf/RefPtr.h"
 #include "wtf/text/WTFString.h"
-
 #include <algorithm>
+#include <memory>
 
 namespace blink {
 
 namespace {
 
 const float kDragLabelBorderX = 4;
 // Keep border_y in synch with DragController::LinkDragBorderInset.
 const float kDragLabelBorderY = 2;
 const float kLabelBorderYOffset = 2;
 
@@ skipping 57 matching lines @@
     // Uniform scaling for clamping.
     const float clampScaleX = size.width() > maxSize.width()
         ? static_cast<float>(maxSize.width()) / size.width() : 1;
     const float clampScaleY = size.height() > maxSize.height()
         ? static_cast<float>(maxSize.height()) / size.height() : 1;
     imageScale.scale(std::min(clampScaleX, clampScaleY));
 
     return imageScale;
 }
 
-PassOwnPtr<DragImage> DragImage::create(Image* image,
+std::unique_ptr<DragImage> DragImage::create(Image* image,
     RespectImageOrientationEnum shouldRespectImageOrientation, float deviceScaleFactor,
     InterpolationQuality interpolationQuality, float opacity, FloatSize imageScale)
 {
     if (!image)
         return nullptr;
 
     RefPtr<SkImage> skImage = image->imageForCurrentFrame();
     if (!skImage)
         return nullptr;
 
     ImageOrientation orientation;
     if (shouldRespectImageOrientation == RespectImageOrientation && image->isBitmapImage())
         orientation = toBitmapImage(image)->currentFrameOrientation();
 
     SkBitmap bm;
     RefPtr<SkImage> resizedImage =
         resizeAndOrientImage(skImage.release(), orientation, imageScale, opacity, interpolationQuality);
     if (!resizedImage || !resizedImage->asLegacyBitmap(&bm, SkImage::kRO_LegacyBitmapMode))
         return nullptr;
 
-    return adoptPtr(new DragImage(bm, deviceScaleFactor, interpolationQuality));
+    return wrapUnique(new DragImage(bm, deviceScaleFactor, interpolationQuality));
 }
 
 static Font deriveDragLabelFont(int size, FontWeight fontWeight, const FontDescription& systemFont)
 {
     FontDescription description = systemFont;
     description.setWeight(fontWeight);
     description.setSpecifiedSize(size);
     description.setComputedSize(size);
     Font result(description);
     result.update(nullptr);
     return result;
 }
 
-PassOwnPtr<DragImage> DragImage::create(const KURL& url, const String& inLabel, const FontDescription& systemFont, float deviceScaleFactor)
+std::unique_ptr<DragImage> DragImage::create(const KURL& url, const String& inLabel, const FontDescription& systemFont, float deviceScaleFactor)
 {
     const Font labelFont = deriveDragLabelFont(kDragLinkLabelFontSize, FontWeightBold, systemFont);
     const Font urlFont = deriveDragLabelFont(kDragLinkUrlFontSize, FontWeightNormal, systemFont);
     FontCachePurgePreventer fontCachePurgePreventer;
 
     bool drawURLString = true;
     bool clipURLString = false;
     bool clipLabelString = false;
     float maxDragLabelStringWidthDIP = kMaxDragLabelStringWidth / deviceScaleFactor;
 
@@ skipping 25 matching lines @@
             imageSize.setWidth(maxDragLabelStringWidthDIP);
             clipURLString = true;
         } else
             imageSize.setWidth(std::max(labelSize.width(), urlStringSize.width()) + kDragLabelBorderX * 2);
     }
 
     // We now know how big the image needs to be, so we create and
     // fill the background
     IntSize scaledImageSize = imageSize;
     scaledImageSize.scale(deviceScaleFactor);
-    OwnPtr<ImageBuffer> buffer(ImageBuffer::create(scaledImageSize));
+    std::unique_ptr<ImageBuffer> buffer(ImageBuffer::create(scaledImageSize));
     if (!buffer)
         return nullptr;
 
     buffer->canvas()->scale(deviceScaleFactor, deviceScaleFactor);
 
     const float DragLabelRadius = 5;
 
     IntRect rect(IntPoint(), imageSize);
     SkPaint backgroundPaint;
     backgroundPaint.setColor(SkColorSetRGB(140, 140, 140));
@@ skipping 41 matching lines @@
 
 void DragImage::scale(float scaleX, float scaleY)
 {
     skia::ImageOperations::ResizeMethod resizeMethod = m_interpolationQuality == InterpolationNone ? skia::ImageOperations::RESIZE_BOX : skia::ImageOperations::RESIZE_LANCZOS3;
     int imageWidth = scaleX * m_bitmap.width();
     int imageHeight = scaleY * m_bitmap.height();
     m_bitmap = skia::ImageOperations::Resize(m_bitmap, resizeMethod, imageWidth, imageHeight);
 }
 
 } // namespace blink