Fix initial offline state response handling

net/base/network_change_notifier_linux.cc

 // Copyright (c) 2011 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.
 //
 // This implementation of NetworkChangeNotifier's offline state detection
 // depends on D-Bus and NetworkManager, and is known to work on at least
 // GNOME version 2.30.  If D-Bus or NetworkManager are unavailable, this
 // implementation will always behave as if it is online.
 
 #include "net/base/network_change_notifier_linux.h"
@@ skipping 70 matching lines @@
 
   // Must be called by the helper thread's CleanUp() method.
   void CleanUp();
 
   // Implementation of NetworkChangeNotifierLinux::IsCurrentlyOffline().
   // Safe to call from any thread, but will block until Init() has completed.
   bool IsCurrentlyOffline();
 
  private:
   // Callbacks for D-Bus API.
-  void OnStateChanged(dbus::Message* message);
-
-  void OnResponse(dbus::Response* response) {
-    OnStateChanged(response);
+  void OnInitialResponse(dbus::Response* response) {
+    HandleResponse(response);
     offline_state_initialized_.Signal();
   }
 
-  void OnSignaled(dbus::Signal* signal) {
-    OnStateChanged(signal);
-  }
+  void OnSignaled(dbus::Signal* signal);
 
   void OnConnected(const std::string&, const std::string&, bool success) {
     if (!success) {
       DLOG(WARNING) << "Failed to set up offline state detection";
       offline_state_initialized_.Signal();
     }
   }
 
+  // Helper for OnInitialResponse.
+  void HandleResponse(dbus::Response* response);
+
   // Converts a NetworkManager state uint to a bool.
   static bool StateIsOffline(uint32 state);
 
   bool is_offline_;
   base::Lock is_offline_lock_;
   base::WaitableEvent offline_state_initialized_;
 
   base::Closure notification_callback_;
 
   base::PlatformThreadId helper_thread_id_;
@@ skipping 21 matching lines @@
       system_bus_->GetObjectProxy(kNetworkManagerServiceName,
                                   kNetworkManagerPath);
 
   // Get the initial state asynchronously.
   dbus::MethodCall method_call(DBUS_INTERFACE_PROPERTIES, "Get");
   dbus::MessageWriter builder(&method_call);
   builder.AppendString(kNetworkManagerInterface);
   builder.AppendString("State");
   proxy->CallMethod(
       &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-      base::Bind(&NetworkManagerApi::OnResponse, ptr_factory_.GetWeakPtr()));
+      base::Bind(&NetworkManagerApi::OnInitialResponse,
+                 ptr_factory_.GetWeakPtr()));
 
   // And sign up for notifications.
   proxy->ConnectToSignal(
       kNetworkManagerInterface,
       "StateChanged",
       base::Bind(&NetworkManagerApi::OnSignaled, ptr_factory_.GetWeakPtr()),
       base::Bind(&NetworkManagerApi::OnConnected, ptr_factory_.GetWeakPtr()));
 }
 
 void NetworkManagerApi::CleanUp() {
   DCHECK_EQ(helper_thread_id_, base::PlatformThread::CurrentId());
   ptr_factory_.InvalidateWeakPtrs();
 }
 
-void NetworkManagerApi::OnStateChanged(dbus::Message* message) {
+void NetworkManagerApi::HandleResponse(dbus::Response* response) {
   DCHECK_EQ(helper_thread_id_, base::PlatformThread::CurrentId());
-  if (!message) {
+  if (!response) {
     DLOG(WARNING) << "No response received for initial state request";
     return;
   }
-  dbus::MessageReader reader(message);
+  dbus::MessageReader reader(response);
   uint32 state = 0;
-  if (!reader.HasMoreData() || !reader.PopUint32(&state)) {
+  if (!reader.PopVariantOfUint32(&state)) {
     DLOG(WARNING) << "Unexpected response for NetworkManager State request: "
-                  << message->ToString();
+                  << response->ToString();
+    return;
+  }
+  {
+    base::AutoLock lock(is_offline_lock_);
+    is_offline_ = StateIsOffline(state);
+  }
+}
+
+void NetworkManagerApi::OnSignaled(dbus::Signal* signal) {
+  DCHECK_EQ(helper_thread_id_, base::PlatformThread::CurrentId());
+  dbus::MessageReader reader(signal);
+  uint32 state = 0;
+  if (!reader.PopUint32(&state)) {
+    DLOG(WARNING) << "Unexpected signal for NetworkManager StateChanged: "
+                  << signal->ToString();
     return;
   }
   bool new_is_offline = StateIsOffline(state);
   {
     base::AutoLock lock(is_offline_lock_);
     if (is_offline_ != new_is_offline)
       is_offline_ = new_is_offline;
     else
       return;
   }
-  if (offline_state_initialized_.IsSignaled())
-    notification_callback_.Run();
+  notification_callback_.Run();
 }
 
 bool NetworkManagerApi::StateIsOffline(uint32 state) {
   switch (state) {
     case NM_LEGACY_STATE_CONNECTED:
     case NM_STATE_CONNECTED_SITE:
     case NM_STATE_CONNECTED_GLOBAL:
       // Definitely connected
       return false;
     case NM_LEGACY_STATE_DISCONNECTED:
@@ skipping 245 matching lines @@
   // Stopping from here allows us to sanity- check that the notifier
   // thread shut down properly.
   notifier_thread_->Stop();
 }
 
 bool NetworkChangeNotifierLinux::IsCurrentlyOffline() const {
   return notifier_thread_->IsCurrentlyOffline();
 }
 
 }  // namespace net