Make extensions::DictionaryBuilder and extensions::ListValue unmovable.

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 13 matching lines @@
 // Return an extension with |id| which imports a module with the given
 // |import_id|.
 scoped_refptr<Extension> CreateExtensionImportingModule(
     const std::string& import_id,
     const std::string& id) {
   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)))))
+          .Set("import",
+               ListBuilder()
+                   .Append(DictionaryBuilder().Set("id", import_id).Build())
+                   .Build())
           .Build();
 
   return ExtensionBuilder()
       .SetManifest(std::move(manifest))
       .AddFlags(Extension::FROM_WEBSTORE)
       .SetID(id)
       .Build();
 }
 
 }  // namespace
@@ skipping 39 matching lines @@
   ExtensionSet extensions;
   std::string whitelisted_id = crx_file::id_util::GenerateId("extension_id");
   std::string bad_id = crx_file::id_util::GenerateId("bad_id");
 
   scoped_ptr<base::DictionaryValue> shared_module_manifest =
       DictionaryBuilder()
           .Set("name", "Whitelisted Shared Module")
           .Set("version", "1.0")
           .Set("manifest_version", 2)
           .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)))))
+               DictionaryBuilder()
+                   .Set("resources", ListBuilder().Append("*").Build())
+                   // Add the extension to the whitelist.  This
+                   // restricts import to |whitelisted_id| only.
+                   .Set("whitelist",
+                        ListBuilder().Append(whitelisted_id).Build())
+                   .Build())
           .Build();
   scoped_refptr<Extension> shared_module =
       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;
@@ skipping 22 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