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

chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_api.cc

 // Copyright 2013 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/extensions/api/webrtc_logging_private/webrtc_logging_private_api.h"
 
 #include "base/command_line.h"
 #include "base/hash.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 133 matching lines @@
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   api::webrtc_logging_private::AudioDebugRecordingsInfo result;
   result.prefix_path = prefix_path;
   result.did_stop = did_stop;
   result.did_manual_stop = did_manual_stop;
   SetResult(result.ToValue().release());
   SendResponse(true);
 }
 
 bool WebrtcLoggingPrivateSetMetaDataFunction::RunAsync() {
-  scoped_ptr<SetMetaData::Params> params(SetMetaData::Params::Create(*args_));
+  std::unique_ptr<SetMetaData::Params> params(
+      SetMetaData::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   WebRtcLoggingHandlerHost::GenericDoneCallback callback;
   scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host =
       PrepareTask(params->request, params->security_origin, &callback);
   if (!webrtc_logging_handler_host.get())
     return false;
 
-  scoped_ptr<MetaDataMap> meta_data(new MetaDataMap());
+  std::unique_ptr<MetaDataMap> meta_data(new MetaDataMap());
   for (const MetaDataEntry& entry : params->meta_data)
     (*meta_data.get())[entry.key] = entry.value;
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
       &WebRtcLoggingHandlerHost::SetMetaData, webrtc_logging_handler_host,
       base::Passed(&meta_data), callback));
 
   return true;
 }
 
 bool WebrtcLoggingPrivateStartFunction::RunAsync() {
-  scoped_ptr<Start::Params> params(Start::Params::Create(*args_));
+  std::unique_ptr<Start::Params> params(Start::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   WebRtcLoggingHandlerHost::GenericDoneCallback callback;
   scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host =
       PrepareTask(params->request, params->security_origin, &callback);
   if (!webrtc_logging_handler_host.get())
     return false;
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
       &WebRtcLoggingHandlerHost::StartLogging, webrtc_logging_handler_host,
       callback));
 
   return true;
 }
 
 bool WebrtcLoggingPrivateSetUploadOnRenderCloseFunction::RunAsync() {
-  scoped_ptr<SetUploadOnRenderClose::Params> params(
+  std::unique_ptr<SetUploadOnRenderClose::Params> params(
       SetUploadOnRenderClose::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host(
       LoggingHandlerFromRequest(params->request, params->security_origin));
   if (!webrtc_logging_handler_host.get())
     return false;
 
   webrtc_logging_handler_host->set_upload_log_on_render_close(
       params->should_upload);
 
   return true;
 }
 
 bool WebrtcLoggingPrivateStopFunction::RunAsync() {
-  scoped_ptr<Stop::Params> params(Stop::Params::Create(*args_));
+  std::unique_ptr<Stop::Params> params(Stop::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   WebRtcLoggingHandlerHost::GenericDoneCallback callback;
   scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host =
       PrepareTask(params->request, params->security_origin, &callback);
   if (!webrtc_logging_handler_host.get())
     return false;
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
       &WebRtcLoggingHandlerHost::StopLogging, webrtc_logging_handler_host,
       callback));
 
   return true;
 }
 
 bool WebrtcLoggingPrivateStoreFunction::RunAsync() {
-  scoped_ptr<Store::Params> params(Store::Params::Create(*args_));
+  std::unique_ptr<Store::Params> params(Store::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   WebRtcLoggingHandlerHost::GenericDoneCallback callback;
   scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host =
       PrepareTask(params->request, params->security_origin, &callback);
   if (!webrtc_logging_handler_host.get())
     return false;
 
   const std::string local_log_id(HashIdWithOrigin(params->security_origin,
                                                   params->log_id));
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
       &WebRtcLoggingHandlerHost::StoreLog,
       webrtc_logging_handler_host, local_log_id, callback));
 
   return true;
 }
 
 bool WebrtcLoggingPrivateUploadStoredFunction::RunAsync() {
-  scoped_ptr<UploadStored::Params> params(UploadStored::Params::Create(*args_));
+  std::unique_ptr<UploadStored::Params> params(
+      UploadStored::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   scoped_refptr<WebRtcLoggingHandlerHost> logging_handler(
       LoggingHandlerFromRequest(params->request, params->security_origin));
   if (!logging_handler.get())
     return false;
 
   WebRtcLoggingHandlerHost::UploadDoneCallback callback = base::Bind(
       &WebrtcLoggingPrivateUploadStoredFunction::FireCallback, this);
 
   const std::string local_log_id(HashIdWithOrigin(params->security_origin,
                                                   params->log_id));
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
       &WebRtcLoggingHandlerHost::UploadStoredLog, logging_handler, local_log_id,
       callback));
 
   return true;
 }
 
 bool WebrtcLoggingPrivateUploadFunction::RunAsync() {
-  scoped_ptr<Upload::Params> params(Upload::Params::Create(*args_));
+  std::unique_ptr<Upload::Params> params(Upload::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   scoped_refptr<WebRtcLoggingHandlerHost> logging_handler(
       LoggingHandlerFromRequest(params->request, params->security_origin));
   if (!logging_handler.get())
     return false;
 
   WebRtcLoggingHandlerHost::UploadDoneCallback callback = base::Bind(
       &WebrtcLoggingPrivateUploadFunction::FireCallback, this);
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
       &WebRtcLoggingHandlerHost::UploadLog, logging_handler, callback));
 
   return true;
 }
 
 bool WebrtcLoggingPrivateDiscardFunction::RunAsync() {
-  scoped_ptr<Discard::Params> params(Discard::Params::Create(*args_));
+  std::unique_ptr<Discard::Params> params(Discard::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   WebRtcLoggingHandlerHost::GenericDoneCallback callback;
   scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host =
       PrepareTask(params->request, params->security_origin, &callback);
   if (!webrtc_logging_handler_host.get())
     return false;
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
       &WebRtcLoggingHandlerHost::DiscardLog, webrtc_logging_handler_host,
       callback));
 
   return true;
 }
 
 bool WebrtcLoggingPrivateStartRtpDumpFunction::RunAsync() {
-  scoped_ptr<StartRtpDump::Params> params(StartRtpDump::Params::Create(*args_));
+  std::unique_ptr<StartRtpDump::Params> params(
+      StartRtpDump::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   if (!params->incoming && !params->outgoing) {
     FireCallback(false, "Either incoming or outgoing must be true.");
     return true;
   }
 
   RtpDumpType type =
       (params->incoming && params->outgoing)
           ? RTP_DUMP_BOTH
@@ skipping 21 matching lines @@
                           FROM_HERE,
                           base::Bind(&WebRtcLoggingHandlerHost::StartRtpDump,
                                      webrtc_logging_handler_host,
                                      type,
                                      callback,
                                      stop_callback));
   return true;
 }
 
 bool WebrtcLoggingPrivateStopRtpDumpFunction::RunAsync() {
-  scoped_ptr<StopRtpDump::Params> params(StopRtpDump::Params::Create(*args_));
+  std::unique_ptr<StopRtpDump::Params> params(
+      StopRtpDump::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   if (!params->incoming && !params->outgoing) {
     FireCallback(false, "Either incoming or outgoing must be true.");
     return true;
   }
 
   RtpDumpType type =
       (params->incoming && params->outgoing)
           ? RTP_DUMP_BOTH
@@ skipping 18 matching lines @@
                                      callback));
   return true;
 }
 
 bool WebrtcLoggingPrivateStartAudioDebugRecordingsFunction::RunAsync() {
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableAudioDebugRecordingsFromExtension)) {
     return false;
   }
 
