Add a CONNECT_REQUESTED state to Network ConnectionState.

chrome/browser/chromeos/cros/network_library.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_
 #define CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_
 #pragma once
 
 #include <map>
 #include <string>
@@ skipping 281 matching lines @@
 
 // Contains data common to all network service types.
 class Network {
  public:
   virtual ~Network();
 
   // Test API for accessing setters in tests.
   class TestApi {
    public:
     explicit TestApi(Network* network) : network_(network) {}
-    void SetConnected(bool connected) {
-      network_->set_connected(connected);
+    void SetConnected() {
+      network_->set_connected();
     }
-    void SetConnecting(bool connecting) {
-      network_->set_connecting(connecting);
+    void SetConnecting() {
+      network_->set_connecting();
+    }
+    void SetDisconnected() {
+      network_->set_idle();
     }
    private:
     Network* network_;
   };
   friend class TestApi;
 
   // Structure used only for parsing ONC's ProxySettings value.
   struct ProxyOncConfig {
     ProxyOncConfig() : type(PROXY_ONC_DIRECT) {}
 
@@ skipping 83 matching lines @@
   // Copy any credentials from a remembered network that are unset in |this|.
   virtual void CopyCredentialsFromRemembered(Network* remembered);
 
   // Static helper functions.
   static bool IsConnectedState(ConnectionState state) {
     return (state == STATE_READY ||
             state == STATE_ONLINE ||
             state == STATE_PORTAL);
   }
   static bool IsConnectingState(ConnectionState state) {
-    return (state == STATE_ASSOCIATION ||
+    return (state == STATE_CONNECT_REQUESTED ||
+            state == STATE_ASSOCIATION ||
             state == STATE_CONFIGURATION ||
             state == STATE_CARRIER);
   }
   static bool IsDisconnectedState(ConnectionState state) {
     return (state == STATE_UNKNOWN ||
             state == STATE_IDLE ||
             state == STATE_DISCONNECT ||
             state == STATE_FAILURE ||
             state == STATE_ACTIVATION_FAILURE);
   }
@@ skipping 92 matching lines @@
 
   // Use these functions at your peril.  They are used by the various
   // parsers to set state, and really shouldn't be used by anything else
   // because they don't do the error checking and sending to the
   // network layer that the other setters do.
   void set_device_path(const std::string& device_path) {
     device_path_ = device_path;
   }
   void set_name(const std::string& name) { name_ = name; }
   void set_mode(ConnectionMode mode) { mode_ = mode; }
-  void set_connecting(bool connecting) {
-    state_ = (connecting ? STATE_ASSOCIATION : STATE_IDLE);
+  void set_connecting() {
+    state_ = STATE_CONNECT_REQUESTED;
   }
-  void set_connected(bool connected) {
-    state_ = (connected ? STATE_ONLINE : STATE_IDLE);
+  void set_connected() {
+    state_ = STATE_ONLINE;
+  }
+  void set_idle() {

[Greg Spencer (Chromium), 2012/06/18 17:02:38]

Any reason this shouldn't be called "set_disconnected" to match SetDisconnected
above?  And I'm kind of curious why there isn't also a
"STATE_DISCONNECT_REQUESTED": is the switch to idle atomic?

[stevenjb (google-dont-use), 2012/06/18 17:35:31]

Done.
The UI doesn't currently care about a "disconnecting" state.  In practice, the
time between requested a disconnect and flimflam/shill switching to that state
is very small.

+    state_ = STATE_IDLE;
   }
   void set_connectable(bool connectable) { connectable_ = connectable; }
   void set_connection_started(bool started) { connection_started_ = started; }
   void set_is_active(bool is_active) { is_active_ = is_active; }
   void set_error(ConnectionError error) { error_ = error; }
   void set_added(bool added) { added_ = added; }
   void set_auto_connect(bool auto_connect) { auto_connect_ = auto_connect; }
   void set_save_credentials(bool save_credentials) {
     save_credentials_ = save_credentials;
   }
@@ skipping 1136 matching lines @@
                                 const std::string& service_path) = 0;
 
   // Factory function, creates a new instance and returns ownership.
   // For normal usage, access the singleton via CrosLibrary::Get().
   static NetworkLibrary* GetImpl(bool stub);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_