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

chrome/browser/extensions/api/audio_modem/audio_modem_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 "chrome/browser/extensions/api/audio_modem/audio_modem_api.h"
 
 #include <stdint.h>
+
 #include <map>
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/copresence/chrome_whispernet_client.h"
 #include "chrome/common/extensions/api/audio_modem.h"
 #include "extensions/browser/event_router.h"
 
 // TODO(ckehoe): Implement transmit fail checking.
 
 namespace extensions {
 
@@ skipping 68 matching lines @@
   return raw_token;
 }
 
 }  // namespace
 
 
 // Public functions.
 
 AudioModemAPI::AudioModemAPI(content::BrowserContext* context)
     : AudioModemAPI(context,
-                    make_scoped_ptr(new ChromeWhispernetClient(context)),
+                    base::WrapUnique(new ChromeWhispernetClient(context)),
                     audio_modem::Modem::Create()) {}
 
 AudioModemAPI::AudioModemAPI(
     content::BrowserContext* context,
-    scoped_ptr<audio_modem::WhispernetClient> whispernet_client,
-    scoped_ptr<audio_modem::Modem> modem)
+    std::unique_ptr<audio_modem::WhispernetClient> whispernet_client,
+    std::unique_ptr<audio_modem::Modem> modem)
     : browser_context_(context),
       whispernet_client_(std::move(whispernet_client)),
       modem_(std::move(modem)),
       init_failed_(false) {
   // We own these objects, so these callbacks will not outlive us.
   whispernet_client_->Initialize(
       base::Bind(&AudioModemAPI::WhispernetInitComplete,
                  base::Unretained(this)));
   modem_->Initialize(whispernet_client_.get(),
                      base::Bind(&AudioModemAPI::TokensReceived,
@@ skipping 120 matching lines @@
   // Send events to the appropriate app(s).
   for (const auto& app_entry : tokens_by_app) {
     const std::string& app_id = app_entry.first;
     const auto& app_tokens = app_entry.second;
     if (app_id.empty())
       continue;
 
     // Construct the event arguments by hand because a given token can be
     // present for multiple listeners, so constructing a
     // std::vector<ReceivedToken> for each is inefficient.
-    scoped_ptr<base::ListValue> tokens_value(new base::ListValue());
+    std::unique_ptr<base::ListValue> tokens_value(new base::ListValue());
     for (const ReceivedToken* token : app_tokens)
       tokens_value->Append(token->ToValue());
-    scoped_ptr<base::ListValue> args(new base::ListValue());
+    std::unique_ptr<base::ListValue> args(new base::ListValue());
     args->Append(std::move(tokens_value));
 
     EventRouter::Get(browser_context_)
         ->DispatchEventToExtension(
-            app_id, make_scoped_ptr(new Event(events::AUDIO_MODEM_ON_RECEIVED,
-                                              OnReceived::kEventName,
-                                              std::move(args))));
+            app_id, base::WrapUnique(new Event(events::AUDIO_MODEM_ON_RECEIVED,
+                                               OnReceived::kEventName,
+                                               std::move(args))));
   }
 }
 
 
 // Functions outside the API scope.
 
 template <>
 void
 BrowserContextKeyedAPIFactory<AudioModemAPI>::DeclareFactoryDependencies() {
   DependsOn(ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
 }
 
 ExtensionFunction::ResponseAction AudioModemTransmitFunction::Run() {
-  scoped_ptr<Transmit::Params> params(Transmit::Params::Create(*args_));
+  std::unique_ptr<Transmit::Params> params(Transmit::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   AudioModemAPI* api =
       AudioModemAPI::GetFactoryInstance()->Get(browser_context());
   if (api->init_failed()) {
     return RespondNow(ErrorWithArguments(
         Transmit::Results::Create(STATUS_CODERERROR),
         kInitFailedError));
   }
 
   // Check the token length.
@@ skipping 20 matching lines @@
   }
   if (timeout_millis > kMaxTransmitTimeout)
     timeout_millis = kMaxTransmitTimeout;
 
   // Start transmission.
   Status status = api->StartTransmit(extension_id(), params->params, token_str);
   return RespondNow(ArgumentList(Transmit::Results::Create(status)));
 }
 
 ExtensionFunction::ResponseAction AudioModemStopTransmitFunction::Run() {
-  scoped_ptr<StopTransmit::Params> params(StopTransmit::Params::Create(*args_));
+  std::unique_ptr<StopTransmit::Params> params(
+      StopTransmit::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   Status status = AudioModemAPI::GetFactoryInstance()->Get(browser_context())
       ->StopTransmit(extension_id(), AudioTypeForBand(params->band));
   return RespondNow(ArgumentList(StopTransmit::Results::Create(status)));
 }
 
 ExtensionFunction::ResponseAction AudioModemReceiveFunction::Run() {
-  scoped_ptr<Receive::Params> params(Receive::Params::Create(*args_));
+  std::unique_ptr<Receive::Params> params(Receive::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   AudioModemAPI* api =
       AudioModemAPI::GetFactoryInstance()->Get(browser_context());
   if (api->init_failed()) {
     return RespondNow(ErrorWithArguments(
         Transmit::Results::Create(STATUS_CODERERROR),
         kInitFailedError));
   }
 
   // Check the timeout.
   int64_t timeout_millis = params->params.timeout_millis;
   if (timeout_millis <= 0) {
     return RespondNow(ErrorWithArguments(
         Receive::Results::Create(STATUS_INVALIDREQUEST),
         kInvalidTimeoutError));
   }
   if (timeout_millis > kMaxReceiveTimeout)
     timeout_millis = kMaxReceiveTimeout;
 
   // Start receiving.
   api->StartReceive(extension_id(), params->params);
   return RespondNow(ArgumentList(Receive::Results::Create(STATUS_SUCCESS)));
 }
 
 ExtensionFunction::ResponseAction AudioModemStopReceiveFunction::Run() {
-  scoped_ptr<StopReceive::Params> params(StopReceive::Params::Create(*args_));
+  std::unique_ptr<StopReceive::Params> params(
+      StopReceive::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   Status status = AudioModemAPI::GetFactoryInstance()->Get(browser_context())
       ->StopReceive(extension_id(), AudioTypeForBand(params->band));
   return RespondNow(ArgumentList(StopReceive::Results::Create(status)));
 }
 
 }  // namespace extensions