cros: doing dbus stuff on the file thread==disaster.

chrome/browser/chromeos/cros_network_library.cc

 // Copyright (c) 2009 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 "chrome/browser/chromeos/cros_network_library.h"
 
 #include <algorithm>
 
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/chromeos/cros_library.h"
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until it's last InvokeLater is run.
 template <>
 struct RunnableMethodTraits<CrosNetworkLibrary> {
   void RetainCallee(CrosNetworkLibrary* obj) {}
   void ReleaseCallee(CrosNetworkLibrary* obj) {}
 };
 
 CrosNetworkLibrary::CrosNetworkLibrary() {
   if (CrosLibrary::loaded()) {
-    MessageLoop* loop = ChromeThread::GetMessageLoop(ChromeThread::FILE);
-    if (loop) {
-      loop->PostTask(FROM_HERE, NewRunnableMethod(this,
-          &CrosNetworkLibrary::InitOnBackgroundThread));
-    }
+    Init();
   }
 }
 
 CrosNetworkLibrary::~CrosNetworkLibrary() {
   if (CrosLibrary::loaded()) {
-    // FILE thread is already gone by the time we get to this destructor.
-    // So it's ok to just make the disconnect call on the main thread.
     chromeos::DisconnectNetworkStatus(network_status_connection_);
   }
 }
 
 // static
 CrosNetworkLibrary* CrosNetworkLibrary::Get() {
   return Singleton<CrosNetworkLibrary>::get();
 }
 
 // static
@@ skipping 19 matching lines @@
       return "wep";
     case chromeos::WPA:
       return "wpa";
   }
   return "none";
 }
 
 void CrosNetworkLibrary::ConnectToWifiNetwork(WifiNetwork network,
                                               const string16& password) {
   if (CrosLibrary::loaded()) {
-    MessageLoop* loop = ChromeThread::GetMessageLoop(ChromeThread::FILE);
-    if (loop)
-      loop->PostTask(FROM_HERE, NewRunnableFunction(
-          &chromeos::ConnectToWifiNetwork,
-          network.ssid.c_str(),
-          password.empty() ? NULL : UTF16ToUTF8(password).c_str(),
-          GetEncryptionString(network.encryption)));
+    // This call kicks off a request to connect to this network, the results of
+    // which we'll hear about through the monitoring we've set up in Init();
+    chromeos::ConnectToWifiNetwork(
+        network.ssid.c_str(),
+        password.empty() ? NULL : UTF16ToUTF8(password).c_str(),
+        GetEncryptionString(network.encryption));
   }
 }
 
 // static
 void CrosNetworkLibrary::NetworkStatusChangedHandler(void* object,
     const chromeos::ServiceStatus& service_status) {
   CrosNetworkLibrary* network = static_cast<CrosNetworkLibrary*>(object);
   WifiNetworkVector networks;
   bool ethernet_connected;
   ParseNetworks(service_status, &networks, &ethernet_connected);
@@ skipping 23 matching lines @@
       networks->push_back(WifiNetwork(service.ssid,
                                       service.needs_passphrase,
                                       service.encryption,
                                       service.signal_strength,
                                       connecting,
                                       connected));
     }
   }
 }
 
-void CrosNetworkLibrary::InitOnBackgroundThread() {
+void CrosNetworkLibrary::Init() {
+  // First, get the currently available networks.  This data is cached
+  // on the connman side, so the call should be quick.
   chromeos::ServiceStatus* service_status = chromeos::GetAvailableNetworks();
   if (service_status) {
+    LOG(INFO) << "Getting initial CrOS network info.";
     WifiNetworkVector networks;
     bool ethernet_connected;
     ParseNetworks(*service_status, &networks, &ethernet_connected);
     UpdateNetworkStatus(networks, ethernet_connected);
     chromeos::FreeServiceStatus(service_status);
   }
+  LOG(INFO) << "Registering for network status updates.";
+  // Now, register to receive updates on network status.
   network_status_connection_ = chromeos::MonitorNetworkStatus(
       &NetworkStatusChangedHandler, this);
 }
 
 void CrosNetworkLibrary::UpdateNetworkStatus(
     const WifiNetworkVector& networks, bool ethernet_connected) {
   // Make sure we run on UI thread.
   if (!ChromeThread::CurrentlyOn(ChromeThread::UI)) {
     MessageLoop* loop = ChromeThread::GetMessageLoop(ChromeThread::UI);
     if (loop)
       loop->PostTask(FROM_HERE, NewRunnableMethod(this,
           &CrosNetworkLibrary::UpdateNetworkStatus, networks,
           ethernet_connected));
     return;
   }
 
   ethernet_connected_ = ethernet_connected;
   wifi_networks_ = networks;
   // Sort the list of wifi networks by ssid.
   std::sort(wifi_networks_.begin(), wifi_networks_.end());
   wifi_ = WifiNetwork();
   for (size_t i = 0; i < wifi_networks_.size(); i++) {
     if (wifi_networks_[i].connecting || wifi_networks_[i].connected) {
       wifi_ = wifi_networks_[i];
       break;  // There is only one connected or connecting wifi network.
     }
   }
   FOR_EACH_OBSERVER(Observer, observers_, NetworkChanged(this));
 }