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

chrome/common/extensions/api/common_extension_api_unittest.cc

 // Copyright (c) 2012 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 "extensions/common/extension_api.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 187 matching lines @@
                               static_cast<int>(i),
                               test_data[i].api_full_name.c_str(),
                               expected ? "not available" : "available",
                               availability.message().c_str());
   }
 }
 
 TEST(ExtensionAPITest, IsAnyFeatureAvailableToContext) {
   scoped_refptr<const Extension> app =
       ExtensionBuilder()
-          .SetManifest(std::move(
+          .SetManifest(
               DictionaryBuilder()
                   .Set("name", "app")
-                  .Set("app", std::move(DictionaryBuilder().Set(
-                                  "background",
-                                  std::move(DictionaryBuilder().Set(
-                                      "scripts", std::move(ListBuilder().Append(
-                                                     "background.js")))))))
+                  .Set("app",
+                       DictionaryBuilder()
+                           .Set("background",
+                                DictionaryBuilder()
+                                    .Set("scripts", ListBuilder()
+                                                        .Append("background.js")
+                                                        .Build())
+                                    .Build())
+                           .Build())
                   .Set("version", "1")
-                  .Set("manifest_version", 2)))
+                  .Set("manifest_version", 2)
+                  .Build())
           .Build();
   scoped_refptr<const Extension> extension =
       ExtensionBuilder()
-          .SetManifest(std::move(DictionaryBuilder()
-                                     .Set("name", "extension")
-                                     .Set("version", "1")
-                                     .Set("manifest_version", 2)))
+          .SetManifest(DictionaryBuilder()
+                           .Set("name", "extension")
+                           .Set("version", "1")
+                           .Set("manifest_version", 2)
+                           .Build())
           .Build();
 
   struct {
     std::string api_full_name;
     bool expect_is_available;
     Feature::Context context;
     const Extension* extension;
     GURL url;
   } test_data[] = {
     { "test1", false, Feature::WEB_PAGE_CONTEXT, NULL, GURL() },
@@ skipping 590 matching lines @@
 }
 
 // Tests that permissions that require manifest keys are available when those
 // keys are present.
 TEST(ExtensionAPITest, ManifestKeys) {
   scoped_ptr<ExtensionAPI> extension_api(
       ExtensionAPI::CreateWithDefaultConfiguration());
 
   scoped_refptr<Extension> extension =
       BuildExtension(ExtensionBuilder())
-          .MergeManifest(
-              DictionaryBuilder().Set("browser_action", DictionaryBuilder()))
+          .MergeManifest(DictionaryBuilder()
+                             .Set("browser_action", DictionaryBuilder().Build())
+                             .Build())
           .Build();
 
   EXPECT_TRUE(extension_api->IsAvailable("browserAction",
                                          extension.get(),
                                          Feature::BLESSED_EXTENSION_CONTEXT,
                                          GURL()).is_available());
   EXPECT_FALSE(extension_api->IsAvailable("pageAction",
                                           extension.get(),
                                           Feature::BLESSED_EXTENSION_CONTEXT,
                                           GURL()).is_available());
 }
 
 }  // namespace extensions