Convert callers of base::DeepCopy() to base::CreateDeepCopy() in //remoting

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 <utility>
@@ skipping 34 matching lines @@
 
 namespace key = ::policy::key;
 
 namespace {
 
 // Copies all policy values from one dictionary to another, using values from
 // |default_values| if they are not set in |from|.
 std::unique_ptr<base::DictionaryValue> CopyValuesAndAddDefaults(
     const base::DictionaryValue& from,
     const base::DictionaryValue& default_values) {
-  std::unique_ptr<base::DictionaryValue> to(default_values.DeepCopy());
+  std::unique_ptr<base::DictionaryValue> to(default_values.CreateDeepCopy());
   for (base::DictionaryValue::Iterator i(default_values); !i.IsAtEnd();
        i.Advance()) {
     const base::Value* value = nullptr;
 
     // 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());
+    to->Set(i.key(), value->CreateDeepCopy());
   }
 
   return to;
 }
 
 policy::PolicyNamespace GetPolicyNamespace() {
   return policy::PolicyNamespace(policy::POLICY_DOMAIN_CHROME, std::string());
 }
 
 std::unique_ptr<policy::SchemaRegistry> CreateSchemaRegistry() {
@@ skipping 15 matching lines @@
       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());
+      policy_dict->Set(key, value->CreateDeepCopy());
     }
   }
 
   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.
@@ skipping 123 matching lines @@
     return false;
   }
 }
 
 namespace {
 void CopyDictionaryValue(const base::DictionaryValue& from,
                          base::DictionaryValue& to,
                          std::string key) {
   const base::Value* value;
   if (from.Get(key, &value)) {
-    to.Set(key, value->DeepCopy());
+    to.Set(key, value->CreateDeepCopy());
   }
 }
 }  // namespace
 
 std::unique_ptr<base::DictionaryValue>
 PolicyWatcher::StoreNewAndReturnChangedPolicies(
     std::unique_ptr<base::DictionaryValue> new_policies) {
   // Find the changed policies.
   std::unique_ptr<base::DictionaryValue> changed_policies(
       new base::DictionaryValue());
   base::DictionaryValue::Iterator iter(*new_policies);
   while (!iter.IsAtEnd()) {
     base::Value* old_policy;
     if (!(old_policies_->Get(iter.key(), &old_policy) &&
           old_policy->Equals(&iter.value()))) {
-      changed_policies->Set(iter.key(), iter.value().DeepCopy());
+      changed_policies->Set(iter.key(), iter.value().CreateDeepCopy());
     }
     iter.Advance();
   }
 
   // If one of ThirdPartyAuthConfig policies changed, we need to include all.
   if (changed_policies->HasKey(key::kRemoteAccessHostTokenUrl) ||
       changed_policies->HasKey(key::kRemoteAccessHostTokenValidationUrl) ||
       changed_policies->HasKey(
           key::kRemoteAccessHostTokenValidationCertificateIssuer)) {
     CopyDictionaryValue(*new_policies, *changed_policies,
@@ skipping 109 matching lines @@
       CreateSchemaRegistry()));
 #else
 #error OS that is not yet supported by PolicyWatcher code.
 #endif
 
   return PolicyWatcher::CreateFromPolicyLoader(std::move(policy_loader));
 #endif  // !(OS_CHROMEOS)
 }
 
 }  // namespace remoting