Add a CONNECT_REQUESTED state to Network ConnectionState.

chrome/browser/chromeos/cros/network_library.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 "chrome/browser/chromeos/cros/network_library.h"
 
 #include <dbus/dbus-glib.h>
 
 #include "base/i18n/icu_encoding_detection.h"
 #include "base/i18n/icu_string_conversions.h"
@@ skipping 116 matching lines @@
     bool is_unicode_char = base::ReadUnicodeCharacter(str.c_str(), str.size(),
                                                       &index, &code_point_out);
     if (is_unicode_char && (code_point_out >= 0x20))
       base::WriteUnicodeCharacter(code_point_out, output);
     else
       // Puts REPLACEMENT CHARACTER (U+FFFD) if character is not readable UTF-8
       base::WriteUnicodeCharacter(0xFFFD, output);
   }
 }
 
+std::string ConnectionStateString(ConnectionState state) {
+  switch (state) {
+    case STATE_UNKNOWN:
+      return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_UNKNOWN);
+    case STATE_IDLE:
+      return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_IDLE);
+    case STATE_CARRIER:
+      return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_CARRIER);
+    case STATE_ASSOCIATION:
+      return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_ASSOCIATION);
+    case STATE_CONFIGURATION:
+      return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_CONFIGURATION);
+    case STATE_READY:
+      return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_READY);
+    case STATE_DISCONNECT:
+      return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_DISCONNECT);
+    case STATE_FAILURE:
+      return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_FAILURE);
+    case STATE_ACTIVATION_FAILURE:
+      return l10n_util::GetStringUTF8(
+          IDS_CHROMEOS_NETWORK_STATE_ACTIVATION_FAILURE);
+    case STATE_PORTAL:
+      return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_PORTAL);
+    case STATE_ONLINE:
+      return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_ONLINE);
+    case STATE_CONNECT_REQUESTED:
+      return l10n_util::GetStringUTF8(
+          IDS_CHROMEOS_NETWORK_STATE_CONNECT_REQUESTED);
+  }
+  return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_UNRECOGNIZED);
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // FoundCellularNetwork
 
 FoundCellularNetwork::FoundCellularNetwork() {}
 
 FoundCellularNetwork::~FoundCellularNetwork() {}
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 71 matching lines @@
       delete iter->second;
       property_map_.erase(iter);
     }
     return;
   }
 
   // Add the property to property_map_.  Delete previous value if necessary.
   Value*& entry = property_map_[index];
   delete entry;
   entry = value->DeepCopy();
-  if (VLOG_IS_ON(2)) {
+  if (VLOG_IS_ON(3)) {
     std::string value_json;
     base::JSONWriter::WriteWithOptions(value,
                                        base::JSONWriter::OPTIONS_PRETTY_PRINT,
                                        &value_json);
-    VLOG(2) << "Updated property map on network: "
+    VLOG(3) << "Updated property map on network: "
             << unique_id() << "[" << index << "] = " << value_json;
   }
 }
 
 bool Network::GetProperty(PropertyIndex index,
                           const base::Value** value) const {
   PropertyMap::const_iterator i = property_map_.find(index);
   if (i == property_map_.end())
     return false;
   if (value != NULL)
     *value = i->second;
   return true;
 }
 
 // static
 Network* Network::CreateForTesting(ConnectionType type) {
   return new Network("fake_service_path", type);
 }
 
 void Network::SetState(ConnectionState new_state) {
   if (new_state == state_)
     return;
+  if (state_ == STATE_CONNECT_REQUESTED && new_state == STATE_IDLE) {
+    // CONNECT_REQUESTED is set internally. Shill/flimflam do not update the
+    // state immediately, so ignore any Idle state updates sent while a
+    // connection attempt is in progress.
+    return;
+  }
   ConnectionState old_state = state_;
   state_ = new_state;
   if (!IsConnectingState(new_state))
     set_connection_started(false);
   if (new_state == STATE_FAILURE) {
     if (old_state != STATE_UNKNOWN &&
         old_state != STATE_IDLE) {
       // New failure, the user needs to be notified.
       // Transition STATE_IDLE -> STATE_FAILURE sometimes happens on resume
       // but is not an actual failure as network device is not ready yet.
       notify_failure_ = true;
       // Normally error_ should be set, but if it is not we need to set it to
       // something here so that the retry logic will be triggered.
       if (error_ == ERROR_NO_ERROR)
         error_ = ERROR_UNKNOWN;
     }
   } else {
     // State changed, so refresh IP address.
     // Note: blocking DBus call. TODO(stevenjb): refactor this.
     InitIPAddress();
   }
-  VLOG(1) << name() << ".State = " << GetStateString();
+  VLOG(1) << name() << ".State [" << service_path() << "]: " << GetStateString()
+          << " (was: " << ConnectionStateString(old_state) << ")";
 }
 
 void Network::SetName(const std::string& name) {
   std::string name_utf8;
   ValidateUTF8(name, &name_utf8);
   set_name(name_utf8);
 }
 
 void Network::ParseInfo(const DictionaryValue& info) {
   if (network_parser_.get())
@@ skipping 94 matching lines @@
   closure.Run();
 }
 
 void Network::SetProfilePath(const std::string& profile_path) {
   VLOG(1) << "Setting profile for: " << name_ << " to: " << profile_path;
   SetOrClearStringProperty(
       flimflam::kProfileProperty, profile_path, &profile_path_);
 }
 
 std::string Network::GetStateString() const {
-  switch (state_) {
-    case STATE_UNKNOWN:
-      return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_UNKNOWN);
-    case STATE_IDLE:
-      return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_IDLE);
-    case STATE_CARRIER:
-      return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_CARRIER);
-    case STATE_ASSOCIATION:
-      return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_ASSOCIATION);
-    case STATE_CONFIGURATION:
-      return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_CONFIGURATION);
-    case STATE_READY:
-      return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_READY);
-    case STATE_DISCONNECT:
-      return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_DISCONNECT);
-    case STATE_FAILURE:
-      return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_FAILURE);
-    case STATE_ACTIVATION_FAILURE:
-      return l10n_util::GetStringUTF8(
-          IDS_CHROMEOS_NETWORK_STATE_ACTIVATION_FAILURE);
-    case STATE_PORTAL:
-      return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_PORTAL);
-    case STATE_ONLINE:
-      return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_ONLINE);
-  }
-  return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_UNRECOGNIZED);
+  return ConnectionStateString(state_);
 }
 
 std::string Network::GetErrorString() const {
   switch (error_) {
     case ERROR_NO_ERROR:
       // TODO(nkostylev): Introduce new error message "None" instead.
       return std::string();
     case ERROR_OUT_OF_RANGE:
       return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_OUT_OF_RANGE);
     case ERROR_PIN_MISSING:
@@ skipping 871 matching lines @@
   NetworkLibrary* impl;
   if (stub)
     impl = new NetworkLibraryImplStub();
   else
     impl = new NetworkLibraryImplCros();
   impl->Init();
   return impl;
 }
 
 }  // namespace chromeos