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

chrome/common/extensions/features/chrome_channel_feature_filter_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/extensions/features/chrome_channel_feature_filter.h"
 
 #include <string>
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 161 matching lines @@
   provider.reset(
       new BaseFeatureProvider(*value, CreateFeature<PermissionFeature>));
   EXPECT_TRUE(provider->GetFeature("feature2"));
 }
 
 // Tests simple feature availability across channels.
 TEST_F(ChromeChannelFeatureFilterTest, SimpleFeatureAvailability) {
   scoped_ptr<base::DictionaryValue> rule(
       DictionaryBuilder()
           .Set("feature1",
-               std::move(ListBuilder()
-                             .Append(std::move(
-                                 DictionaryBuilder()
-                                     .Set("channel", "beta")
-                                     .Set("extension_types",
-                                          std::move(ListBuilder().Append(
-                                              "extension")))))
-                             .Append(std::move(
-                                 DictionaryBuilder()
-                                     .Set("channel", "beta")
-                                     .Set("extension_types",
-                                          std::move(ListBuilder().Append(
-                                              "legacy_packaged_app")))))))
+               ListBuilder()
+                   .Append(DictionaryBuilder()
+                               .Set("channel", "beta")
+                               .Set("extension_types",
+                                    ListBuilder().Append("extension").Build())
+                               .Build())
+                   .Append(DictionaryBuilder()
+                               .Set("channel", "beta")
+                               .Set("extension_types",
+                                    ListBuilder()
+                                        .Append("legacy_packaged_app")
+                                        .Build())
+                               .Build())
+                   .Build())
           .Build());
 
   scoped_ptr<BaseFeatureProvider> provider(
       new BaseFeatureProvider(*rule, CreateFeature<SimpleFeature>));
 
   Feature* feature = provider->GetFeature("feature1");
   EXPECT_TRUE(feature);
 
   // Make sure both rules are applied correctly.
   {
@@ skipping 31 matching lines @@
 // Tests complex feature availability across channels.
 TEST_F(ChromeChannelFeatureFilterTest, ComplexFeatureAvailability) {
   scoped_ptr<ComplexFeature::FeatureList> features(
       new ComplexFeature::FeatureList());
 
   // Rule: "extension", channel trunk.
   scoped_ptr<SimpleFeature> simple_feature(CreateFeature<SimpleFeature>());
   scoped_ptr<base::DictionaryValue> rule(
       DictionaryBuilder()
           .Set("channel", "trunk")
-          .Set("extension_types", std::move(ListBuilder().Append("extension")))
+          .Set("extension_types", ListBuilder().Append("extension").Build())
           .Build());
   simple_feature->Parse(rule.get());
   features->push_back(std::move(simple_feature));
 
   // Rule: "legacy_packaged_app", channel stable.
   simple_feature.reset(CreateFeature<SimpleFeature>());
   rule = DictionaryBuilder()
              .Set("channel", "stable")
              .Set("extension_types",
-                  std::move(ListBuilder().Append("legacy_packaged_app")))
+                  ListBuilder().Append("legacy_packaged_app").Build())
              .Build();
   simple_feature->Parse(rule.get());
   features->push_back(std::move(simple_feature));
 
   scoped_ptr<ComplexFeature> feature(new ComplexFeature(std::move(features)));
 
   // Test match 1st rule.
   {
     ScopedCurrentChannel current_channel(version_info::Channel::UNKNOWN);
     EXPECT_EQ(
@@ skipping 24 matching lines @@
         Feature::IS_AVAILABLE,
         feature->IsAvailableToManifest("1",
                                        Manifest::TYPE_EXTENSION,
                                        Manifest::INVALID_LOCATION,
                                        Feature::UNSPECIFIED_PLATFORM,
                                        Feature::GetCurrentPlatform()).result());
   }
 }
 
 }  // namespace extensions