Convert //components/[u-z]* from scoped_ptr to std::unique_ptr

components/wifi/wifi_service_win.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/wifi/wifi_service.h"
 
 #include <iphlpapi.h>
 #include <objbase.h>
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 180 matching lines @@
 
   void GetManagedProperties(const std::string& network_guid,
                             base::DictionaryValue* managed_properties,
                             std::string* error) override;
 
   void GetState(const std::string& network_guid,
                 base::DictionaryValue* properties,
                 std::string* error) override;
 
   void SetProperties(const std::string& network_guid,
-                     scoped_ptr<base::DictionaryValue> properties,
+                     std::unique_ptr<base::DictionaryValue> properties,
                      std::string* error) override;
 
   void CreateNetwork(bool shared,
-                     scoped_ptr<base::DictionaryValue> properties,
+                     std::unique_ptr<base::DictionaryValue> properties,
                      std::string* network_guid,
                      std::string* error) override;
 
   void GetVisibleNetworks(const std::string& network_type,
                           base::ListValue* network_list,
                           bool include_details) override;
 
   void RequestNetworkScan() override;
 
   void StartConnect(const std::string& network_guid,
@@ skipping 161 matching lines @@
   DWORD Disconnect();
 
   // Get desired connection freqency if it was set using |SetProperties|.
   // Default to |kFrequencyAny|.
   Frequency GetFrequencyToConnect(const std::string& network_guid) const;
 
   // Get DOT11_BSSID_LIST of desired BSSIDs to connect to |ssid| network on
   // given |frequency|.
   DWORD GetDesiredBssList(DOT11_SSID& ssid,
                           Frequency frequency,
-                          scoped_ptr<DOT11_BSSID_LIST>* desired_list);
+                          std::unique_ptr<DOT11_BSSID_LIST>* desired_list);
 
   // Normalizes |frequency_in_mhz| into one of |Frequency| values.
   Frequency GetNormalizedFrequency(int frequency_in_mhz) const;
 
   // Create |profile_xml| based on |network_properties|. If |encryption_type|
   // is |kEncryptionTypeAny| applies the type most suitable for parameters in
   // |network_properties|.
   bool CreateProfile(const NetworkProperties& network_properties,
                      EncryptionType encryption_type,
                      std::string* profile_xml);
@@ skipping 62 matching lines @@
   // Created WLAN Profiles, indexed by |network_guid|. Contains xml with TKIP
   // encryption type saved by |CreateNetwork| if applicable. Profile has to be
   // deleted if connection fails. Implicitly created profiles have to be deleted
   // if connection succeeds. Persist only in memory.
   base::DictionaryValue created_profiles_;
   // Observer to get notified when network(s) have changed (e.g. connect).
   NetworkGuidListCallback networks_changed_observer_;
   // Observer to get notified when network list has changed (scan complete).
   NetworkGuidListCallback network_list_changed_observer_;
   // Saved value of network location wizard show value.
-  scoped_ptr<DWORD> saved_nw_category_wizard_;
+  std::unique_ptr<DWORD> saved_nw_category_wizard_;
   // Task runner to post events on UI thread.
   scoped_refptr<base::SingleThreadTaskRunner> event_task_runner_;
   // Task runner for worker tasks.
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
   // If |false|, then |networks_changed_observer_| is not notified.
   bool enable_notify_network_changed_;
   // Number of attempts to check that network has connected successfully.
   static const int kMaxAttempts = 100;
   // Delay between attempts to check that network has connected successfully.
   static const int kAttemptDelayMs = 100;
