Remove ListValue::Append(raw ptr) on Win

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>
 #include <wlanapi.h>
 
+#include <memory>
 #include <set>
+#include <utility>
 
 #include "base/base_paths_win.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/values.h"
 #include "base/win/registry.h"
 #include "components/onc/onc_constants.h"
 #include "components/wifi/network_properties.h"
 #include "third_party/libxml/chromium/libxml_utils.h"
 
 namespace {
 const wchar_t kNwCategoryWizardRegKey[] =
     L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Network\\"
     L"NwCategoryWizard";
 const wchar_t kNwCategoryWizardRegValue[] = L"Show";
@@ skipping 539 matching lines @@
   }
 
   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());
+                                                std::move(properties));
   }
 }
 
 void WiFiServiceImpl::CreateNetwork(
     bool shared,
     std::unique_ptr<base::DictionaryValue> properties,
     std::string* network_guid,
     std::string* error) {
   DWORD error_code = EnsureInitialized();
   if (CheckError(error_code, kErrorWiFiService, error))
@@ skipping 28 matching lines @@
     CheckError(ERROR_INVALID_DATA, kErrorWiFiService, error);
     return;
   }
 
   if (tkip_profile_xml != profile_xml) {
     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());
+                                              std::move(tkip_profile));
   }
 
   *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) {
         std::unique_ptr<base::DictionaryValue> network(
             it->ToValue(!include_details));
-        network_list->Append(network.release());
+        network_list->Append(std::move(network));
       }
     }
   }
 }
 
 void WiFiServiceImpl::RequestNetworkScan() {
   DWORD error = EnsureInitialized();
   if (error == ERROR_SUCCESS) {
     WlanScan_function_(client_, &interface_guid_, NULL, NULL, NULL);
   }
@@ skipping 1224 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