Convert Pass()→std::move() in //components/[n-z]*

components/policy/core/common/schema_registry_tracking_policy_provider_unittest.cc

 // Copyright 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 "components/policy/core/common/schema_registry_tracking_policy_provider.h"
 
 #include <string>
+#include <utility>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "components/policy/core/common/mock_configuration_policy_provider.h"
 #include "components/policy/core/common/policy_bundle.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/policy/core/common/policy_types.h"
 #include "components/policy/core/common/schema.h"
 #include "components/policy/core/common/schema_registry.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 75 matching lines @@
   EXPECT_CALL(observer_, OnUpdatePolicy(&schema_registry_tracking_provider_));
   scoped_ptr<PolicyBundle> delegate_bundle(new PolicyBundle);
   delegate_bundle->CopyFrom(bundle);
   delegate_bundle->Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, "xyz"))
       .Set("foo",
            POLICY_LEVEL_MANDATORY,
            POLICY_SCOPE_USER,
            POLICY_SOURCE_CLOUD,
            new base::StringValue("not visible"),
            NULL);
-  mock_provider_.UpdatePolicy(delegate_bundle.Pass());
+  mock_provider_.UpdatePolicy(std::move(delegate_bundle));
   Mock::VerifyAndClearExpectations(&observer_);
 
   EXPECT_FALSE(schema_registry_tracking_provider_.IsInitializationComplete(
       POLICY_DOMAIN_EXTENSIONS));
   EXPECT_TRUE(schema_registry_tracking_provider_.policies().Equals(bundle));
 }
 
 TEST_F(SchemaRegistryTrackingPolicyProviderTest, RefreshPolicies) {
   EXPECT_CALL(mock_provider_, RefreshPolicies());
   schema_registry_tracking_provider_.RefreshPolicies();
@@ skipping 16 matching lines @@
                  POLICY_LEVEL_MANDATORY,
                  POLICY_SCOPE_USER,
                  POLICY_SOURCE_CLOUD,
                  new base::StringValue("omg"),
                  NULL);
   scoped_ptr<PolicyBundle> bundle(new PolicyBundle);
   bundle->Get(PolicyNamespace(POLICY_DOMAIN_CHROME, "")).CopyFrom(policy_map);
   bundle->Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, "xyz"))
       .CopyFrom(policy_map);
   EXPECT_CALL(observer_, OnUpdatePolicy(&schema_registry_tracking_provider_));
-  mock_provider_.UpdatePolicy(bundle.Pass());
+  mock_provider_.UpdatePolicy(std::move(bundle));
   Mock::VerifyAndClearExpectations(&observer_);
 
   EXPECT_CALL(mock_provider_, RefreshPolicies()).Times(0);
   schema_registry_.RegisterComponent(
       PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, "xyz"), CreateTestSchema());
   schema_registry_.SetReady(POLICY_DOMAIN_EXTENSIONS);
   Mock::VerifyAndClearExpectations(&mock_provider_);
 
   EXPECT_CALL(mock_provider_, RefreshPolicies());
   schema_registry_.SetReady(POLICY_DOMAIN_CHROME);
@@ skipping 73 matching lines @@
   PolicyBundle platform_policy;
   platform_policy.Get(ns).Set("foo",
                               POLICY_LEVEL_MANDATORY,
                               POLICY_SCOPE_USER,
                               POLICY_SOURCE_CLOUD,
                               new base::StringValue("omg"),
                               NULL);
   scoped_ptr<PolicyBundle> copy(new PolicyBundle);
   copy->CopyFrom(platform_policy);
   EXPECT_CALL(observer_, OnUpdatePolicy(_));
-  mock_provider_.UpdatePolicy(copy.Pass());
+  mock_provider_.UpdatePolicy(std::move(copy));
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_TRUE(
       schema_registry_tracking_provider_.policies().Equals(platform_policy));
 
   // Now remove that component.
   EXPECT_CALL(observer_, OnUpdatePolicy(_));
   schema_registry_.UnregisterComponent(ns);
   Mock::VerifyAndClearExpectations(&observer_);
   const PolicyBundle empty;
   EXPECT_TRUE(schema_registry_tracking_provider_.policies().Equals(empty));
 
   // Adding it back should serve the current policies again, even though they
   // haven't changed on the platform provider.
   EXPECT_CALL(mock_provider_, RefreshPolicies());
   schema_registry_.RegisterComponent(ns, CreateTestSchema());
   Mock::VerifyAndClearExpectations(&mock_provider_);
 
   EXPECT_CALL(observer_, OnUpdatePolicy(_));
   copy.reset(new PolicyBundle);
   copy->CopyFrom(platform_policy);
-  mock_provider_.UpdatePolicy(copy.Pass());
+  mock_provider_.UpdatePolicy(std::move(copy));
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_TRUE(
       schema_registry_tracking_provider_.policies().Equals(platform_policy));
 }
 
 }  // namespace policy