-  scoped_ptr<StartAudioDebugRecordings::Params> params(
+  std::unique_ptr<StartAudioDebugRecordings::Params> params(
       StartAudioDebugRecordings::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   if (params->seconds < 0) {
     FireErrorCallback("seconds must be greater than or equal to 0");
     return true;
   }
 
   content::RenderProcessHost* host =
       RphFromRequest(params->request, params->security_origin);
@@ skipping 13 matching lines @@
                  this));
   return true;
 }
 
 bool WebrtcLoggingPrivateStopAudioDebugRecordingsFunction::RunAsync() {
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableAudioDebugRecordingsFromExtension)) {
     return false;
   }
 
-  scoped_ptr<StopAudioDebugRecordings::Params> params(
+  std::unique_ptr<StopAudioDebugRecordings::Params> params(
       StopAudioDebugRecordings::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   content::RenderProcessHost* host =
       RphFromRequest(params->request, params->security_origin);
   if (!host)
     return false;
 
   scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host(
       base::UserDataAdapter<WebRtcLoggingHandlerHost>::Get(host, host));
 
   webrtc_logging_handler_host->StopAudioDebugRecordings(
       host,
       base::Bind(
           &WebrtcLoggingPrivateStopAudioDebugRecordingsFunction::FireCallback,
           this),
       base::Bind(&WebrtcLoggingPrivateStopAudioDebugRecordingsFunction::
                      FireErrorCallback,
                  this));
   return true;
 }
 
 }  // namespace extensions