Use std::unique_ptr to express ownership of base::Value in PolicyMap::Entry

components/policy/core/common/policy_service_impl.cc

 // Copyright (c) 2012 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/policy_service_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "components/policy/core/common/policy_bundle.h"
 #include "components/policy/core/common/policy_map.h"
@@ skipping 17 matching lines @@
 void FixDeprecatedPolicies(PolicyMap* policies) {
   // Proxy settings have been configured by 5 policies that didn't mix well
   // together, and maps of policies had to take this into account when merging
   // policy sources. The proxy settings will eventually be configured by a
   // single Dictionary policy when all providers have support for that. For
   // now, the individual policies are mapped here to a single Dictionary policy
   // that the rest of the policy machinery uses.
 
   // The highest (level, scope) pair for an existing proxy policy is determined
   // first, and then only policies with those exact attributes are merged.
-  PolicyMap::Entry current_priority;  // Defaults to the lowest priority.
+  PolicyMap::Entry default_priority;  // Defaults to the lowest priority.
+  const PolicyMap::Entry* current_priority = &default_priority;
   PolicySource inherited_source = POLICY_SOURCE_ENTERPRISE_DEFAULT;
   std::unique_ptr<base::DictionaryValue> proxy_settings(
       new base::DictionaryValue);
   for (size_t i = 0; i < arraysize(kProxyPolicies); ++i) {
     const PolicyMap::Entry* entry = policies->Get(kProxyPolicies[i]);
     if (entry) {
-      if (entry->has_higher_priority_than(current_priority)) {
+      if (entry->has_higher_priority_than(*current_priority)) {
         proxy_settings->Clear();
-        current_priority = *entry;
+        current_priority = entry;
         if (entry->source > inherited_source)  // Higher priority?
           inherited_source = entry->source;
       }
-      if (!entry->has_higher_priority_than(current_priority) &&
-          !current_priority.has_higher_priority_than(*entry)) {
-        proxy_settings->Set(kProxyPolicies[i], entry->value->DeepCopy());
+      if (!entry->has_higher_priority_than(*current_priority) &&
+          !current_priority->has_higher_priority_than(*entry)) {
+        proxy_settings->Set(kProxyPolicies[i], entry->value->CreateDeepCopy());
       }
       policies->Erase(kProxyPolicies[i]);
     }
   }
   // Sets the new |proxy_settings| if kProxySettings isn't set yet, or if the
   // new priority is higher.
   const PolicyMap::Entry* existing = policies->Get(key::kProxySettings);
   if (!proxy_settings->empty() &&
-      (!existing || current_priority.has_higher_priority_than(*existing))) {
-    policies->Set(key::kProxySettings,
-                  current_priority.level,
-                  current_priority.scope,
-                  inherited_source,
-                  proxy_settings.release(),
-                  NULL);
+      (!existing || current_priority->has_higher_priority_than(*existing))) {
+    policies->Set(key::kProxySettings, current_priority->level,
+                  current_priority->scope, inherited_source,
+                  std::move(proxy_settings), nullptr);
   }
 }
 
 }  // namespace
 
 PolicyServiceImpl::PolicyServiceImpl(const Providers& providers)
     : update_task_ptr_factory_(this) {
   for (int domain = 0; domain < POLICY_DOMAIN_SIZE; ++domain)
     initialization_complete_[domain] = true;
   providers_ = providers;
@@ skipping 194 matching lines @@
   if (refresh_pending_.empty() && !refresh_callbacks_.empty()) {
     std::vector<base::Closure> callbacks;
     callbacks.swap(refresh_callbacks_);
     std::vector<base::Closure>::iterator it;
     for (it = callbacks.begin(); it != callbacks.end(); ++it)
       it->Run();
   }
 }
 
 }  // namespace policy