Fix logic for default network notification

chromeos/network/network_state_handler.cc

 // Copyright (c) 2012 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 "chromeos/network/network_state_handler.h"
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/guid.h"
 #include "base/json/json_string_value_serializer.h"
@@ skipping 754 matching lines @@
     return;
 
   default_network_path_ = service_path;
   NET_LOG_EVENT("DefaultNetworkServiceChanged:", default_network_path_);
   const NetworkState* network = nullptr;
   if (!default_network_path_.empty()) {
     network = GetNetworkState(default_network_path_);
     if (!network) {
       // If NetworkState is not available yet, do not notify observers here,
       // they will be notified when the state is received.
-      NET_LOG_DEBUG("Default NetworkState not available",
-                    default_network_path_);
+      NET_LOG(EVENT) << "Default NetworkState not available: "
+                     << default_network_path_;
       return;
     }
   }
   if (network && !network->IsConnectedState()) {
-    NET_LOG_ERROR(
-        "DefaultNetwork is not connected: " + network->connection_state(),
-        network->path());
+    if (network->IsConnectingState()) {
+      NET_LOG(EVENT) << "DefaultNetwork is connecting: " << GetLogName(network)
+                     << ": " << network->connection_state();
+    } else {
+      NET_LOG(ERROR) << "DefaultNetwork in unexpected state: "
+                     << GetLogName(network) << ": "
+                     << network->connection_state();
+    }
+    // Do not notify observers here, the notification will occur when the
+    // connection state changes.
+    return;
   }
   NotifyDefaultNetworkChanged(network);
 }
 
 //------------------------------------------------------------------------------
 // Private methods
 
 void NetworkStateHandler::UpdateGuid(NetworkState* network) {
   std::string specifier = network->GetSpecifier();
   DCHECK(!specifier.empty());
@@ skipping 66 matching lines @@
       return &device_list_;
   }
   NOTREACHED();
   return nullptr;
 }
 
 void NetworkStateHandler::OnNetworkConnectionStateChanged(
     NetworkState* network) {
   SCOPED_NET_LOG_IF_SLOW();
   DCHECK(network);
-  std::string event = "NetworkConnectionStateChanged";
+  bool notify_default = false;
   if (network->path() == default_network_path_) {
-    event = "Default" + event;
-    if (!network->IsConnectedState()) {
-      NET_LOG_EVENT(
-          "DefaultNetwork is not connected: " + network->connection_state(),
-          network->path());
+    if (network->IsConnectedState()) {
+      notify_default = true;
+    } else if (network->IsConnectingState()) {
+      // Wait until the network is actually connected to notify that the default
+      // network changed.
+      NET_LOG(EVENT) << "Default network is not connected: "
+                     << GetLogName(network)
+                     << "State: " << network->connection_state();
+    } else {
+      NET_LOG(ERROR) << "Default network in unexpected state: "
+                     << GetLogName(network)
+                     << "State: " << network->connection_state();
       default_network_path_.clear();
       SortNetworkList();
       NotifyDefaultNetworkChanged(nullptr);
     }
   }
-  NET_LOG_EVENT("NOTIFY:" + event + ": " + network->connection_state(),
-                GetLogName(network));
+  std::string desc = "NetworkConnectionStateChanged";
+  if (notify_default)
+    desc = "Default" + desc;
+  NET_LOG(EVENT) << "NOTIFY: " << desc << ": " << GetLogName(network) << ": "
+                 << network->connection_state();
   FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
                     NetworkConnectionStateChanged(network));
-  if (network->path() == default_network_path_)
+  if (notify_default)
     NotifyDefaultNetworkChanged(network);
 }
 
 void NetworkStateHandler::NotifyDefaultNetworkChanged(
     const NetworkState* default_network) {
   SCOPED_NET_LOG_IF_SLOW();
   NET_LOG_EVENT("NOTIFY:DefaultNetworkChanged", GetLogName(default_network));
   FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
                     DefaultNetworkChanged(default_network));
 }
@@ skipping 59 matching lines @@
   if (type.MatchesType(shill::kTypeBluetooth))
     technologies.push_back(new std::string(shill::kTypeBluetooth));
   if (type.MatchesType(shill::kTypeVPN))
     technologies.push_back(new std::string(shill::kTypeVPN));
 
   CHECK_GT(technologies.size(), 0ul);
   return technologies.Pass();
 }
 
 }  // namespace chromeos