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

chrome/common/pepper_permission_util_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/common/pepper_permission_util.h"
 
 #include <set>
 #include <string>
 #include <utility>
 
@@ skipping 18 matching lines @@
   scoped_ptr<base::DictionaryValue> manifest =
       DictionaryBuilder()
           .Set("name", "Has Dependent Modules")
           .Set("version", "1.0")
           .Set("manifest_version", 2)
           .Set("import", std::move(ListBuilder().Append(std::move(
                              DictionaryBuilder().Set("id", import_id)))))
           .Build();
 
   return ExtensionBuilder()
-      .SetManifest(manifest.Pass())
+      .SetManifest(std::move(manifest))
       .AddFlags(Extension::FROM_WEBSTORE)
       .SetID(id)
       .Build();
 }
 
 }  // namespace
 
 TEST(PepperPermissionUtilTest, ExtensionWhitelisting) {
   ScopedCurrentChannel current_channel(version_info::Channel::UNKNOWN);
   ExtensionSet extensions;
   std::string whitelisted_id =
       crx_file::id_util::GenerateId("whitelisted_extension");
   scoped_ptr<base::DictionaryValue> manifest =
       DictionaryBuilder()
           .Set("name", "Whitelisted Extension")
           .Set("version", "1.0")
           .Set("manifest_version", 2)
           .Build();
   scoped_refptr<Extension> ext = ExtensionBuilder()
-                                     .SetManifest(manifest.Pass())
+                                     .SetManifest(std::move(manifest))
                                      .SetID(whitelisted_id)
                                      .Build();
   extensions.Insert(ext);
   std::set<std::string> whitelist;
   std::string url = std::string("chrome-extension://") + whitelisted_id +
                     std::string("/manifest.nmf");
   std::string bad_scheme_url =
       std::string("http://") + whitelisted_id + std::string("/manifest.nmf");
   std::string bad_host_url = std::string("chrome-extension://") +
                              crx_file::id_util::GenerateId("bad_host");
@@ skipping 24 matching lines @@
           .Set("export",
                std::move(
                    DictionaryBuilder()
                        .Set("resources", std::move(ListBuilder().Append("*")))
                        // Add the extension to the whitelist.  This
                        // restricts import to |whitelisted_id| only.
                        .Set("whitelist",
                             std::move(ListBuilder().Append(whitelisted_id)))))
           .Build();
   scoped_refptr<Extension> shared_module =
-      ExtensionBuilder().SetManifest(shared_module_manifest.Pass()).Build();
+      ExtensionBuilder().SetManifest(std::move(shared_module_manifest)).Build();
 
   scoped_refptr<Extension> ext =
       CreateExtensionImportingModule(shared_module->id(), whitelisted_id);
   std::string extension_url =
       std::string("chrome-extension://") + ext->id() + std::string("/foo.html");
 
   std::set<std::string> whitelist;
   // Important: whitelist *only* the shared module.
   whitelist.insert(shared_module->id());
 
@@ skipping 19 matching lines @@
       GURL(not_in_sm_whitelist_url), &extensions, whitelist));
 
   // Note that the whitelist should be empty after this call, so tests checking
   // for failure to import will fail because of this.
   whitelist.erase(shared_module->id());
   EXPECT_FALSE(IsExtensionOrSharedModuleWhitelisted(
       GURL(extension_url), &extensions, whitelist));
 }
 
 }  // namespace extensions