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

chrome/browser/extensions/api/developer_private/extension_info_generator_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 <utility>
 
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/strings/string_util.h"
@@ skipping 66 matching lines @@
         extension_id,
         base::Bind(&ExtensionInfoGeneratorUnitTest::OnInfosGenerated,
                    base::Unretained(this),
                    base::Unretained(&info)));
     run_loop.Run();
     return make_scoped_ptr(info.release());
   }
 
   const scoped_refptr<const Extension> CreateExtension(
       const std::string& name,
-      ListBuilder permissions) {
+      scoped_ptr<base::ListValue> permissions) {
     const std::string kId = crx_file::id_util::GenerateId(name);
     scoped_refptr<const Extension> extension =
         ExtensionBuilder()
-            .SetManifest(
-                std::move(DictionaryBuilder()
-                              .Set("name", name)
-                              .Set("description", "an extension")
-                              .Set("manifest_version", 2)
-                              .Set("version", "1.0.0")
-                              .Set("permissions", std::move(permissions))))
+            .SetManifest(DictionaryBuilder()
+                             .Set("name", name)
+                             .Set("description", "an extension")
+                             .Set("manifest_version", 2)
+                             .Set("version", "1.0.0")
+                             .Set("permissions", std::move(permissions))
+                             .Build())
             .SetLocation(Manifest::INTERNAL)
             .SetID(kId)
             .Build();
 
     ExtensionRegistry::Get(profile())->AddEnabled(extension);
     PermissionsUpdater(profile()).InitializePermissions(extension.get());
     return extension;
   }
 
   scoped_ptr<developer::ExtensionInfo> CreateExtensionInfoFromPath(
@@ skipping 72 matching lines @@
 
   const char kName[] = "extension name";
   const char kVersion[] = "1.0.0.1";
   std::string id = crx_file::id_util::GenerateId("alpha");
   scoped_ptr<base::DictionaryValue> manifest =
       DictionaryBuilder()
           .Set("name", kName)
           .Set("version", kVersion)
           .Set("manifest_version", 2)
           .Set("description", "an extension")
-          .Set("permissions", std::move(ListBuilder().Append("file://*/*")))
+          .Set("permissions", ListBuilder().Append("file://*/*").Build())
           .Build();
   scoped_ptr<base::DictionaryValue> manifest_copy(manifest->DeepCopy());
   scoped_refptr<const Extension> extension =
       ExtensionBuilder()
           .SetManifest(std::move(manifest))
           .SetLocation(Manifest::UNPACKED)
           .SetPath(data_dir())
           .SetID(id)
           .Build();
   service()->AddExtension(extension.get());
@@ skipping 145 matching lines @@
 
 // Test that the all_urls checkbox only shows up for extensions that want all
 // urls, and only when the switch is on.
 TEST_F(ExtensionInfoGeneratorUnitTest, ExtensionInfoRunOnAllUrls) {
   // Start with the switch enabled.
   scoped_ptr<FeatureSwitch::ScopedOverride> enable_scripts_switch(
       new FeatureSwitch::ScopedOverride(
           FeatureSwitch::scripts_require_action(), true));
   // Two extensions - one with all urls, one without.
   scoped_refptr<const Extension> all_urls_extension = CreateExtension(
-      "all_urls", std::move(ListBuilder().Append(kAllHostsPermission)));
+      "all_urls", ListBuilder().Append(kAllHostsPermission).Build());
   scoped_refptr<const Extension> no_urls_extension =
-      CreateExtension("no urls", ListBuilder());
+      CreateExtension("no urls", ListBuilder().Build());
 
   scoped_ptr<developer::ExtensionInfo> info =
       GenerateExtensionInfo(all_urls_extension->id());
 
   // The extension should want all urls, but not currently have it.
   EXPECT_TRUE(info->run_on_all_urls.is_enabled);
   EXPECT_FALSE(info->run_on_all_urls.is_active);
 
   // Give the extension all urls.
   util::SetAllowedScriptingOnAllUrls(all_urls_extension->id(), profile(), true);
@@ skipping 24 matching lines @@
 
   // If we grant the extension all urls, then the checkbox should still be
   // there, since it has an explicitly-set user preference.
   util::SetAllowedScriptingOnAllUrls(all_urls_extension->id(), profile(), true);
   info = GenerateExtensionInfo(all_urls_extension->id());
   EXPECT_TRUE(info->run_on_all_urls.is_enabled);
   EXPECT_TRUE(info->run_on_all_urls.is_active);
 
   // Load another extension with all urls (so permissions get re-init'd).
   all_urls_extension = CreateExtension(
-      "all_urls_II", std::move(ListBuilder().Append(kAllHostsPermission)));
+      "all_urls_II", ListBuilder().Append(kAllHostsPermission).Build());
 
   // Even though the extension has all_urls permission, the checkbox shouldn't
   // show up without the switch.
   info = GenerateExtensionInfo(all_urls_extension->id());
   EXPECT_FALSE(info->run_on_all_urls.is_enabled);
   EXPECT_TRUE(info->run_on_all_urls.is_active);
 }
 
 }  // namespace extensions