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

components/policy/core/browser/proxy_policy_handler.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/browser/proxy_policy_handler.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "components/policy/core/browser/configuration_policy_handler.h"
 #include "components/policy/core/browser/policy_error_map.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/prefs/pref_value_map.h"
 #include "components/proxy_config/proxy_config_dictionary.h"
 #include "components/proxy_config/proxy_config_pref_names.h"
 #include "grit/components_strings.h"
 #include "policy/policy_constants.h"
@@ skipping 147 matching lines @@
         proxy_mode = ProxyPrefs::MODE_DIRECT;
         NOTREACHED();
     }
   } else {
     return;
   }
 
   switch (proxy_mode) {
     case ProxyPrefs::MODE_DIRECT:
       prefs->SetValue(proxy_config::prefs::kProxy,
-                      make_scoped_ptr(ProxyConfigDictionary::CreateDirect()));
+                      base::WrapUnique(ProxyConfigDictionary::CreateDirect()));
       break;
     case ProxyPrefs::MODE_AUTO_DETECT:
       prefs->SetValue(
           proxy_config::prefs::kProxy,
-          make_scoped_ptr(ProxyConfigDictionary::CreateAutoDetect()));
+          base::WrapUnique(ProxyConfigDictionary::CreateAutoDetect()));
       break;
     case ProxyPrefs::MODE_PAC_SCRIPT: {
       std::string pac_url_string;
       if (pac_url && pac_url->GetAsString(&pac_url_string)) {
         prefs->SetValue(proxy_config::prefs::kProxy,
-                        make_scoped_ptr(ProxyConfigDictionary::CreatePacScript(
+                        base::WrapUnique(ProxyConfigDictionary::CreatePacScript(
                             pac_url_string, false)));
       } else {
         NOTREACHED();
       }
       break;
     }
     case ProxyPrefs::MODE_FIXED_SERVERS: {
       std::string proxy_server;
       std::string bypass_list_string;
       if (server->GetAsString(&proxy_server)) {
         if (bypass_list)
           bypass_list->GetAsString(&bypass_list_string);
         prefs->SetValue(
             proxy_config::prefs::kProxy,
-            make_scoped_ptr(ProxyConfigDictionary::CreateFixedServers(
+            base::WrapUnique(ProxyConfigDictionary::CreateFixedServers(
                 proxy_server, bypass_list_string)));
       }
       break;
     }
     case ProxyPrefs::MODE_SYSTEM:
       prefs->SetValue(proxy_config::prefs::kProxy,
-                      make_scoped_ptr(ProxyConfigDictionary::CreateSystem()));
+                      base::WrapUnique(ProxyConfigDictionary::CreateSystem()));
       break;
     case ProxyPrefs::kModeCount:
       NOTREACHED();
   }
 }
 
 const base::Value* ProxyPolicyHandler::GetProxyPolicyValue(
     const PolicyMap& policies, const char* policy_name) {
   // See note on the ProxyPolicyHandler implementation above.
   const base::Value* value = policies.GetValue(key::kProxySettings);
@@ skipping 109 matching lines @@
                          key::kProxyServerMode,
                          IDS_POLICY_OUT_OF_RANGE_ERROR,
                          base::IntToString(server_mode_value));
         return false;
     }
   }
   return true;
 }
 
 }  // namespace policy