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

chrome/browser/extensions/extension_message_bubble_controller_unittest.cc

 // Copyright (c) 2013 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 <stddef.h>
 
 #include <utility>
 
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
@@ skipping 132 matching lines @@
 };
 
 class ExtensionMessageBubbleTest : public BrowserWithTestWindowTest {
  public:
   ExtensionMessageBubbleTest() {}
 
   testing::AssertionResult LoadGenericExtension(const std::string& index,
                                                 const std::string& id,
                                                 Manifest::Location location) {
     ExtensionBuilder builder;
-    builder.SetManifest(
-        std::move(DictionaryBuilder()
-                      .Set("name", std::string("Extension " + index))
-                      .Set("version", "1.0")
-                      .Set("manifest_version", 2)));
+    builder.SetManifest(DictionaryBuilder()
+                            .Set("name", std::string("Extension " + index))
+                            .Set("version", "1.0")
+                            .Set("manifest_version", 2)
+                            .Build());
     builder.SetLocation(location);
     builder.SetID(id);
     service_->AddExtension(builder.Build().get());
 
     if (ExtensionRegistry::Get(profile())->enabled_extensions().GetByID(id))
       return testing::AssertionSuccess();
     return testing::AssertionFailure() << "Could not install extension: " << id;
   }
 
   testing::AssertionResult LoadExtensionWithAction(
       const std::string& index,
       const std::string& id,
       Manifest::Location location) {
     ExtensionBuilder builder;
-    builder.SetManifest(std::move(
+    builder.SetManifest(
         DictionaryBuilder()
             .Set("name", std::string("Extension " + index))
             .Set("version", "1.0")
             .Set("manifest_version", 2)
-            .Set("browser_action", std::move(DictionaryBuilder().Set(
-                                       "default_title", "Default title")))));
+            .Set("browser_action", DictionaryBuilder()
+                                       .Set("default_title", "Default title")
+                                       .Build())
+            .Build());
     builder.SetLocation(location);
     builder.SetID(id);
     service_->AddExtension(builder.Build().get());
 
     if (ExtensionRegistry::Get(profile())->enabled_extensions().GetByID(id))
       return testing::AssertionSuccess();
     return testing::AssertionFailure() << "Could not install extension: " << id;
   }
 
   testing::AssertionResult LoadExtensionOverridingHome(
       const std::string& index,
       const std::string& id,
       Manifest::Location location) {
     ExtensionBuilder builder;
-    builder.SetManifest(
-        std::move(DictionaryBuilder()
-                      .Set("name", std::string("Extension " + index))
-                      .Set("version", "1.0")
-                      .Set("manifest_version", 2)
-                      .Set("chrome_settings_overrides",
-                           std::move(DictionaryBuilder().Set(
-                               "homepage", "http://www.google.com")))));
+    builder.SetManifest(DictionaryBuilder()
+                            .Set("name", std::string("Extension " + index))
+                            .Set("version", "1.0")
+                            .Set("manifest_version", 2)
+                            .Set("chrome_settings_overrides",
+                                 DictionaryBuilder()
+                                     .Set("homepage", "http://www.google.com")
+                                     .Build())
+                            .Build());
     builder.SetLocation(location);
     builder.SetID(id);
     service_->AddExtension(builder.Build().get());
 
     if (ExtensionRegistry::Get(profile())->enabled_extensions().GetByID(id))
       return testing::AssertionSuccess();
     return testing::AssertionFailure() << "Could not install extension: " << id;
   }
 
   testing::AssertionResult LoadExtensionOverridingStart(
       const std::string& index,
       const std::string& id,
       Manifest::Location location) {
     ExtensionBuilder builder;
-    builder.SetManifest(std::move(
+    builder.SetManifest(
         DictionaryBuilder()
             .Set("name", std::string("Extension " + index))
             .Set("version", "1.0")
             .Set("manifest_version", 2)
             .Set("chrome_settings_overrides",
-                 std::move(DictionaryBuilder().Set(
-                     "startup_pages", std::move(ListBuilder().Append(
-                                          "http://www.google.com")))))));
+                 DictionaryBuilder()
+                     .Set("startup_pages",
+                          ListBuilder().Append("http://www.google.com").Build())
+                     .Build())
+            .Build());
     builder.SetLocation(location);
     builder.SetID(id);
     service_->AddExtension(builder.Build().get());
 
     if (ExtensionRegistry::Get(profile())->enabled_extensions().GetByID(id))
       return testing::AssertionSuccess();
     return testing::AssertionFailure() << "Could not install extension: " << id;
   }
 
   testing::AssertionResult LoadExtensionOverridingNtp(
       const std::string& index,
       const std::string& id,
       Manifest::Location location) {
     ExtensionBuilder builder;
-    builder.SetManifest(std::move(
+    builder.SetManifest(
         DictionaryBuilder()
             .Set("name", std::string("Extension " + index))
             .Set("version", "1.0")
             .Set("manifest_version", 2)
-            .Set("chrome_url_overrides", std::move(DictionaryBuilder().Set(
-                                             "newtab", "Default.html")))));
+            .Set("chrome_url_overrides",
+                 DictionaryBuilder().Set("newtab", "Default.html").Build())
+            .Build());
 
     builder.SetLocation(location);
     builder.SetID(id);
     service_->AddExtension(builder.Build().get());
 
     if (ExtensionRegistry::Get(profile())->enabled_extensions().GetByID(id))
       return testing::AssertionSuccess();
     return testing::AssertionFailure() << "Could not install extension: " << id;
   }
 
   testing::AssertionResult LoadExtensionOverridingProxy(
       const std::string& index,
       const std::string& id,
       Manifest::Location location) {
     ExtensionBuilder builder;
-    builder.SetManifest(std::move(
+    builder.SetManifest(
         DictionaryBuilder()
             .Set("name", std::string("Extension " + index))
             .Set("version", "1.0")
             .Set("manifest_version", 2)
-            .Set("permissions", std::move(ListBuilder().Append("proxy")))));
+            .Set("permissions", ListBuilder().Append("proxy").Build())
+            .Build());
 
     builder.SetLocation(location);
     builder.SetID(id);
     service_->AddExtension(builder.Build().get());
 
     // The proxy check relies on ExtensionPrefValueMap being up to date as to
     // specifying which extension is controlling the proxy, but unfortunately
     // that Map is not updated automatically for unit tests, so we simulate the
     // update here to avoid test failures.
     ExtensionPrefValueMap* extension_prefs_value_map =
@@ skipping 695 matching lines @@
                                extensions::UNINSTALL_REASON_FOR_TESTING,
                                base::Bind(&base::DoNothing),
                                NULL);
   service_->UninstallExtension(kId3,
                                extensions::UNINSTALL_REASON_FOR_TESTING,
                                base::Bind(&base::DoNothing),
                                NULL);
 }
 
 }  // namespace extensions