Convert //extensions/browser/api from scoped_ptr to std::unique_ptr

extensions/browser/api/printer_provider_internal/printer_provider_internal_api.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 "extensions/browser/api/printer_provider_internal/printer_provider_internal_api.h"
 
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/memory/ref_counted_memory.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "content/public/browser/blob_handle.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/api/printer_provider/printer_provider_api.h"
 #include "extensions/browser/api/printer_provider/printer_provider_api_factory.h"
 #include "extensions/browser/api/printer_provider/printer_provider_print_job.h"
@@ skipping 72 matching lines @@
 PrinterProviderInternalReportPrintResultFunction::
     PrinterProviderInternalReportPrintResultFunction() {
 }
 
 PrinterProviderInternalReportPrintResultFunction::
     ~PrinterProviderInternalReportPrintResultFunction() {
 }
 
 ExtensionFunction::ResponseAction
 PrinterProviderInternalReportPrintResultFunction::Run() {
-  scoped_ptr<internal_api::ReportPrintResult::Params> params(
+  std::unique_ptr<internal_api::ReportPrintResult::Params> params(
       internal_api::ReportPrintResult::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   PrinterProviderInternalAPI::GetFactoryInstance()
       ->Get(browser_context())
       ->NotifyPrintResult(extension(), params->request_id, params->error);
   return RespondNow(NoArguments());
 }
 
 PrinterProviderInternalReportPrinterCapabilityFunction::
     PrinterProviderInternalReportPrinterCapabilityFunction() {
 }
 
 PrinterProviderInternalReportPrinterCapabilityFunction::
     ~PrinterProviderInternalReportPrinterCapabilityFunction() {
 }
 
 ExtensionFunction::ResponseAction
 PrinterProviderInternalReportPrinterCapabilityFunction::Run() {
-  scoped_ptr<internal_api::ReportPrinterCapability::Params> params(
+  std::unique_ptr<internal_api::ReportPrinterCapability::Params> params(
       internal_api::ReportPrinterCapability::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   if (params->capability) {
     PrinterProviderInternalAPI::GetFactoryInstance()
         ->Get(browser_context())
         ->NotifyGetCapabilityResult(extension(), params->request_id,
                                     params->capability->additional_properties);
   } else {
     PrinterProviderInternalAPI::GetFactoryInstance()
         ->Get(browser_context())
         ->NotifyGetCapabilityResult(extension(), params->request_id,
                                     base::DictionaryValue());
   }
   return RespondNow(NoArguments());
 }
 
 PrinterProviderInternalReportPrintersFunction::
     PrinterProviderInternalReportPrintersFunction() {
 }
 
 PrinterProviderInternalReportPrintersFunction::
     ~PrinterProviderInternalReportPrintersFunction() {
 }
 
 ExtensionFunction::ResponseAction
 PrinterProviderInternalReportPrintersFunction::Run() {
-  scoped_ptr<internal_api::ReportPrinters::Params> params(
+  std::unique_ptr<internal_api::ReportPrinters::Params> params(
       internal_api::ReportPrinters::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   base::ListValue printers;
   if (params->printers) {
     PrinterProviderInternalAPI::GetFactoryInstance()
         ->Get(browser_context())
         ->NotifyGetPrintersResult(extension(), params->request_id,
                                   *params->printers);
   } else {
     PrinterProviderInternalAPI::GetFactoryInstance()
         ->Get(browser_context())
         ->NotifyGetPrintersResult(
             extension(), params->request_id,
             PrinterProviderInternalAPIObserver::PrinterInfoVector());
   }
   return RespondNow(NoArguments());
 }
 
 PrinterProviderInternalGetPrintDataFunction::
     PrinterProviderInternalGetPrintDataFunction() {
 }
 
 PrinterProviderInternalGetPrintDataFunction::
     ~PrinterProviderInternalGetPrintDataFunction() {
 }
 
 ExtensionFunction::ResponseAction
 PrinterProviderInternalGetPrintDataFunction::Run() {
-  scoped_ptr<internal_api::GetPrintData::Params> params(
+  std::unique_ptr<internal_api::GetPrintData::Params> params(
       internal_api::GetPrintData::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   const PrinterProviderPrintJob* job =
       PrinterProviderAPIFactory::GetInstance()
           ->GetForBrowserContext(browser_context())
           ->GetPrintJob(extension(), params->request_id);
   if (!job)
     return RespondNow(Error("Print request not found."));
 
@@ skipping 16 matching lines @@
   } else {
     return RespondNow(Error("Job data not set"));
   }
   return RespondLater();
 }
 
 void PrinterProviderInternalGetPrintDataFunction::OnBlob(
     const std::string& type,
     int size,
     const scoped_refptr<base::RefCountedMemory>& data,
-    scoped_ptr<content::BlobHandle> blob) {
+    std::unique_ptr<content::BlobHandle> blob) {
   if (!blob) {
     SetError("Unable to create the blob.");
     SendResponse(false);
     return;
   }
 
   internal_api::BlobInfo info;
   info.blob_uuid = blob->GetUUID();
   info.type = type;
   info.size = size;
@@ skipping 14 matching lines @@
 PrinterProviderInternalReportUsbPrinterInfoFunction::
     PrinterProviderInternalReportUsbPrinterInfoFunction() {
 }
 
 PrinterProviderInternalReportUsbPrinterInfoFunction::
     ~PrinterProviderInternalReportUsbPrinterInfoFunction() {
 }
 
 ExtensionFunction::ResponseAction
 PrinterProviderInternalReportUsbPrinterInfoFunction::Run() {
-  scoped_ptr<internal_api::ReportUsbPrinterInfo::Params> params(
+  std::unique_ptr<internal_api::ReportUsbPrinterInfo::Params> params(
       internal_api::ReportUsbPrinterInfo::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   PrinterProviderInternalAPI::GetFactoryInstance()
       ->Get(browser_context())
       ->NotifyGetUsbPrinterInfoResult(extension(), params->request_id,
                                       params->printer_info.get());
   return RespondNow(NoArguments());
 }
 
 }  // namespace extensions