@@ skipping 74 matching lines @@
 }
 
 void WiFiServiceImpl::GetState(const std::string& network_guid,
                                base::DictionaryValue* properties,
                                std::string* error) {
   CheckError(ERROR_CALL_NOT_IMPLEMENTED, kErrorWiFiService, error);
 }
 
 void WiFiServiceImpl::SetProperties(
     const std::string& network_guid,
-    scoped_ptr<base::DictionaryValue> properties,
+    std::unique_ptr<base::DictionaryValue> properties,
     std::string* error) {
   // Temporary preserve WiFi properties (desired frequency, wifi password) to
   // use in StartConnect.
   DCHECK(properties.get());
   if (!properties->HasKey(onc::network_type::kWiFi)) {
     DVLOG(0) << "Missing WiFi properties:" << *properties;
     *error = kErrorWiFiService;
     return;
   }
 
   base::DictionaryValue* existing_properties;
   // If the network properties already exist, don't override previously set
   // properties, unless they are set in |properties|.
   if (connect_properties_.GetDictionaryWithoutPathExpansion(
           network_guid, &existing_properties)) {
     existing_properties->MergeDictionary(properties.get());
   } else {
     connect_properties_.SetWithoutPathExpansion(network_guid,
                                                 properties.release());
   }
 }
 
 void WiFiServiceImpl::CreateNetwork(
     bool shared,
-    scoped_ptr<base::DictionaryValue> properties,
+    std::unique_ptr<base::DictionaryValue> properties,
     std::string* network_guid,
     std::string* error) {
   DWORD error_code = EnsureInitialized();
   if (CheckError(error_code, kErrorWiFiService, error))
     return;
 
   NetworkProperties network_properties;
   if (!network_properties.UpdateFromValue(*properties)) {
     CheckError(ERROR_INVALID_DATA, kErrorWiFiService, error);
     return;
@@ skipping 17 matching lines @@
   // encryption type fails.
   std::string tkip_profile_xml;
   if (!CreateProfile(network_properties,
                      kEncryptionTypeTKIP,
                      &tkip_profile_xml)) {
     CheckError(ERROR_INVALID_DATA, kErrorWiFiService, error);
     return;
   }
 
   if (tkip_profile_xml != profile_xml) {
-    scoped_ptr<base::DictionaryValue> tkip_profile(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> tkip_profile(
+        new base::DictionaryValue());
     tkip_profile->SetString(kProfileXmlKey, tkip_profile_xml);
     tkip_profile->SetBoolean(kProfileSharedKey, shared);
     created_profiles_.SetWithoutPathExpansion(network_properties.guid,
                                               tkip_profile.release());
   }
 
   *network_guid = network_properties.guid;
 }
 
 void WiFiServiceImpl::GetVisibleNetworks(const std::string& network_type,
                                          base::ListValue* network_list,
                                          bool include_details) {
   if (!network_type.empty() &&
       network_type != onc::network_type::kAllTypes &&
       network_type != onc::network_type::kWiFi) {
     return;
   }
 
   DWORD error = EnsureInitialized();
   if (error == ERROR_SUCCESS) {
     NetworkList networks;
     error = GetVisibleNetworkList(&networks);
     if (error == ERROR_SUCCESS && !networks.empty()) {
       SortNetworks(&networks);
       for (NetworkList::const_iterator it = networks.begin();
            it != networks.end();
            ++it) {
-        scoped_ptr<base::DictionaryValue> network(
+        std::unique_ptr<base::DictionaryValue> network(
             it->ToValue(!include_details));
         network_list->Append(network.release());
       }
     }
   }
 }
 
 void WiFiServiceImpl::RequestNetworkScan() {
   DWORD error = EnsureInitialized();
   if (error == ERROR_SUCCESS) {
@@ skipping 476 matching lines @@
     const GUID& interface_guid,
     IP_ADAPTER_INDEX_MAP* adapter_index_map) {
   base::string16 guid_string;
   const int kGUIDSize = 39;
   ::StringFromGUID2(
       interface_guid, base::WriteInto(&guid_string, kGUIDSize), kGUIDSize);
 
   ULONG buffer_length = 0;
   DWORD error = ::GetInterfaceInfo(NULL, &buffer_length);
   if (error == ERROR_INSUFFICIENT_BUFFER) {
-    scoped_ptr<unsigned char[]> buffer(new unsigned char[buffer_length]);
+    std::unique_ptr<unsigned char[]> buffer(new unsigned char[buffer_length]);
     IP_INTERFACE_INFO* interface_info =
         reinterpret_cast<IP_INTERFACE_INFO*>(buffer.get());
     error = GetInterfaceInfo(interface_info, &buffer_length);
     if (error == ERROR_SUCCESS) {
       for (int adapter = 0; adapter < interface_info->NumAdapters; ++adapter) {
         if (base::EndsWith(
                 interface_info->Adapter[adapter].Name, guid_string,
                 base::CompareCase::INSENSITIVE_ASCII)) {
           *adapter_index_map = interface_info->Adapter[adapter];
           break;
@@ skipping 364 matching lines @@
       if (wifi->GetInteger(onc::wifi::kFrequency, &frequency))
         return GetNormalizedFrequency(frequency);
     }
   }
   return kFrequencyAny;
 }
 
 DWORD WiFiServiceImpl::GetDesiredBssList(
     DOT11_SSID& ssid,
     Frequency frequency,
-    scoped_ptr<DOT11_BSSID_LIST>* desired_list) {
+    std::unique_ptr<DOT11_BSSID_LIST>* desired_list) {
   if (client_ == NULL) {
     NOTREACHED();
     return ERROR_NOINTERFACE;
   }
 
   desired_list->reset();
 
   if (frequency == kFrequencyAny)
     return ERROR_SUCCESS;
 
@@ skipping 32 matching lines @@
       if (bss_frequency == frequency &&
           bss_entry.uLinkQuality > best_quality) {
         best_quality = bss_entry.uLinkQuality;
         best_index = bss;
       }
     }
 
     // If any matching BSS were found, prepare the header.
     if (best_quality > 0) {
       const WLAN_BSS_ENTRY& bss_entry(bss_list->wlanBssEntries[best_index]);
-      scoped_ptr<DOT11_BSSID_LIST> selected_list(new DOT11_BSSID_LIST);
+      std::unique_ptr<DOT11_BSSID_LIST> selected_list(new DOT11_BSSID_LIST);
 
       selected_list->Header.Revision = DOT11_BSSID_LIST_REVISION_1;
       selected_list->Header.Size = sizeof(DOT11_BSSID_LIST);
       selected_list->Header.Type = NDIS_OBJECT_TYPE_DEFAULT;
       selected_list->uNumOfEntries = 1;
       selected_list->uTotalNumOfEntries = 1;
       std::copy(bss_entry.dot11Bssid,
                 bss_entry.dot11Bssid+sizeof(bss_entry.dot11Bssid),
                 selected_list->BSSIDs[0]);
       desired_list->swap(selected_list);
@@ skipping 21 matching lines @@
 
 DWORD WiFiServiceImpl::Connect(const std::string& network_guid,
                                Frequency frequency) {
   if (client_ == NULL) {
     NOTREACHED();
     return ERROR_NOINTERFACE;
   }
 
   DWORD error = ERROR_SUCCESS;
   DOT11_SSID ssid = SSIDFromGUID(network_guid);
-  scoped_ptr<DOT11_BSSID_LIST> desired_bss_list;
+  std::unique_ptr<DOT11_BSSID_LIST> desired_bss_list;
   error = GetDesiredBssList(ssid, frequency, &desired_bss_list);
   if (error == ERROR_SUCCESS) {
     if (HaveProfile(network_guid)) {
       base::string16 profile_name = ProfileNameFromGUID(network_guid);
       WLAN_CONNECTION_PARAMETERS wlan_params = {
           wlan_connection_mode_profile,
           profile_name.c_str(),
           NULL,
           desired_bss_list.get(),
           dot11_BSS_type_any,
           0};
       error = WlanConnect_function_(
           client_, &interface_guid_, &wlan_params, NULL);
     } else {
       // If network is available, but is not open security, then it cannot be
       // connected without profile, so return 'access denied' error.
-      scoped_ptr<base::DictionaryValue> properties (new base::DictionaryValue);
+      std::unique_ptr<base::DictionaryValue> properties(
+          new base::DictionaryValue);
       const base::DictionaryValue* wifi;
       std::string wifi_security;
       std::string error_string;
       GetProperties(network_guid, properties.get(), &error_string);
       if (error_string.empty() &&
           properties->GetDictionary(onc::network_type::kWiFi, &wifi) &&
           wifi->GetString(onc::wifi::kSecurity, &wifi_security) &&
           wifi_security != onc::wifi::kSecurityNone) {
         error = ERROR_ACCESS_DENIED;
         LOG(ERROR) << error;
@@ skipping 231 matching lines @@
     DVLOG(1) << "NotifyNetworkChanged: " << network_guid;
     NetworkGuidList changed_networks(1, network_guid);
     event_task_runner_->PostTask(
         FROM_HERE, base::Bind(networks_changed_observer_, changed_networks));
   }
 }
 
 WiFiService* WiFiService::Create() { return new WiFiServiceImpl(); }
 
 }  // namespace wifi