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

chrome/browser/extensions/api/audio_modem/audio_modem_api_unittest.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 <map>
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/values.h"
-#include "chrome/browser/extensions/api/audio_modem/audio_modem_api.h"
 #include "chrome/browser/extensions/extension_api_unittest.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "components/audio_modem/public/modem.h"
 #include "components/audio_modem/test/stub_modem.h"
 #include "components/audio_modem/test/stub_whispernet_client.h"
 #include "extensions/browser/api_test_utils.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/event_router_factory.h"
 
@@ skipping 16 matching lines @@
 namespace extensions {
 
 namespace {
 
 // The TestingFactoryFunction uses a BrowserContext as its context pointer.
 // But each BrowserContext is still associated with a unit test.
 // So we store the StubModem created in each test.
 std::map<BrowserContext*, StubModem*> g_modems;
 
 // Create a test AudioModemAPI and store the modem it uses.
-scoped_ptr<KeyedService> ApiFactoryFunction(BrowserContext* context) {
+std::unique_ptr<KeyedService> ApiFactoryFunction(BrowserContext* context) {
   StubModem* modem = new StubModem;
   g_modems[context] = modem;
-  return make_scoped_ptr(new AudioModemAPI(
+  return base::WrapUnique(new AudioModemAPI(
       context,
-      make_scoped_ptr<audio_modem::WhispernetClient>(new StubWhispernetClient),
-      make_scoped_ptr<audio_modem::Modem>(modem)));
+      base::WrapUnique<audio_modem::WhispernetClient>(new StubWhispernetClient),
+      base::WrapUnique<audio_modem::Modem>(modem)));
 }
 
 DictionaryValue* CreateParams(const std::string& audio_band) {
   DictionaryValue* params = new DictionaryValue;
   params->SetInteger("timeoutMillis", 60000);
   params->SetString("band", audio_band);
   params->SetInteger("encoding.tokenLength", 4);
   return params;
 }
 
 BinaryValue* CreateToken(const std::string& token) {
   return BinaryValue::CreateWithCopiedBuffer(token.c_str(), token.size());
 }
 
-scoped_ptr<ListValue> CreateList(Value* single_elt) {
-  scoped_ptr<ListValue> list(new ListValue);
+std::unique_ptr<ListValue> CreateList(Value* single_elt) {
+  std::unique_ptr<ListValue> list(new ListValue);
   list->Append(single_elt);
   return list;
 }
 
-scoped_ptr<ListValue> CreateList(Value* elt1, Value* elt2) {
-  scoped_ptr<ListValue> list(new ListValue);
+std::unique_ptr<ListValue> CreateList(Value* elt1, Value* elt2) {
+  std::unique_ptr<ListValue> list(new ListValue);
   list->Append(elt1);
   list->Append(elt2);
   return list;
 }
 
 DictionaryValue* CreateReceivedToken(const std::string& token,
                                      const std::string& audio_band) {
   DictionaryValue* out = new DictionaryValue;
   out->Set("token", CreateToken(token));
   out->SetString("band", audio_band);
@@ skipping 11 matching lines @@
   received_tokens->GetDictionary(0, &received_token);
   return received_token->Equals(expected_token);
 }
 
 // TODO(ckehoe): Put this in //extensions/test.
 // Then replace the other EventRouter mocks.
 class StubEventRouter : public EventRouter {
  public:
   // Callback to receive events. First argument is
   // the extension id to receive the event.
-  using EventCallback = base::Callback<void(const std::string&,
-                                            scoped_ptr<Event>)>;
+  using EventCallback =
+      base::Callback<void(const std::string&, std::unique_ptr<Event>)>;
 
   explicit StubEventRouter(BrowserContext* context)
       : EventRouter(context, nullptr) {}
 
   void DispatchEventToExtension(const std::string& extension_id,
-                                scoped_ptr<Event> event) override {
+                                std::unique_ptr<Event> event) override {
     event_callback_.Run(extension_id, std::move(event));
   }
 
   void SetEventCallBack(EventCallback event_callback) {
     event_callback_ = event_callback;
   }
 
   void ClearEventCallback() {
     event_callback_.Reset();
   }
 
  private:
   EventCallback event_callback_;
 };
 
 // StubEventRouter factory function
-scoped_ptr<KeyedService> StubEventRouterFactoryFunction(
+std::unique_ptr<KeyedService> StubEventRouterFactoryFunction(
     content::BrowserContext* context) {
-  return make_scoped_ptr(new StubEventRouter(context));
+  return base::WrapUnique(new StubEventRouter(context));
 }
 
 }  // namespace
 
 class AudioModemApiUnittest : public ExtensionApiUnittest {
  public:
   AudioModemApiUnittest() {}
   ~AudioModemApiUnittest() override {}
 
  protected:
-  template<typename Function>
-  const std::string RunFunction(scoped_ptr<ListValue> args,
+  template <typename Function>
+  const std::string RunFunction(std::unique_ptr<ListValue> args,
                                 const Extension* extension) {
     scoped_refptr<UIThreadExtensionFunction> function(new Function);
     function->set_extension(extension);
     function->set_browser_context(profile());
     function->set_has_callback(true);
     ext_test_utils::RunFunction(function.get(), std::move(args), browser(),
                                 ext_test_utils::NONE);
 
     std::string result_status;
     CHECK(function->GetResultList()->GetString(0, &result_status));
     return result_status;
   }
 
-  template<typename Function>
-  const std::string RunFunction(scoped_ptr<ListValue> args) {
+  template <typename Function>
+  const std::string RunFunction(std::unique_ptr<ListValue> args) {
     return RunFunction<Function>(std::move(args), GetExtension(std::string()));
   }
 
   StubModem* GetModem() const {
     return g_modems[profile()];
   }
 
   const Extension* GetExtension(const std::string& name) {
     if (!extensions_by_name_[name].get()) {
-      scoped_ptr<DictionaryValue> extension_definition(new DictionaryValue);
+      std::unique_ptr<DictionaryValue> extension_definition(
+          new DictionaryValue);
       extension_definition->SetString("name", name);
       extension_definition->SetString("version", "1.0");
       extensions_by_name_[name] = api_test_utils::CreateExtension(
           Manifest::INTERNAL, extension_definition.get(), name);
       DVLOG(2) << "Created extension " << extensions_by_name_[name]->id();
     }
     return extensions_by_name_[name].get();
   }
 
-  const std::vector<scoped_ptr<const Event>>& GetEventsForExtension(
+  const std::vector<std::unique_ptr<const Event>>& GetEventsForExtension(
       const std::string& name) {
     const Extension* extension = extensions_by_name_[name].get();
     DCHECK(extension);
     return events_by_extension_id_[extension->id()];
   }
 
-  const std::vector<scoped_ptr<const Event>>& GetEvents() {
+  const std::vector<std::unique_ptr<const Event>>& GetEvents() {
     return GetEventsForExtension(std::string());
   }
 
  private:
   void SetUp() override {
     ExtensionApiUnittest::SetUp();
     AudioModemAPI::GetFactoryInstance()->SetTestingFactory(
         profile(), &ApiFactoryFunction);
 
     StubEventRouter* stub_event_router = static_cast<StubEventRouter*>(
         extensions::EventRouterFactory::GetInstance()->SetTestingFactoryAndUse(
             profile(), &StubEventRouterFactoryFunction));
     stub_event_router->SetEventCallBack(base::Bind(
         &AudioModemApiUnittest::CaptureEvent, base::Unretained(this)));
   }
 
   void CaptureEvent(const std::string& extension_id,
-                    scoped_ptr<Event> event) {
+                    std::unique_ptr<Event> event) {
     events_by_extension_id_[extension_id].push_back(std::move(event));
   }
 
   std::map<std::string, scoped_refptr<Extension>> extensions_by_name_;
 
-  std::map<std::string, std::vector<scoped_ptr<const Event>>>
+  std::map<std::string, std::vector<std::unique_ptr<const Event>>>
       events_by_extension_id_;
 };
 
 TEST_F(AudioModemApiUnittest, TransmitBasic) {
   // Start transmitting inaudibly.
   EXPECT_EQ("success", RunFunction<AudioModemTransmitFunction>(
       CreateList(CreateParams("inaudible"), CreateToken("1234"))));
   EXPECT_TRUE(GetModem()->IsPlaying(INAUDIBLE));
 
   // Can't cancel audible transmit - we haven't started it yet.
@@ skipping 29 matching lines @@
 
   // Send some audible tokens.
   std::vector<AudioToken> tokens;
   tokens.push_back(AudioToken("1234", true));
   tokens.push_back(AudioToken("ABCD", true));
   tokens.push_back(AudioToken("abcd", false));
   GetModem()->DeliverTokens(tokens);
 
   // Check the tokens received.
   EXPECT_EQ(1u, GetEvents().size());
-  scoped_ptr<ListValue> expected_tokens(new ListValue);
+  std::unique_ptr<ListValue> expected_tokens(new ListValue);
   expected_tokens->Append(CreateReceivedToken("1234", "audible"));
   expected_tokens->Append(CreateReceivedToken("ABCD", "audible"));
   ListValue* received_tokens;
   GetEvents()[0]->event_args->GetList(0, &received_tokens);
   EXPECT_TRUE(received_tokens->Equals(expected_tokens.get()));
 
   // Start listening for inaudible tokens.
   EXPECT_EQ("success", RunFunction<AudioModemReceiveFunction>(
       CreateList(CreateParams("inaudible"))));
   EXPECT_TRUE(GetModem()->IsRecording(INAUDIBLE));
@@ skipping 68 matching lines @@
   EXPECT_EQ("success", RunFunction<AudioModemReceiveFunction>(
       CreateList(CreateParams("inaudible")), GetExtension("ext2")));
 
   // Receive a token.
   GetModem()->DeliverTokens(std::vector<AudioToken>(
       1, AudioToken("abcd", false)));
   EXPECT_EQ(1u, GetEventsForExtension("ext1").size());
   EXPECT_EQ(1u, GetEventsForExtension("ext2").size());
 
   // Check the token received.
-  scoped_ptr<DictionaryValue> expected_token(
+  std::unique_ptr<DictionaryValue> expected_token(
       CreateReceivedToken("abcd", "inaudible"));
   EXPECT_TRUE(ReceivedSingleToken(GetEventsForExtension("ext1")[0].get(),
                                   expected_token.get()));
   EXPECT_TRUE(ReceivedSingleToken(GetEventsForExtension("ext2")[0].get(),
                                   expected_token.get()));
 
   // If one extension stops, the modem is still receiving for the other.
   EXPECT_EQ("success", RunFunction<AudioModemStopReceiveFunction>(
       CreateList(new StringValue("inaudible")), GetExtension("ext1")));
   EXPECT_TRUE(GetModem()->IsRecording(INAUDIBLE));
 
   // Receive another token. Should only go to ext2.
   GetModem()->DeliverTokens(std::vector<AudioToken>(
       1, AudioToken("1234", false)));
   EXPECT_EQ(1u, GetEventsForExtension("ext1").size());
   EXPECT_EQ(2u, GetEventsForExtension("ext2").size());
   expected_token.reset(CreateReceivedToken("1234", "inaudible"));
   EXPECT_TRUE(ReceivedSingleToken(GetEventsForExtension("ext2")[1].get(),
                                   expected_token.get()));
 
   EXPECT_EQ("success", RunFunction<AudioModemStopReceiveFunction>(
       CreateList(new StringValue("inaudible")), GetExtension("ext2")));
   EXPECT_FALSE(GetModem()->IsRecording(INAUDIBLE));
 }
 
 }  // namespace extensions