Add a CONNECT_REQUESTED state to Network ConnectionState.

chrome/browser/chromeos/cros/network_library_impl_cros.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_impl_cros.h"
 
 #include <dbus/dbus-glib.h>
 #include "base/command_line.h"
 #include "base/json/json_writer.h"  // for debug output only.
 #include "base/metrics/histogram.h"
@@ skipping 690 matching lines @@
     case PROPERTY_INDEX_CHECK_PORTAL_LIST: {
       DCHECK_EQ(value->GetType(), Value::TYPE_STRING);
       value->GetAsString(&check_portal_list_);
       break;
     }
     case PROPERTY_INDEX_PORTAL_URL:
     case PROPERTY_INDEX_ARP_GATEWAY:
       // Currently we ignore PortalURL and ArpGateway.
       break;
     default:
-      LOG(WARNING) << "Manager: Unhandled key: " << key;
+      VLOG(2) << "Manager: Unhandled key: " << key;
       break;
   }
   base::TimeDelta delta = base::TimeTicks::Now() - start;
   VLOG(2) << "NetworkManagerStatusChanged: time: "
           << delta.InMilliseconds() << " ms.";
   HISTOGRAM_TIMES("CROS_NETWORK_UPDATE", delta);
   return true;
 }
 
 void NetworkLibraryImplCros::NetworkManagerUpdate(
@@ skipping 98 matching lines @@
         AddNetwork(found->second);
         old_network_map.erase(found);
       }
       // Always request network updates.
       // TODO(stevenjb): Investigate why we are missing updates then
       // rely on watched network updates and only request updates here for
       // new networks.
       // Use update_request map to store network priority.
       network_update_requests_[service_path] = network_priority_order++;
       wifi_scanning_ = true;
+      VLOG(2) << "UpdateNetworkServiceList, Service: " << service_path;
       CrosRequestNetworkServiceProperties(
           service_path,
           base::Bind(&NetworkLibraryImplCros::NetworkServiceUpdate,
                      weak_ptr_factory_.GetWeakPtr()));
     }
   }
   // Iterate through list of remaining networks that are no longer in the
   // list and delete them or update their status and re-add them to the list.
   for (NetworkMap::iterator iter = old_network_map.begin();
        iter != old_network_map.end(); ++iter) {
@@ skipping 39 matching lines @@
                      weak_ptr_factory_.GetWeakPtr()));
     }
   }
 }
 
 void NetworkLibraryImplCros::NetworkServiceUpdate(
     const std::string& service_path,
     const base::DictionaryValue* properties) {
   if (!properties)
     return;  // Network no longer in visible list, ignore.
+  VLOG(2) << "NetworkServiceUpdate: " << service_path;
   ParseNetwork(service_path, *properties);
 }
 
 // Called from NetworkServiceUpdate and WifiServiceUpdateAndConnect.
 Network* NetworkLibraryImplCros::ParseNetwork(
     const std::string& service_path, const DictionaryValue& info) {
   Network* network = FindNetworkByPath(service_path);
   if (!network) {
     NativeNetworkParser parser;
     network = parser.CreateNetworkFromInfo(service_path, info);
@@ skipping 121 matching lines @@
   // |profile_entries| is a list of remembered networks from |profile_path|.
   profile.services.clear();
   for (ListValue::const_iterator iter2 = profile_entries->begin();
        iter2 != profile_entries->end(); ++iter2) {
     std::string service_path;
     (*iter2)->GetAsString(&service_path);
     if (service_path.empty()) {
       LOG(WARNING) << "Empty service path in profile.";
       continue;
     }
-    VLOG(1) << " Remembered service: " << service_path;
+    VLOG(2) << " Remembered service: " << service_path;
     // Add service to profile list.
     profile.services.insert(service_path);
     // Request update for remembered network.
     CrosRequestNetworkProfileEntryProperties(
         profile_path,
         service_path,
         base::Bind(&NetworkLibraryImplCros::RememberedNetworkServiceUpdate,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 }
@@ skipping 34 matching lines @@
       delete remembered;
       return NULL;
     }
   }
 
   if (!remembered->unique_id().empty())
     remembered_network_unique_id_map_[remembered->unique_id()] = remembered;
 
   SetProfileTypeFromPath(remembered);
 
-  VLOG(1) << "ParseRememberedNetwork: " << remembered->name()
+  VLOG(2) << "ParseRememberedNetwork: " << remembered->name()
           << " path: " << remembered->service_path()
           << " profile: " << remembered->profile_path_;
   NotifyNetworkManagerChanged(false);  // Not forced.
 
   if (remembered->type() == TYPE_VPN) {
     // VPNs are only stored in profiles. If we don't have a network for it,
     // request one.
     if (!FindNetworkByUniqueId(remembered->unique_id())) {
       VirtualNetwork* vpn = static_cast<VirtualNetwork*>(remembered);
       std::string provider_type = ProviderTypeToString(vpn->provider_type());
-      VLOG(1) << "Requesting VPN: " << vpn->name()
+      VLOG(2) << "Requesting VPN: " << vpn->name()
               << " Server: " << vpn->server_hostname()
               << " Type: " << provider_type;
       CrosRequestVirtualNetworkProperties(
           vpn->name(),
           vpn->server_hostname(),
           provider_type,
           base::Bind(&NetworkLibraryImplCros::NetworkServiceUpdate,
                      weak_ptr_factory_.GetWeakPtr()));
     }
   }
@@ skipping 57 matching lines @@
     device->device_parser()->UpdateDeviceFromInfo(info, device);
   } else {
     NativeNetworkDeviceParser parser;
     device = parser.CreateDeviceFromInfo(device_path, info);
     VLOG(2) << " Adding device: " << device_path;
     if (device) {
       device_map_[device_path] = device;
     }
     CHECK(device) << "Attempted to add NULL device for path: " << device_path;
   }
-  VLOG(1) << "ParseNetworkDevice:" << device->name();
+  VLOG(2) << "ParseNetworkDevice:" << device->name();
   if (device && device->type() == TYPE_CELLULAR) {
     if (!device->data_roaming_allowed() && IsCellularAlwaysInRoaming()) {
       SetCellularDataRoamingAllowed(true);
     } else {
       bool settings_value;
       if (CrosSettings::Get()->GetBoolean(
               kSignedDataRoamingEnabled, &settings_value) &&
           device->data_roaming_allowed() != settings_value) {
         // Switch back to signed settings value.
         SetCellularDataRoamingAllowed(settings_value);
       }
     }
   }
   NotifyNetworkManagerChanged(false);  // Not forced.
   AddNetworkDeviceObserver(device_path, network_device_observer_.get());
 }
 
 }  // namespace chromeos