Use std::move() instead of .Pass() in remoting/host

remoting/host/policy_watcher.cc

 // Copyright 2015 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.
 
 // Most of this code is copied from:
 //   src/chrome/browser/policy/asynchronous_policy_loader.{h,cc}
 
 #include "remoting/host/policy_watcher.h"
 
 #include "base/bind.h"
@@ skipping 44 matching lines @@
 
     // If the policy isn't in |from|, use the default.
     if (!from.Get(i.key(), &value)) {
       continue;
     }
 
     CHECK(value->IsType(i.value().GetType()));
     to->Set(i.key(), value->DeepCopy());
   }
 
-  return to.Pass();
+  return to;
 }
 
 policy::PolicyNamespace GetPolicyNamespace() {
   return policy::PolicyNamespace(policy::POLICY_DOMAIN_CHROME, std::string());
 }
 
 scoped_ptr<policy::SchemaRegistry> CreateSchemaRegistry() {
   // TODO(lukasza): Schema below should ideally only cover Chromoting-specific
   // policies (expecting perf and maintanability improvement, but no functional
   // impact).
   policy::Schema schema = policy::Schema::Wrap(policy::GetChromeSchemaData());
 
   scoped_ptr<policy::SchemaRegistry> schema_registry(
       new policy::SchemaRegistry());
   schema_registry->RegisterComponent(GetPolicyNamespace(), schema);
-  return schema_registry.Pass();
+  return schema_registry;
 }
 
 scoped_ptr<base::DictionaryValue> CopyChromotingPoliciesIntoDictionary(
     const policy::PolicyMap& current) {
   const char kPolicyNameSubstring[] = "RemoteAccessHost";
   scoped_ptr<base::DictionaryValue> policy_dict(new base::DictionaryValue());
   for (auto it = current.begin(); it != current.end(); ++it) {
     const std::string& key = it->first;
     const base::Value* value = it->second.value;
 
     // Copying only Chromoting-specific policies helps avoid false alarms
     // raised by NormalizePolicies below (such alarms shutdown the host).
     // TODO(lukasza): Removing this somewhat brittle filtering will be possible
     //                after having separate, Chromoting-specific schema.
     if (key.find(kPolicyNameSubstring) != std::string::npos) {
       policy_dict->Set(key, value->DeepCopy());
     }
   }
 
-  return policy_dict.Pass();
+  return policy_dict;
 }
 
 // Takes a dictionary containing only 1) recognized policy names and 2)
 // well-typed policy values and further verifies policy contents.
 bool VerifyWellformedness(const base::DictionaryValue& changed_policies) {
   // Verify ThirdPartyAuthConfig policy.
   ThirdPartyAuthConfig not_used;
   switch (ThirdPartyAuthConfig::Parse(changed_policies, &not_used)) {
     case ThirdPartyAuthConfig::NoPolicy:
     case ThirdPartyAuthConfig::ParsingSuccess:
@@ skipping 47 matching lines @@
 }
 
 PolicyWatcher::PolicyWatcher(
     policy::PolicyService* policy_service,
     scoped_ptr<policy::PolicyService> owned_policy_service,
     scoped_ptr<policy::ConfigurationPolicyProvider> owned_policy_provider,
     scoped_ptr<policy::SchemaRegistry> owned_schema_registry)
     : old_policies_(new base::DictionaryValue()),
       default_values_(new base::DictionaryValue()),
       policy_service_(policy_service),
-      owned_schema_registry_(owned_schema_registry.Pass()),
-      owned_policy_provider_(owned_policy_provider.Pass()),
-      owned_policy_service_(owned_policy_service.Pass()) {
+      owned_schema_registry_(std::move(owned_schema_registry)),
+      owned_policy_provider_(std::move(owned_policy_provider)),
+      owned_policy_service_(std::move(owned_policy_service)) {
   DCHECK(policy_service_);
   DCHECK(owned_schema_registry_);
 
   // Initialize the default values for each policy.
   default_values_->SetBoolean(key::kRemoteAccessHostFirewallTraversal, true);
   default_values_->SetBoolean(key::kRemoteAccessHostRequireCurtain, false);
   default_values_->SetBoolean(key::kRemoteAccessHostMatchUsername, false);
   default_values_->SetString(key::kRemoteAccessHostDomain, std::string());
   default_values_->SetString(key::kRemoteAccessHostTalkGadgetPrefix,
                              kDefaultHostTalkGadgetPrefix);
@@ skipping 85 matching lines @@
                         key::kRemoteAccessHostTokenUrl);
     CopyDictionaryValue(*new_policies, *changed_policies,
                         key::kRemoteAccessHostTokenValidationUrl);
     CopyDictionaryValue(*new_policies, *changed_policies,
                         key::kRemoteAccessHostTokenValidationCertificateIssuer);
   }
 
   // Save the new policies.
   old_policies_.swap(new_policies);
 
-  return changed_policies.Pass();
+  return changed_policies;
 }
 
 void PolicyWatcher::OnPolicyUpdated(const policy::PolicyNamespace& ns,
                                     const policy::PolicyMap& previous,
                                     const policy::PolicyMap& current) {
   scoped_ptr<base::DictionaryValue> new_policies =
       CopyChromotingPoliciesIntoDictionary(current);
 
   // Check for mistyped values and get rid of unknown policies.
   if (!NormalizePolicies(new_policies.get())) {
     SignalPolicyError();
     return;
   }
 
   // Use default values for any missing policies.
   scoped_ptr<base::DictionaryValue> filled_policies =
       CopyValuesAndAddDefaults(*new_policies, *default_values_);
 
   // Limit reporting to only the policies that were changed.
   scoped_ptr<base::DictionaryValue> changed_policies =
-      StoreNewAndReturnChangedPolicies(filled_policies.Pass());
+      StoreNewAndReturnChangedPolicies(std::move(filled_policies));
   if (changed_policies->empty()) {
     return;
   }
 
   // Verify that we are calling the callback with valid policies.
   if (!VerifyWellformedness(*changed_policies)) {
     SignalPolicyError();
     return;
   }
 
   // Notify our client of the changed policies.
-  policy_updated_callback_.Run(changed_policies.Pass());
+  policy_updated_callback_.Run(std::move(changed_policies));
 }
 
 void PolicyWatcher::OnPolicyServiceInitialized(policy::PolicyDomain domain) {
   policy::PolicyNamespace ns = GetPolicyNamespace();
   const policy::PolicyMap& current = policy_service_->GetPolicies(ns);
   OnPolicyUpdated(ns, current, current);
 }
 
 scoped_ptr<PolicyWatcher> PolicyWatcher::CreateFromPolicyLoader(
     scoped_ptr<policy::AsyncPolicyLoader> async_policy_loader) {
   scoped_ptr<policy::SchemaRegistry> schema_registry = CreateSchemaRegistry();
   scoped_ptr<policy::AsyncPolicyProvider> policy_provider(
       new policy::AsyncPolicyProvider(schema_registry.get(),
-                                      async_policy_loader.Pass()));
+                                      std::move(async_policy_loader)));
   policy_provider->Init(schema_registry.get());
 
   policy::PolicyServiceImpl::Providers providers;
   providers.push_back(policy_provider.get());
   scoped_ptr<policy::PolicyService> policy_service(
       new policy::PolicyServiceImpl(providers));
 
   policy::PolicyService* borrowed_policy_service = policy_service.get();
