Convert //chrome/browser/ui from scoped_ptr to std::unique_ptr

chrome/browser/ui/webui/print_preview/extension_printer_handler.cc

 // Copyright 2015 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 "chrome/browser/ui/webui/print_preview/extension_printer_handler.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 40 matching lines @@
 const char kContentTypePWGRaster[] = "image/pwg-raster";
 const char kContentTypeAll[] = "*/*";
 
 const char kInvalidDataPrintError[] = "INVALID_DATA";
 const char kInvalidTicketPrintError[] = "INVALID_TICKET";
 
 const char kProvisionalUsbLabel[] = "provisional-usb";
 
 // Updates |job| with raster file path, size and last modification time.
 // Returns the updated print job.
-scoped_ptr<extensions::PrinterProviderPrintJob> UpdateJobFileInfoOnWorkerThread(
+std::unique_ptr<extensions::PrinterProviderPrintJob>
+UpdateJobFileInfoOnWorkerThread(
     const base::FilePath& raster_path,
-    scoped_ptr<extensions::PrinterProviderPrintJob> job) {
+    std::unique_ptr<extensions::PrinterProviderPrintJob> job) {
   if (base::GetFileInfo(raster_path, &job->file_info))
     job->document_path = raster_path;
   return job;
 }
 
 // Callback to PWG raster conversion.
 // Posts a task to update print job with info about file containing converted
 // PWG raster data. The task is posted to |slow_task_runner|.
 void UpdateJobFileInfo(
-    scoped_ptr<extensions::PrinterProviderPrintJob> job,
+    std::unique_ptr<extensions::PrinterProviderPrintJob> job,
     const scoped_refptr<base::TaskRunner>& slow_task_runner,
     const ExtensionPrinterHandler::PrintJobCallback& callback,
     bool success,
     const base::FilePath& pwg_file_path) {
   if (!success) {
     callback.Run(std::move(job));
     return;
   }
 
   base::PostTaskAndReplyWithResult(
@@ skipping 97 matching lines @@
 }
 
 void ExtensionPrinterHandler::StartPrint(
     const std::string& destination_id,
     const std::string& capability,
     const base::string16& job_title,
     const std::string& ticket_json,
     const gfx::Size& page_size,
     const scoped_refptr<base::RefCountedMemory>& print_data,
     const PrinterHandler::PrintCallback& callback) {
-  scoped_ptr<extensions::PrinterProviderPrintJob> print_job(
+  std::unique_ptr<extensions::PrinterProviderPrintJob> print_job(
       new extensions::PrinterProviderPrintJob());
   print_job->printer_id = destination_id;
   print_job->job_title = job_title;
   print_job->ticket_json = ticket_json;
 
   cloud_devices::CloudDeviceDescription printer_description;
   printer_description.InitFromString(capability);
 
   cloud_devices::printer::ContentTypesCapability content_types;
   content_types.LoadFrom(printer_description);
@@ skipping 46 matching lines @@
 
   extensions::PrinterProviderAPIFactory::GetInstance()
       ->GetForBrowserContext(browser_context_)
       ->DispatchGetUsbPrinterInfoRequested(
           extension_id, device,
           base::Bind(&ExtensionPrinterHandler::WrapGetPrinterInfoCallback,
                      weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void ExtensionPrinterHandler::SetPWGRasterConverterForTesting(
-    scoped_ptr<PWGRasterConverter> pwg_raster_converter) {
+    std::unique_ptr<PWGRasterConverter> pwg_raster_converter) {
   pwg_raster_converter_ = std::move(pwg_raster_converter);
 }
 
 void ExtensionPrinterHandler::ConvertToPWGRaster(
     const scoped_refptr<base::RefCountedMemory>& data,
     const cloud_devices::CloudDeviceDescription& printer_description,
     const cloud_devices::CloudDeviceDescription& ticket,
     const gfx::Size& page_size,
-    scoped_ptr<extensions::PrinterProviderPrintJob> job,
+    std::unique_ptr<extensions::PrinterProviderPrintJob> job,
     const ExtensionPrinterHandler::PrintJobCallback& callback) {
   if (!pwg_raster_converter_) {
     pwg_raster_converter_ = PWGRasterConverter::CreateDefault();
   }
   pwg_raster_converter_->Start(
       data.get(),
       PWGRasterConverter::GetConversionSettings(printer_description, page_size),
       PWGRasterConverter::GetBitmapSettings(printer_description, ticket),
       base::Bind(&UpdateJobFileInfo, base::Passed(&job), slow_task_runner_,
                  callback));
 }
 
 void ExtensionPrinterHandler::DispatchPrintJob(
     const PrinterHandler::PrintCallback& callback,
-    scoped_ptr<extensions::PrinterProviderPrintJob> print_job) {
+    std::unique_ptr<extensions::PrinterProviderPrintJob> print_job) {
   if (print_job->document_path.empty() && !print_job->document_bytes) {
     WrapPrintCallback(callback, false, kInvalidDataPrintError);
     return;
   }
 
   extensions::PrinterProviderAPIFactory::GetInstance()
       ->GetForBrowserContext(browser_context_)
       ->DispatchPrintRequested(
           *print_job, base::Bind(&ExtensionPrinterHandler::WrapPrintCallback,
                                  weak_ptr_factory_.GetWeakPtr(), callback));
@@ skipping 73 matching lines @@
                 .Set("provisional", true)
                 .Build());
       }
     }
   }
 
   DCHECK_GT(pending_enumeration_count_, 0);
   pending_enumeration_count_--;
   callback.Run(*printer_list.Build().get(), pending_enumeration_count_ == 0);
 }