Convert //printing to use std::unique_ptr

printing/pdf_metafile_skia.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/pdf_metafile_skia.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/containers/hash_tables.h"
@@ skipping 40 matching lines @@
   SkSize page_size_;
   SkRect content_area_;
   float scale_factor_;
   sk_sp<SkPicture> content_;
 };
 
 bool WriteAssetToBuffer(const SkStreamAsset* asset,
                         void* buffer,
                         size_t size) {
   // Calling duplicate() keeps original asset state unchanged.
-  scoped_ptr<SkStreamAsset> assetCopy(asset->duplicate());
+  std::unique_ptr<SkStreamAsset> assetCopy(asset->duplicate());
   size_t length = assetCopy->getLength();
   if (length > size)
     return false;
   return (length == assetCopy->read(buffer, length));
 }
 
 SkTime::DateTime TimeToSkTime(base::Time time) {
     base::Time::Exploded exploded;
     time.UTCExplode(&exploded);
     SkTime::DateTime skdate;
     skdate.fTimeZoneMinutes = 0;
     skdate.fYear = exploded.year;
     skdate.fMonth = exploded.month;
     skdate.fDayOfWeek = exploded.day_of_week;
     skdate.fDay = exploded.day_of_month;
     skdate.fHour = exploded.hour;
     skdate.fMinute = exploded.minute;
     skdate.fSecond = exploded.second;
     return skdate;
 }
 
 }  // namespace
 
 namespace printing {
 
 struct PdfMetafileSkiaData {
   SkPictureRecorder recorder_;  // Current recording
 
   std::vector<Page> pages_;
-  scoped_ptr<SkStreamAsset> pdf_data_;
+  std::unique_ptr<SkStreamAsset> pdf_data_;
 
 #if defined(OS_MACOSX)
   PdfMetafileCg pdf_cg_;
 #endif
 };
 
 PdfMetafileSkia::~PdfMetafileSkia() {}
 
 bool PdfMetafileSkia::Init() {
   return true;
@@ skipping 148 matching lines @@
   }
   return data_->pdf_cg_.RenderPage(page_number, context, rect, params);
 }
 #endif
 
 bool PdfMetafileSkia::SaveTo(base::File* file) const {
   if (GetDataSize() == 0U)
     return false;
 
   // Calling duplicate() keeps original asset state unchanged.
-  scoped_ptr<SkStreamAsset> asset(data_->pdf_data_->duplicate());
+  std::unique_ptr<SkStreamAsset> asset(data_->pdf_data_->duplicate());
 
   const size_t maximum_buffer_size = 1024 * 1024;
   std::vector<char> buffer(std::min(maximum_buffer_size, asset->getLength()));
   do {
     size_t read_size = asset->read(&buffer[0], buffer.size());
     if (read_size == 0)
       break;
     DCHECK_GE(buffer.size(), read_size);
     if (!file->WriteAtCurrentPos(&buffer[0],
                                  base::checked_cast<int>(read_size))) {
@@ skipping 18 matching lines @@
 
   if (!fd.auto_close)
     file.TakePlatformFile();
   return result;
 }
 #endif
 
 PdfMetafileSkia::PdfMetafileSkia() : data_(new PdfMetafileSkiaData) {
 }
 
-scoped_ptr<PdfMetafileSkia> PdfMetafileSkia::GetMetafileForCurrentPage() {
+std::unique_ptr<PdfMetafileSkia> PdfMetafileSkia::GetMetafileForCurrentPage() {
   // If we only ever need the metafile for the last page, should we
   // only keep a handle on one SkPicture?
-  scoped_ptr<PdfMetafileSkia> metafile(new PdfMetafileSkia);
+  std::unique_ptr<PdfMetafileSkia> metafile(new PdfMetafileSkia);
 
   if (data_->pages_.size() == 0)
     return metafile;
 
   if (data_->recorder_.getRecordingCanvas())  // page outstanding
     return metafile;
 
   const Page& page = data_->pages_.back();
 
   metafile->data_->pages_.push_back(page);
 
   if (!metafile->FinishDocument())  // Generate PDF.
     metafile.reset();
 
   return metafile;
 }
 
 }  // namespace printing