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

chrome/browser/extensions/shared_module_service_unittest.cc

 // Copyright 2014 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/shared_module_service.h"
 
 #include <utility>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 25 matching lines @@
   DictionaryBuilder builder;
   builder.Set("name", "Has Dependent Modules")
          .Set("version", version)
          .Set("manifest_version", 2);
   if (!import_id.empty()) {
     builder.Set("import", std::move(ListBuilder().Append(std::move(
                               DictionaryBuilder().Set("id", import_id)))));
   }
   scoped_ptr<base::DictionaryValue> manifest = builder.Build();
 
-  return ExtensionBuilder().SetManifest(manifest.Pass())
-                           .AddFlags(Extension::FROM_WEBSTORE)
-                           .SetID(id)
-                           .Build();
+  return ExtensionBuilder()
+      .SetManifest(std::move(manifest))
+      .AddFlags(Extension::FROM_WEBSTORE)
+      .SetID(id)
+      .Build();
 }
 
 }  // namespace
 
 class SharedModuleServiceUnitTest : public ExtensionServiceTestBase {
  public:
   SharedModuleServiceUnitTest() :
       // The "export" key is open for dev-channel only, but unit tests
       // run as stable channel on the official Windows build.
       current_channel_(version_info::Channel::UNKNOWN) {}
@@ skipping 68 matching lines @@
       DictionaryBuilder()
           .Set("name", "Shared Module")
           .Set("version", "1.0")
           .Set("manifest_version", 2)
           .Set("export",
                std::move(DictionaryBuilder().Set(
                    "resources", std::move(ListBuilder().Append("foo.js")))))
           .Build();
   scoped_refptr<Extension> shared_module =
       ExtensionBuilder()
-          .SetManifest(manifest.Pass())
+          .SetManifest(std::move(manifest))
           .AddFlags(Extension::FROM_WEBSTORE)
           .SetID(crx_file::id_util::GenerateId("shared_module"))
           .Build();
 
   EXPECT_TRUE(InstallExtension(shared_module.get(), false));
 
   std::string extension_id = crx_file::id_util::GenerateId("extension_id");
   // Create and install an extension that imports our new module.
   scoped_refptr<Extension> importing_extension =
       CreateExtensionImportingModule(shared_module->id(), extension_id, "1.0");
@@ skipping 20 matching lines @@
       DictionaryBuilder()
           .Set("name", "Shared Module 1")
           .Set("version", "1.0")
           .Set("manifest_version", 2)
           .Set("export",
                std::move(DictionaryBuilder().Set(
                    "resources", std::move(ListBuilder().Append("foo.js")))))
           .Build();
   scoped_refptr<Extension> shared_module_1 =
       ExtensionBuilder()
-          .SetManifest(manifest_1.Pass())
+          .SetManifest(std::move(manifest_1))
           .AddFlags(Extension::FROM_WEBSTORE)
           .SetID(crx_file::id_util::GenerateId("shared_module_1"))
           .Build();
   EXPECT_TRUE(InstallExtension(shared_module_1.get(), false));
 
   scoped_ptr<base::DictionaryValue> manifest_2 =
       DictionaryBuilder()
           .Set("name", "Shared Module 2")
           .Set("version", "1.0")
           .Set("manifest_version", 2)
           .Set("export",
                std::move(DictionaryBuilder().Set(
                    "resources", std::move(ListBuilder().Append("foo.js")))))
           .Build();
   scoped_refptr<Extension> shared_module_2 =
       ExtensionBuilder()
-          .SetManifest(manifest_2.Pass())
+          .SetManifest(std::move(manifest_2))
           .AddFlags(Extension::FROM_WEBSTORE)
           .SetID(crx_file::id_util::GenerateId("shared_module_2"))
           .Build();
   EXPECT_TRUE(InstallExtension(shared_module_2.get(), false));
 
   std::string extension_id = crx_file::id_util::GenerateId("extension_id");
 
   // Create and install an extension v1.0 that imports our new module 1.
   scoped_refptr<Extension> importing_extension_1 =
       CreateExtensionImportingModule(shared_module_1->id(),
@@ skipping 43 matching lines @@
           .Set("manifest_version", 2)
           .Set("export",
                std::move(
                    DictionaryBuilder()
                        .Set("whitelist",
                             std::move(ListBuilder().Append(whitelisted_id)))
                        .Set("resources", std::move(ListBuilder().Append("*")))))
           .Build();
   scoped_refptr<Extension> shared_module =
       ExtensionBuilder()
-          .SetManifest(manifest.Pass())
+          .SetManifest(std::move(manifest))
           .AddFlags(Extension::FROM_WEBSTORE)
           .SetID(crx_file::id_util::GenerateId("shared_module"))
           .Build();
 
   EXPECT_TRUE(InstallExtension(shared_module.get(), false));
 
   // Create and install an extension with the whitelisted ID.
   scoped_refptr<Extension> whitelisted_extension =
       CreateExtensionImportingModule(shared_module->id(),
                                      whitelisted_id,
                                      "1.0");
   EXPECT_TRUE(InstallExtension(whitelisted_extension.get(), false));
 
   // Try to install an extension with an ID that is not whitelisted.
   scoped_refptr<Extension> nonwhitelisted_extension =
       CreateExtensionImportingModule(shared_module->id(),
                                      nonwhitelisted_id,
                                      "1.0");
   // This should succeed because only CRX installer (and by extension the
   // WebStore Installer) checks the shared module whitelist.  InstallExtension
   // bypasses the whitelist check because the SharedModuleService does not
   // care about whitelists.
   EXPECT_TRUE(InstallExtension(nonwhitelisted_extension.get(), false));
 }
 
 }  // namespace extensions