components: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

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 <wlanapi.h>
 
@@ skipping 202 matching lines @@
                     std::string* error) override;
 
   void StartDisconnect(const std::string& network_guid,
                        std::string* error) override;
 
   void GetKeyFromSystem(const std::string& network_guid,
                         std::string* key_data,
                         std::string* error) override;
 
   void SetEventObservers(
-      scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner,
       const NetworkGuidListCallback& networks_changed_observer,
       const NetworkGuidListCallback& network_list_changed_observer) override;
 
   void RequestConnectedNetworkUpdate() override {}
 
   void GetConnectedNetworkSSID(std::string* ssid, std::string* error) override;
 
  private:
   typedef int32 EncryptionType;
   enum EncryptionTypeEnum {
@@ skipping 224 matching lines @@
   // 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_;
-  // MessageLoopProxy to post events on UI thread.
-  scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
+  // 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;
   DISALLOW_COPY_AND_ASSIGN(WiFiServiceImpl);
 };
@@ skipping 293 matching lines @@
         return;
       }
     }
   }
 
   // Did not find passphrase in the profile.
   *error = kErrorWiFiService;
 }
 
 void WiFiServiceImpl::SetEventObservers(
-    scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     const NetworkGuidListCallback& networks_changed_observer,
     const NetworkGuidListCallback& network_list_changed_observer) {
   DWORD error_code = EnsureInitialized();
   if (error_code != ERROR_SUCCESS)
     return;
-  message_loop_proxy_.swap(message_loop_proxy);
+  event_task_runner_.swap(task_runner);
   if (!networks_changed_observer_.is_null() ||
       !network_list_changed_observer_.is_null()) {
     // Stop listening to WLAN notifications.
     WlanRegisterNotification_function_(client_,
                                        WLAN_NOTIFICATION_SOURCE_NONE,
                                        FALSE,
                                        OnWlanNotificationCallback,
                                        this,
                                        NULL,
                                        NULL);
@@ skipping 27 matching lines @@
 
 void WiFiServiceImpl::OnWlanNotificationCallback(
     PWLAN_NOTIFICATION_DATA wlan_notification_data,
     PVOID context) {
   WiFiServiceImpl* service = reinterpret_cast<WiFiServiceImpl*>(context);
   service->OnWlanNotification(wlan_notification_data);
 }
 
 void WiFiServiceImpl::OnWlanNotification(
     PWLAN_NOTIFICATION_DATA wlan_notification_data) {
-  if (message_loop_proxy_.get() == NULL)
+  if (event_task_runner_.get() == NULL)
     return;
   switch (wlan_notification_data->NotificationCode) {
     case wlan_notification_acm_disconnected:
     case wlan_notification_acm_connection_complete:
     case wlan_notification_acm_connection_attempt_fail: {
       PWLAN_CONNECTION_NOTIFICATION_DATA wlan_connection_data =
           reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA>(
               wlan_notification_data->pData);
-      message_loop_proxy_->PostTask(
-          FROM_HERE,
-          base::Bind(&WiFiServiceImpl::NotifyNetworkChanged,
-                     base::Unretained(this),
-                     GUIDFromSSID(wlan_connection_data->dot11Ssid)));
+      event_task_runner_->PostTask(
+          FROM_HERE, base::Bind(&WiFiServiceImpl::NotifyNetworkChanged,
+                                base::Unretained(this),
+                                GUIDFromSSID(wlan_connection_data->dot11Ssid)));
       break;
     }
     case wlan_notification_acm_scan_complete:
     case wlan_notification_acm_interface_removal:
-      message_loop_proxy_->PostTask(
+      event_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&WiFiServiceImpl::OnNetworkScanCompleteOnMainThread,
                      base::Unretained(this)));
       break;
   }
 }
 
 void WiFiServiceImpl::OnNetworkScanCompleteOnMainThread() {
   NetworkList networks;
   // Get current list of visible networks and notify that network list has
@@ skipping 1006 matching lines @@
   if (network_list_changed_observer_.is_null())
     return;
 
   NetworkGuidList current_networks;
   for (NetworkList::const_iterator it = networks.begin();
        it != networks.end();
        ++it) {
     current_networks.push_back(it->guid);
   }
 
-  message_loop_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(network_list_changed_observer_, current_networks));
+  event_task_runner_->PostTask(
+      FROM_HERE, base::Bind(network_list_changed_observer_, current_networks));
 }
 
 void WiFiServiceImpl::NotifyNetworkChanged(const std::string& network_guid) {
   if (enable_notify_network_changed_ && !networks_changed_observer_.is_null()) {
     DVLOG(1) << "NotifyNetworkChanged: " << network_guid;
     NetworkGuidList changed_networks(1, network_guid);
-    message_loop_proxy_->PostTask(
-        FROM_HERE,
-        base::Bind(networks_changed_observer_, changed_networks));
+    event_task_runner_->PostTask(
+        FROM_HERE, base::Bind(networks_changed_observer_, changed_networks));
   }
 }
 
 WiFiService* WiFiService::Create() { return new WiFiServiceImpl(); }
 
 }  // namespace wifi