Convert all connect code to use NetworkHandler instead of NetworkLibrary

chrome/browser/ui/webui/options/chromeos/internet_options_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 "chrome/browser/ui/webui/options/chromeos/internet_options_handler.h"
 
 #include <ctype.h>
 
 #include <map>
 #include <string>
@@ skipping 264 matching lines @@
                         base::Value* value) {
   NET_LOG_EVENT("SetNetworkProperty: " + property, service_path);
   base::DictionaryValue properties;
   properties.SetWithoutPathExpansion(property, value);
   NetworkHandler::Get()->network_configuration_handler()->SetProperties(
       service_path, properties,
       base::Bind(&base::DoNothing),
       base::Bind(&ShillError, "SetNetworkProperty"));
 }
 
-const base::DictionaryValue* FindPolicyForActiveUser(
-    const NetworkState* network,
-    onc::ONCSource* onc_source) {
-  const User* user = UserManager::Get()->GetActiveUser();
-  std::string username_hash = user ? user->username_hash() : std::string();
-  return NetworkHandler::Get()->managed_network_configuration_handler()
-      ->FindPolicyByGUID(username_hash, network->guid(), onc_source);
-}
-
 std::string ActivationStateString(const std::string& activation_state) {
   int id;
   if (activation_state == flimflam::kActivationStateActivated)
     id = IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_ACTIVATED;
   else if (activation_state == flimflam::kActivationStateActivating)
     id = IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_ACTIVATING;
   else if (activation_state == flimflam::kActivationStateNotActivated)
     id = IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_NOT_ACTIVATED;
   else if (activation_state == flimflam::kActivationStatePartiallyActivated)
     id = IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_PARTIALLY_ACTIVATED;
@@ skipping 346 matching lines @@
   if (provider_type == flimflam::kProviderOpenVpn) {
     provider_properties->GetStringWithoutPathExpansion(
         flimflam::kOpenVPNUserProperty, &username);
   } else {
     provider_properties->GetStringWithoutPathExpansion(
         flimflam::kL2tpIpsecUserProperty, &username);
   }
   dictionary->SetString(kTagUsername, username);
 
   onc::ONCSource onc_source = onc::ONC_SOURCE_NONE;
-  const base::DictionaryValue* onc = FindPolicyForActiveUser(vpn, &onc_source);
+  const base::DictionaryValue* onc =
+      network_connect::FindPolicyForActiveUser(vpn, &onc_source);
 
   NetworkPropertyUIData hostname_ui_data;
   hostname_ui_data.ParseOncProperty(
       onc_source,
       onc,
       base::StringPrintf("%s.%s", onc::network_config::kVPN, onc::vpn::kHost));
   std::string provider_host;
   provider_properties->GetStringWithoutPathExpansion(
       flimflam::kHostProperty, &provider_host);
   SetValueDictionary(dictionary, kTagServerHostname,
@@ skipping 486 matching lines @@
 }
 
 void InternetOptionsHandler::CarrierStatusCallback() {
   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
   const DeviceState* device =
       handler->GetDeviceStateByType(flimflam::kTypeCellular);
   if (device && (device->carrier() == shill::kCarrierSprint)) {
     const NetworkState* network =
         handler->FirstNetworkByType(flimflam::kTypeCellular);
     if (network) {
-      chromeos::network_connect::ActivateCellular(network->path());
+      ash::network_connect::ActivateCellular(network->path());
       UpdateConnectionData(network->path());
     }
   }
   UpdateCarrier();
 }
 
 void InternetOptionsHandler::SetCarrierCallback(const base::ListValue* args) {
   std::string service_path;
   std::string carrier;
   if (args->GetSize() != 2 ||
@@ skipping 261 matching lines @@
     const std::string& service_path,
     const base::DictionaryValue& shill_properties) {
   const NetworkState* network = GetNetworkState(service_path);
   if (!network) {
     LOG(ERROR) << "Network properties not found: " << service_path;
     return;
   }
 
   onc::ONCSource onc_source = onc::ONC_SOURCE_NONE;
   const base::DictionaryValue* onc =
-      FindPolicyForActiveUser(network, &onc_source);
+      network_connect::FindPolicyForActiveUser(network, &onc_source);
   const NetworkPropertyUIData property_ui_data(onc_source);
 
   base::DictionaryValue dictionary;
 
   // Device hardware address
   const DeviceState* device = NetworkHandler::Get()->network_state_handler()->
       GetDeviceState(network->device_path());
   if (device)
     dictionary.SetString(kTagHardwareAddress, device->mac_address());
 
@@ skipping 224 matching lines @@
 
   // Device settings.
   const DeviceState* device = NetworkHandler::Get()->network_state_handler()->
       GetDeviceState(cellular->device_path());
   if (device) {
     // TODO(stevenjb): Add NetworkDeviceHandler::GetProperties() and use that
     // to retrieve the complete dictionary of device properties, instead of
     // caching them (will be done for the new UI).
     const base::DictionaryValue& device_properties = device->properties();
     const NetworkPropertyUIData cellular_property_ui_data(
-        cellular->onc_source());
+        cellular->ui_data().onc_source());
     CopyStringFromDictionary(device_properties, flimflam::kManufacturerProperty,
                             kTagManufacturer, dictionary);
     CopyStringFromDictionary(device_properties, flimflam::kModelIDProperty,
                             kTagModelId, dictionary);
     CopyStringFromDictionary(device_properties,
                             flimflam::kFirmwareRevisionProperty,
                             kTagFirmwareRevision, dictionary);
     CopyStringFromDictionary(device_properties,
                             flimflam::kHardwareRevisionProperty,
                             kTagHardwareRevision, dictionary);
@@ skipping 137 matching lines @@
               base::Bind(&base::DoNothing),
               base::Bind(&ShillError, "NetworkCommand: " + command));
     }
   } else if (command == kTagOptions) {
     NetworkHandler::Get()->network_configuration_handler()->GetProperties(
         service_path,
         base::Bind(&InternetOptionsHandler::PopulateDictionaryDetailsCallback,
                    weak_factory_.GetWeakPtr()),
         base::Bind(&ShillError, "NetworkCommand: " + command));
   } else if (command == kTagConnect) {
-    network_connect::ConnectToNetwork(
-        service_path, GetNativeWindow());
+    ash::network_connect::ConnectToNetwork(service_path, GetNativeWindow());
   } else if (command == kTagDisconnect) {
     NetworkHandler::Get()->network_connection_handler()->DisconnectNetwork(
         service_path,
         base::Bind(&base::DoNothing),
         base::Bind(&ShillError, "NetworkCommand: " + command));
   } else if (command == kTagActivate && type == flimflam::kTypeCellular) {
-    network_connect::ActivateCellular(service_path);
+    ash::network_connect::ActivateCellular(service_path);
     // Activation may update network properties (e.g. ActivationState), so
     // request them here in case they change.
     UpdateConnectionData(service_path);
   } else {
     VLOG(1) << "Unknown command: " << command;
     NOTREACHED();
   }
 }
 
 void InternetOptionsHandler::AddConnection(const std::string& type) {
   if (type == flimflam::kTypeWifi)
-    NetworkConfigView::ShowForType(chromeos::TYPE_WIFI, GetNativeWindow());
+    NetworkConfigView::ShowForType(flimflam::kTypeWifi, GetNativeWindow());
   else if (type == flimflam::kTypeVPN)
-    NetworkConfigView::ShowForType(chromeos::TYPE_VPN, GetNativeWindow());
+    NetworkConfigView::ShowForType(flimflam::kTypeVPN, GetNativeWindow());
   else if (type == flimflam::kTypeCellular)
     ChooseMobileNetworkDialog::ShowDialog(GetNativeWindow());
   else
     NOTREACHED();
 }
 
 base::ListValue* InternetOptionsHandler::GetWiredList() {
   base::ListValue* list = new base::ListValue();
   const NetworkState* network = NetworkHandler::Get()->network_state_handler()->
       FirstNetworkByType(flimflam::kTypeEthernet);
@@ skipping 87 matching lines @@
       cellular && cellular->support_network_scan());
 
   dictionary->SetBoolean(kTagWimaxAvailable,
                          handler->IsTechnologyAvailable(flimflam::kTypeWimax));
   dictionary->SetBoolean(kTagWimaxEnabled,
                          handler->IsTechnologyEnabled(flimflam::kTypeWimax));
 }
 
 }  // namespace options
 }  // namespace chromeos