Convert Pass()→std::move() in //chrome/browser/extensions

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 <map>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
@@ skipping 54 matching lines @@
   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);
   list->Append(single_elt);
-  return list.Pass();
+  return list;
 }
 
 scoped_ptr<ListValue> CreateList(Value* elt1, Value* elt2) {
   scoped_ptr<ListValue> list(new ListValue);
   list->Append(elt1);
   list->Append(elt2);
-  return list.Pass();
+  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);
   return out;
 }
 
@@ skipping 16 matching lines @@
   // 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>)>;
 
   explicit StubEventRouter(BrowserContext* context)
       : EventRouter(context, nullptr) {}
 
   void DispatchEventToExtension(const std::string& extension_id,
                                 scoped_ptr<Event> event) override {
-    event_callback_.Run(extension_id, event.Pass());
+    event_callback_.Run(extension_id, std::move(event));
   }
 
   void SetEventCallBack(EventCallback event_callback) {
     event_callback_ = event_callback;
   }
 
   void ClearEventCallback() {
     event_callback_.Reset();
   }
 
@@ skipping 15 matching lines @@
   ~AudioModemApiUnittest() override {}
 
  protected:
   template<typename Function>
   const std::string RunFunction(scoped_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(), args.Pass(), browser(), ext_test_utils::NONE);
+    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) {
-    return RunFunction<Function>(args.Pass(), GetExtension(std::string()));
+    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);
       extension_definition->SetString("name", name);
@@ skipping 195 matching lines @@
   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