-  return make_scoped_ptr(
-      new PolicyWatcher(borrowed_policy_service, policy_service.Pass(),
-                        policy_provider.Pass(), schema_registry.Pass()));
+  return make_scoped_ptr(new PolicyWatcher(
+      borrowed_policy_service, std::move(policy_service),
+      std::move(policy_provider), std::move(schema_registry)));
 }
 
 scoped_ptr<PolicyWatcher> PolicyWatcher::Create(
     policy::PolicyService* policy_service,
     const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner) {
 #if defined(OS_CHROMEOS)
   // On Chrome OS the PolicyService is owned by the browser.
   DCHECK(policy_service);
   return make_scoped_ptr(new PolicyWatcher(policy_service, nullptr, nullptr,
                                            CreateSchemaRegistry()));
@@ skipping 16 matching lines @@
       new MacPreferences(), bundle_id));
 #elif defined(OS_POSIX) && !defined(OS_ANDROID)
   policy_loader.reset(new policy::ConfigDirPolicyLoader(
       file_task_runner,
       base::FilePath(FILE_PATH_LITERAL("/etc/opt/chrome/policies")),
       policy::POLICY_SCOPE_MACHINE));
 #else
 #error OS that is not yet supported by PolicyWatcher code.
 #endif
 
-  return PolicyWatcher::CreateFromPolicyLoader(policy_loader.Pass());
+  return PolicyWatcher::CreateFromPolicyLoader(std::move(policy_loader));
 #endif  // !(OS_CHROMEOS)
 }
 
 }  // namespace remoting