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

extensions/common/features/base_feature_provider_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 "extensions/common/features/base_feature_provider.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 28 matching lines @@
   EXPECT_EQ(1, STLCount(*(extension_types), Manifest::TYPE_SHARED_MODULE));
 }
 
 // Tests that real manifest features have the correct availability for an
 // extension.
 TEST(BaseFeatureProviderTest, ManifestFeatureAvailability) {
   const FeatureProvider* provider = BaseFeatureProvider::GetByName("manifest");
 
   scoped_refptr<const Extension> extension =
       ExtensionBuilder()
-          .SetManifest(std::move(DictionaryBuilder()
-                                     .Set("name", "test extension")
-                                     .Set("version", "1")
-                                     .Set("description", "hello there")))
+          .SetManifest(DictionaryBuilder()
+                           .Set("name", "test extension")
+                           .Set("version", "1")
+                           .Set("description", "hello there")
+                           .Build())
           .Build();
   ASSERT_TRUE(extension.get());
 
   Feature* feature = provider->GetFeature("description");
   EXPECT_EQ(Feature::IS_AVAILABLE,
             feature->IsAvailableToContext(extension.get(),
                                           Feature::UNSPECIFIED_CONTEXT,
                                           GURL()).result());
 
   // This is a generic extension, so an app-only feature isn't allowed.
@@ skipping 30 matching lines @@
   EXPECT_EQ(1, STLCount(*(extension_types), Manifest::TYPE_PLATFORM_APP));
 }
 
 // Tests that real permission features have the correct availability for an app.
 TEST(BaseFeatureProviderTest, PermissionFeatureAvailability) {
   const FeatureProvider* provider =
       BaseFeatureProvider::GetByName("permission");
 
   scoped_refptr<const Extension> app =
       ExtensionBuilder()
-          .SetManifest(std::move(
+          .SetManifest(
               DictionaryBuilder()
                   .Set("name", "test app")
                   .Set("version", "1")
-                  .Set("app", std::move(DictionaryBuilder().Set(
-                                  "background",
-                                  std::move(DictionaryBuilder().Set(
-                                      "scripts", std::move(ListBuilder().Append(
-                                                     "background.js")))))))
-                  .Set("permissions",
-                       std::move(ListBuilder().Append("power")))))
+                  .Set("app",
+                       DictionaryBuilder()
+                           .Set("background",
+                                DictionaryBuilder()
+                                    .Set("scripts", ListBuilder()
+                                                        .Append("background.js")
+                                                        .Build())
+                                    .Build())
+                           .Build())
+                  .Set("permissions", ListBuilder().Append("power").Build())
+                  .Build())
           .Build();
   ASSERT_TRUE(app.get());
   ASSERT_TRUE(app->is_platform_app());
 
   // A permission requested in the manifest is available.
   Feature* feature = provider->GetFeature("power");
   EXPECT_EQ(
       Feature::IS_AVAILABLE,
       feature->IsAvailableToContext(
                    app.get(), Feature::UNSPECIFIED_CONTEXT, GURL()).result());
@@ skipping 10 matching lines @@
   // A permission that isn't part of the manifest returns NOT_PRESENT.
   feature = provider->GetFeature("serial");
   ASSERT_TRUE(feature);
   EXPECT_EQ(
       Feature::NOT_PRESENT,
       feature->IsAvailableToContext(
                    app.get(), Feature::UNSPECIFIED_CONTEXT, GURL()).result());
 }
 
 }  // namespace extensions