Convert //printing to use std::unique_ptr

printing/emf_win.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "printing/emf_win.h"
 
 #include <stdint.h>
 
+#include <memory>
+
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/win/scoped_gdi_object.h"
 #include "base/win/scoped_hdc.h"
 #include "base/win/scoped_select_object.h"
 #include "skia/ext/skia_utils_win.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/gdi_util.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
@@ skipping 329 matching lines @@
       const EMRSTRETCHDIBITS * sdib_record =
           reinterpret_cast<const EMRSTRETCHDIBITS*>(record());
       const BYTE* record_start = reinterpret_cast<const BYTE *>(record());
       const BITMAPINFOHEADER *bmih =
           reinterpret_cast<const BITMAPINFOHEADER *>(record_start +
                                                      sdib_record->offBmiSrc);
       const BYTE* bits = record_start + sdib_record->offBitsSrc;
       bool play_normally = true;
       res = false;
       HDC hdc = context->hdc;
-      scoped_ptr<SkBitmap> bitmap;
+      std::unique_ptr<SkBitmap> bitmap;
       if (bmih->biCompression == BI_JPEG) {
         if (!DIBFormatNativelySupported(hdc, CHECKJPEGFORMAT, bits,
                                         bmih->biSizeImage)) {
           play_normally = false;
           bitmap.reset(gfx::JPEGCodec::Decode(bits, bmih->biSizeImage));
         }
       } else if (bmih->biCompression == BI_PNG) {
         if (!DIBFormatNativelySupported(hdc, CHECKPNGFORMAT, bits,
                                         bmih->biSizeImage)) {
           play_normally = false;
@@ skipping 143 matching lines @@
 bool Emf::IsAlphaBlendUsed() const {
   bool result = false;
   ::EnumEnhMetaFile(NULL,
                     emf(),
                     &IsAlphaBlendUsedEnumProc,
                     &result,
                     NULL);
   return result;
 }
 
-scoped_ptr<Emf> Emf::RasterizeMetafile(int raster_area_in_pixels) const {
+std::unique_ptr<Emf> Emf::RasterizeMetafile(int raster_area_in_pixels) const {
   gfx::Rect page_bounds = GetPageBounds(1);
   gfx::Size page_size(page_bounds.size());
   if (page_size.GetArea() <= 0) {
     NOTREACHED() << "Metafile is empty";
     page_bounds = gfx::Rect(1, 1);
   }
 
   float scale = sqrt(
       static_cast<float>(raster_area_in_pixels) / page_size.GetArea());
   page_size.set_width(std::max<int>(1, page_size.width() * scale));
   page_size.set_height(std::max<int>(1, page_size.height() * scale));
 
 
   RasterBitmap bitmap(page_size);
 
   gfx::Rect bitmap_rect(page_size);
   RECT rect = bitmap_rect.ToRECT();
   Playback(bitmap.context(), &rect);
 
-  scoped_ptr<Emf> result(new Emf);
+  std::unique_ptr<Emf> result(new Emf);
   result->Init();
   HDC hdc = result->context();
   DCHECK(hdc);
   skia::InitializeDC(hdc);
 
   // Params are ignored.
   result->StartPage(page_bounds.size(), page_bounds, 1);
 
   ::ModifyWorldTransform(hdc, NULL, MWT_IDENTITY);
   XFORM xform = {
     static_cast<float>(page_bounds.width()) / bitmap_rect.width(),
     0,
     0,
     static_cast<float>(page_bounds.height()) / bitmap_rect.height(),
     static_cast<float>(page_bounds.x()),
     static_cast<float>(page_bounds.y()),
   };
   ::SetWorldTransform(hdc, &xform);
   ::BitBlt(hdc, 0, 0, bitmap_rect.width(), bitmap_rect.height(),
            bitmap.context(), bitmap_rect.x(), bitmap_rect.y(), SRCCOPY);
 
   result->FinishPage();
   result->FinishDocument();
 
   return result;
 }
 
-scoped_ptr<Emf> Emf::RasterizeAlphaBlend() const {
+std::unique_ptr<Emf> Emf::RasterizeAlphaBlend() const {
   gfx::Rect page_bounds = GetPageBounds(1);
   if (page_bounds.size().GetArea() <= 0) {
     NOTREACHED() << "Metafile is empty";
     page_bounds = gfx::Rect(1, 1);
   }
 
   RasterBitmap bitmap(page_bounds.size());
 
   // Map metafile page_bounds.x(), page_bounds.y() to bitmap 0, 0.
   XFORM xform = {1,
                  0,
                  0,
                  1,
                  static_cast<float>(-page_bounds.x()),
                  static_cast<float>(-page_bounds.y())};
   ::SetWorldTransform(bitmap.context(), &xform);
 
-  scoped_ptr<Emf> result(new Emf);
+  std::unique_ptr<Emf> result(new Emf);
   result->Init();
   HDC hdc = result->context();
   DCHECK(hdc);
   skia::InitializeDC(hdc);
 
   HDC bitmap_dc = bitmap.context();
   RECT rect = page_bounds.ToRECT();
   ::EnumEnhMetaFile(hdc, emf(), &RasterizeAlphaBlendProc, &bitmap_dc, &rect);
 
   result->FinishDocument();
 
   return result;
 }
 
 
 }  // namespace printing