Convert //chrome from scoped_ptr to std::unique_ptr

chrome/service/cloud_print/print_system_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 "chrome/service/cloud_print/print_system.h"
 
+#include <memory>
+
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/memory/free_deleter.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/win/object_watcher.h"
 #include "base/win/scoped_bstr.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_hdc.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/cloud_print/cloud_print_cdd_conversion.h"
 #include "chrome/common/cloud_print/cloud_print_constants.h"
 #include "chrome/common/crash_keys.h"
@@ skipping 232 matching lines @@
                const std::string& job_title,
                JobSpooler::Delegate* delegate) {
       if (delegate_) {
         // We are already in the process of printing.
         NOTREACHED();
         return false;
       }
       base::string16 printer_wide = base::UTF8ToWide(printer_name);
       // We only support PDF and XPS documents for now.
       if (print_data_mime_type == kContentTypePDF) {
-        scoped_ptr<DEVMODE, base::FreeDeleter> dev_mode;
+        std::unique_ptr<DEVMODE, base::FreeDeleter> dev_mode;
         if (print_ticket_mime_type == kContentTypeJSON) {
           dev_mode = CjtToDevMode(printer_wide, print_ticket);
         } else {
           DCHECK(print_ticket_mime_type == kContentTypeXML);
           dev_mode = printing::XpsTicketToDevMode(printer_wide, print_ticket);
         }
 
         if (!dev_mode) {
           NOTREACHED();
           return false;
@@ skipping 143 matching lines @@
                      base::ThreadTaskRunnerHandle::Get()));
     }
 
     // Called on the service process IO thread.
     void RenderPDFPagesInSandbox(
         const base::FilePath& pdf_path,
         const gfx::Rect& render_area,
         int render_dpi,
         const scoped_refptr<base::SingleThreadTaskRunner>& client_task_runner) {
       DCHECK(g_service_process->io_task_runner()->BelongsToCurrentThread());
-      scoped_ptr<ServiceUtilityProcessHost> utility_host(
+      std::unique_ptr<ServiceUtilityProcessHost> utility_host(
           new ServiceUtilityProcessHost(this, client_task_runner.get()));
       // TODO(gene): For now we disabling autorotation for CloudPrinting.
       // Landscape/Portrait setting is passed in the print ticket and
       // server is generating portrait PDF always.
       // We should enable autorotation once server will be able to generate
       // PDF that matches paper size and orientation.
       if (utility_host->StartRenderPDFPagesToMetafile(
               pdf_path,
               printing::PdfRenderSettings(render_area, render_dpi, false))) {
         // The object will self-destruct when the child process dies.
@@ skipping 93 matching lines @@
     Release();
   }
 
   void OnGetPrinterSemanticCapsAndDefaults(
       bool succeeded,
       const std::string& printer_name,
       const printing::PrinterSemanticCapsAndDefaults& semantic_info) override {
     printing::PrinterCapsAndDefaults printer_info;
     if (succeeded) {
       printer_info.caps_mime_type = kContentTypeJSON;
-      scoped_ptr<base::DictionaryValue> description(
+      std::unique_ptr<base::DictionaryValue> description(
           PrinterSemanticCapsAndDefaultsToCdd(semantic_info));
       if (description) {
         base::JSONWriter::WriteWithOptions(
             *description, base::JSONWriter::OPTIONS_PRETTY_PRINT,
             &printer_info.printer_capabilities);
       }
     }
     callback_.Run(succeeded, printer_name, printer_info);
     callback_.Reset();
     Release();
@@ skipping 12 matching lines @@
         base::Bind(&PrinterCapsHandler::GetPrinterSemanticCapsAndDefaultsImpl,
                    this, base::ThreadTaskRunnerHandle::Get()));
   }
 
  private:
   ~PrinterCapsHandler() override {}
 
   void GetPrinterCapsAndDefaultsImpl(
       const scoped_refptr<base::SingleThreadTaskRunner>& client_task_runner) {
     DCHECK(g_service_process->io_task_runner()->BelongsToCurrentThread());
-    scoped_ptr<ServiceUtilityProcessHost> utility_host(
+    std::unique_ptr<ServiceUtilityProcessHost> utility_host(
         new ServiceUtilityProcessHost(this, client_task_runner.get()));
     if (utility_host->StartGetPrinterCapsAndDefaults(printer_name_)) {
       // The object will self-destruct when the child process dies.
       ignore_result(utility_host.release());
     } else {
       client_task_runner->PostTask(
           FROM_HERE, base::Bind(&PrinterCapsHandler::OnChildDied, this));
     }
   }
 
   void GetPrinterSemanticCapsAndDefaultsImpl(
       const scoped_refptr<base::SingleThreadTaskRunner>& client_task_runner) {
     DCHECK(g_service_process->io_task_runner()->BelongsToCurrentThread());
-    scoped_ptr<ServiceUtilityProcessHost> utility_host(
+    std::unique_ptr<ServiceUtilityProcessHost> utility_host(
         new ServiceUtilityProcessHost(this, client_task_runner.get()));
     if (utility_host->StartGetPrinterSemanticCapsAndDefaults(printer_name_)) {
       // The object will self-destruct when the child process dies.
       ignore_result(utility_host.release());
     } else {
       client_task_runner->PostTask(
           FROM_HERE, base::Bind(&PrinterCapsHandler::OnChildDied, this));
     }
   }
 
@@ skipping 142 matching lines @@
   printer_handle.OpenPrinter(printer_name_wide.c_str());
   DCHECK(printer_handle.IsValid());
   bool ret = false;
   if (printer_handle.IsValid()) {
     DWORD bytes_needed = 0;
     GetJob(printer_handle.Get(), job_id, 1, NULL, 0, &bytes_needed);
     DWORD last_error = GetLastError();
     if (ERROR_INVALID_PARAMETER != last_error) {
       // ERROR_INVALID_PARAMETER normally means that the job id is not valid.
       DCHECK(last_error == ERROR_INSUFFICIENT_BUFFER);
-      scoped_ptr<BYTE[]> job_info_buffer(new BYTE[bytes_needed]);
+      std::unique_ptr<BYTE[]> job_info_buffer(new BYTE[bytes_needed]);
       if (GetJob(printer_handle.Get(), job_id, 1, job_info_buffer.get(),
                  bytes_needed, &bytes_needed)) {
         JOB_INFO_1 *job_info =
             reinterpret_cast<JOB_INFO_1 *>(job_info_buffer.get());
         if (job_info->pStatus) {
           base::WideToUTF8(job_info->pStatus, wcslen(job_info->pStatus),
                            &job_details->status_message);
         }
         job_details->platform_status_flags = job_info->Status;
         if ((job_info->Status & JOB_STATUS_COMPLETE) ||
@@ skipping 48 matching lines @@
 }
 
 }  // namespace
 
 scoped_refptr<PrintSystem> PrintSystem::CreateInstance(
     const base::DictionaryValue* print_system_settings) {
   return new PrintSystemWin;
 }
 
 }  // namespace cloud_print