Convert //components/policy from scoped_ptr to std::unique_ptr

components/policy/core/common/policy_loader_win.cc

 // Copyright (c) 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 "components/policy/core/common/policy_loader_win.h"
 
 #include <windows.h>
 #include <lm.h>       // For limits.
 #include <ntdsapi.h>  // For Ds[Un]Bind
 #include <rpc.h>      // For struct GUID
 #include <shlwapi.h>  // For PathIsUNC()
 #include <stddef.h>
 #include <userenv.h>  // For GPO functions
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/scoped_native_library.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "base/win/win_util.h"
 #include "base/win/windows_version.h"
@@ skipping 61 matching lines @@
   DOMAIN_CHECK_ERROR_GET_JOIN_INFO = 0,
   DOMAIN_CHECK_ERROR_DS_BIND = 1,
   DOMAIN_CHECK_ERROR_SIZE,  // Not a DomainCheckError.  Must be last.
 };
 
 // If the LBS extension is found and contains a schema in the registry then this
 // function is used to patch it, and make it compliant. The fix is to
 // add an "items" attribute to lists that don't declare it.
 std::string PatchSchema(const std::string& schema) {
   base::JSONParserOptions options = base::JSON_PARSE_RFC;
-  scoped_ptr<base::Value> json = base::JSONReader::Read(schema, options);
+  std::unique_ptr<base::Value> json = base::JSONReader::Read(schema, options);
   base::DictionaryValue* dict = NULL;
   base::DictionaryValue* properties = NULL;
   if (!json ||
       !json->GetAsDictionary(&dict) ||
       !dict->GetDictionary(schema::kProperties, &properties)) {
     return schema;
   }
 
   for (base::DictionaryValue::Iterator it(*properties);
        !it.IsAtEnd(); it.Advance()) {
     base::DictionaryValue* policy_schema = NULL;
     std::string type;
     if (properties->GetDictionary(it.key(), &policy_schema) &&
         policy_schema->GetString(schema::kType, &type) &&
         type == schema::kArray &&
         !policy_schema->HasKey(schema::kItems)) {
-      scoped_ptr<base::DictionaryValue> items(new base::DictionaryValue());
+      std::unique_ptr<base::DictionaryValue> items(new base::DictionaryValue());
       items->SetString(schema::kType, schema::kString);
       policy_schema->Set(schema::kItems, items.release());
     }
   }
 
   std::string serialized;
   base::JSONWriter::Write(*json, &serialized);
   return serialized;
 }
 
 // Verifies that untrusted policies contain only safe values. Modifies the
 // |policy| in place.
 void FilterUntrustedPolicy(PolicyMap* policy) {
   if (base::win::IsEnrolledToDomain())
     return;
 
   int invalid_policies = 0;
   const PolicyMap::Entry* map_entry =
       policy->Get(key::kExtensionInstallForcelist);
   if (map_entry && map_entry->value) {
     const base::ListValue* policy_list_value = NULL;
     if (!map_entry->value->GetAsList(&policy_list_value))
       return;
 
-    scoped_ptr<base::ListValue> filtered_values(new base::ListValue);
+    std::unique_ptr<base::ListValue> filtered_values(new base::ListValue);
     for (base::ListValue::const_iterator list_entry(policy_list_value->begin());
          list_entry != policy_list_value->end(); ++list_entry) {
       std::string entry;
       if (!(*list_entry)->GetAsString(&entry))
         continue;
       size_t pos = entry.find(';');
       if (pos == std::string::npos)
         continue;
       // Only allow custom update urls in enterprise environments.
       if (!base::LowerCaseEqualsASCII(entry.substr(pos),
@@ skipping 150 matching lines @@
 // Parses |gpo_dict| according to |schema| and writes the resulting policy
 // settings to |policy| for the given |scope| and |level|.
 void ParsePolicy(const RegistryDict* gpo_dict,
                  PolicyLevel level,
                  PolicyScope scope,
                  const Schema& schema,
                  PolicyMap* policy) {
   if (!gpo_dict)
     return;
 
-  scoped_ptr<base::Value> policy_value(gpo_dict->ConvertToJSON(schema));
+  std::unique_ptr<base::Value> policy_value(gpo_dict->ConvertToJSON(schema));
   const base::DictionaryValue* policy_dict = NULL;
   if (!policy_value->GetAsDictionary(&policy_dict) || !policy_dict) {
     LOG(WARNING) << "Root policy object is not a dictionary!";
     return;
   }
 
   policy->LoadFrom(policy_dict, level, scope, POLICY_SOURCE_PLATFORM);
 }
 
 // Collects stats about the enterprise environment that can be used to decide
@@ skipping 64 matching lines @@
     ::UnregisterGPNotification(user_policy_changed_event_.handle());
     user_policy_watcher_.StopWatching();
   }
   if (!machine_policy_watcher_failed_) {
     ::UnregisterGPNotification(machine_policy_changed_event_.handle());
     machine_policy_watcher_.StopWatching();
   }
 }
 
 // static
-scoped_ptr<PolicyLoaderWin> PolicyLoaderWin::Create(
+std::unique_ptr<PolicyLoaderWin> PolicyLoaderWin::Create(
     scoped_refptr<base::SequencedTaskRunner> task_runner,
     const base::string16& chrome_policy_key) {
-  return make_scoped_ptr(
-      new PolicyLoaderWin(task_runner,
-                          chrome_policy_key,
-                          g_win_gpo_list_provider.Pointer()));
+  return base::WrapUnique(new PolicyLoaderWin(

[Thiemo Nagel, 2016/04/20 20:34:19]

Optional nit: Preserving existing indentation would seem preferable to me.

[dcheng, 2016/04/20 20:56:31]

I'd prefer not to fight clang-format here. If we keep trying to fight
clang-format, future clean-up CLs will just have to keep manually reverting an
increasingly large amount of code. It's very likely that these will be rewritten
to base::MakeUnique<T>(...) at some point in the future.

+      task_runner, chrome_policy_key, g_win_gpo_list_provider.Pointer()));
 }
 
 void PolicyLoaderWin::InitOnBackgroundThread() {
   is_initialized_ = true;
   SetupWatches();
   CollectEnterpriseUMAs();
 }
 
-scoped_ptr<PolicyBundle> PolicyLoaderWin::Load() {
+std::unique_ptr<PolicyBundle> PolicyLoaderWin::Load() {
   // Reset the watches BEFORE reading the individual policies to avoid
   // missing a change notification.
   if (is_initialized_)
     SetupWatches();
 
   // Policy scope and corresponding hive.
   static const struct {
     PolicyScope scope;
     HKEY hive;
   } kScopes[] = {
     { POLICY_SCOPE_MACHINE, HKEY_LOCAL_MACHINE },
     { POLICY_SCOPE_USER,    HKEY_CURRENT_USER  },
   };
 
   bool is_enterprise = base::win::IsEnrolledToDomain();
   VLOG(1) << "Reading policy from the registry is "
           << (is_enterprise ? "enabled." : "disabled.");
 
   // Load policy data for the different scopes/levels and merge them.
-  scoped_ptr<PolicyBundle> bundle(new PolicyBundle());
+  std::unique_ptr<PolicyBundle> bundle(new PolicyBundle());
   PolicyMap* chrome_policy =
       &bundle->Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()));
   for (size_t i = 0; i < arraysize(kScopes); ++i) {
     PolicyScope scope = kScopes[i].scope;
     PolicyLoadStatusSample status;
     RegistryDict gpo_dict;
 
     // Note: GPO rules mandate a call to EnterCriticalPolicySection() here, and
     // a matching LeaveCriticalPolicySection() call below after the
     // ReadPolicyFromGPO() block. Unfortunately, the policy mutex may be
@@ skipping 12 matching lines @@
     // the additional effort this would introduce.
 
     bool is_registry_forced = is_enterprise || gpo_provider_ == nullptr;
     if (is_registry_forced || !ReadPolicyFromGPO(scope, &gpo_dict, &status)) {
       VLOG_IF(1, !is_registry_forced) << "Failed to read GPO files for "
                                       << scope << " falling back to registry.";
       gpo_dict.ReadRegistry(kScopes[i].hive, chrome_policy_key_);
     }
 
     // Remove special-cased entries from the GPO dictionary.
-    scoped_ptr<RegistryDict> recommended_dict(
+    std::unique_ptr<RegistryDict> recommended_dict(
         gpo_dict.RemoveKey(kKeyRecommended));
-    scoped_ptr<RegistryDict> third_party_dict(
+    std::unique_ptr<RegistryDict> third_party_dict(
         gpo_dict.RemoveKey(kKeyThirdParty));
 
     // Load Chrome policy.
     LoadChromePolicy(&gpo_dict, POLICY_LEVEL_MANDATORY, scope, chrome_policy);
     LoadChromePolicy(recommended_dict.get(), POLICY_LEVEL_RECOMMENDED, scope,
                      chrome_policy);
 
     // Load 3rd-party policy.
     if (third_party_dict)
       Load3rdPartyPolicy(third_party_dict.get(), scope, bundle.get());
@@ skipping 198 matching lines @@
 
 void PolicyLoaderWin::OnObjectSignaled(HANDLE object) {
   DCHECK(object == user_policy_changed_event_.handle() ||
          object == machine_policy_changed_event_.handle())
       << "unexpected object signaled policy reload, obj = "
       << std::showbase << std::hex << object;
   Reload(false);
 }
 
 }  // namespace policy