Eliminate unused PYAUTO tests and TestingAutomationProvider methods

chrome/browser/automation/testing_automation_provider_chromeos.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/automation/testing_automation_provider.h"
 
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "base/command_line.h"
@@ skipping 614 matching lines @@
     network_library->EnableWifiNetworkDevice(enable);
   } else if (device == "cellular") {
     network_library->EnableCellularNetworkDevice(enable);
   } else {
     reply.SendError(
         "Unknown device. Valid devices are ethernet, wifi, cellular.");
     return;
   }
 }
 
-void TestingAutomationProvider::SetSharedProxies(
-    DictionaryValue* args,
-    IPC::Message* reply_message) {
-
-  AutomationJSONReply reply(this, reply_message);
-  base::Value* value;
-  if (!args->Get("value", &value)) {
-    reply.SendError("Invalid or missing value argument.");
-    return;
-  }
-  std::string error_message;
-  Profile* profile =
-      automation_util::GetCurrentProfileOnChromeOS(&error_message);
-  if (!profile) {
-    reply.SendError(error_message);
-    return;
-  }
-  PrefService* pref_service = profile->GetPrefs();
-  pref_service->Set(prefs::kUseSharedProxies, *value);
-  reply.SendSuccess(NULL);
-}
-
-void TestingAutomationProvider::SetProxySettings(DictionaryValue* args,
-                                                 IPC::Message* reply_message) {
-  AutomationJSONReply reply(this, reply_message);
-  std::string proxy_config_str;
-  if (!args->GetString("proxy_config", &proxy_config_str)) {
-    reply.SendError("Invalid or missing args.");
-    return;
-  }
-
-  const chromeos::NetworkState* network = chromeos::NetworkHandler::Get()->
-      network_state_handler()->DefaultNetwork();
-  if (!network) {
-    reply.SendError("No network connected.");
-    return;
-  }
-
-  scoped_ptr<base::DictionaryValue> proxy_config_dict(
-      chromeos::onc::ReadDictionaryFromJson(proxy_config_str));
-  ProxyConfigDictionary proxy_config(proxy_config_dict.get());
-  chromeos::proxy_config::SetProxyConfigForNetwork(proxy_config, *network);
-
-  reply.SendSuccess(NULL);
-}
-
-void TestingAutomationProvider::ConnectToCellularNetwork(
-    DictionaryValue* args, IPC::Message* reply_message) {
-  std::string service_path;
-  if (!args->GetString("service_path", &service_path)) {
-    AutomationJSONReply(this, reply_message).SendError(
-        "Invalid or missing args.");
-    return;
-  }
-
-  NetworkLibrary* network_library = NetworkLibrary::Get();
-  chromeos::CellularNetwork* cellular =
-      network_library->FindCellularNetworkByPath(service_path);
-  if (!cellular) {
-    AutomationJSONReply(this, reply_message).SendError(
-        "No network found with specified service path.");
-    return;
-  }
-
-  // Set up an observer (it will delete itself).
-  new ServicePathConnectObserver(this, reply_message, service_path);
-
-  network_library->ConnectToCellularNetwork(cellular);
-  network_library->RequestNetworkScan();
-}
-
-void TestingAutomationProvider::DisconnectFromCellularNetwork(
-    DictionaryValue* args, IPC::Message* reply_message) {
-  NetworkLibrary* network_library = NetworkLibrary::Get();
-  const chromeos::CellularNetwork* cellular =
-        network_library->cellular_network();
-  if (!cellular) {
-    AutomationJSONReply(this, reply_message).SendError(
-        "Not connected to any cellular network.");
-    return;
-  }
-
-  // Set up an observer (it will delete itself).
-  new NetworkDisconnectObserver(this, reply_message, cellular->service_path());
-
-  network_library->DisconnectFromNetwork(cellular);
-}
-
-void TestingAutomationProvider::ConnectToWifiNetwork(
-    DictionaryValue* args, IPC::Message* reply_message) {
-  AutomationJSONReply reply(this, reply_message);
-  std::string service_path, password;
-  bool shared;
-  if (!args->GetString("service_path", &service_path) ||
-      !args->GetString("password", &password) ||
-      !args->GetBoolean("shared", &shared)) {
-    reply.SendError("Invalid or missing args.");
-    return;
-  }
-
-  NetworkLibrary* network_library = NetworkLibrary::Get();
-  chromeos::WifiNetwork* wifi =
-      network_library->FindWifiNetworkByPath(service_path);
-  if (!wifi) {
-    reply.SendError("No network found with specified service path.");
-    return;
-  }
-  if (!password.empty())
-    wifi->SetPassphrase(password);
-
-  // Regardless of what was passed, if the network is open and visible,
-  // the network must be shared because of a UI restriction.
-  if (wifi->encryption() == chromeos::SECURITY_NONE)
-    shared = true;
-
-  // Set up an observer (it will delete itself).
-  new ServicePathConnectObserver(this, reply_message, service_path);
-
-  network_library->ConnectToWifiNetwork(wifi, shared);
-  network_library->RequestNetworkScan();
-}
-
 void TestingAutomationProvider::ForgetWifiNetwork(
     DictionaryValue* args, IPC::Message* reply_message) {
   std::string service_path;
   if (!args->GetString("service_path", &service_path)) {
     AutomationJSONReply(this, reply_message).SendError(
         "Invalid or missing args.");
     return;
   }
 
   NetworkLibrary::Get()->ForgetNetwork(service_path);
@@ skipping 85 matching lines @@
     network_library->ConnectToUnconfiguredWifiNetwork(
         ssid, chromeos::SECURITY_8021X, password, &config_data,
         save_credentials, shared);
   } else {
     network_library->ConnectToUnconfiguredWifiNetwork(
         ssid, connection_security, password, NULL,
         save_credentials, shared);
   }
 }
 
-void TestingAutomationProvider::DisconnectFromWifiNetwork(
-    DictionaryValue* args, IPC::Message* reply_message) {
-  AutomationJSONReply reply(this, reply_message);
-  NetworkLibrary* network_library = NetworkLibrary::Get();
-  const chromeos::WifiNetwork* wifi = network_library->wifi_network();
-  if (!wifi) {
-    reply.SendError("Not connected to any wifi network.");
-    return;
-  }
-
-  network_library->DisconnectFromNetwork(wifi);
-  reply.SendSuccess(NULL);
-}
-
-void TestingAutomationProvider::AddPrivateNetwork(
-    DictionaryValue* args, IPC::Message* reply_message) {
-  std::string hostname, service_name, provider_type, key, cert_id, username,
-      password;
-  if (!args->GetString("hostname", &hostname) ||
-      !args->GetString("service_name", &service_name) ||
-      !args->GetString("provider_type", &provider_type) ||
-      !args->GetString("username", &username) ||
-      !args->GetString("password", &password)) {
-    AutomationJSONReply(this, reply_message)
-        .SendError("Invalid or missing args.");
-    return;
-  }
-
-  NetworkLibrary* network_library = NetworkLibrary::Get();
-
-  // Attempt to connect to the VPN based on the provider type.
-  if (provider_type == VPNProviderTypeToString(
-      chromeos::PROVIDER_TYPE_L2TP_IPSEC_PSK)) {
-    if (!args->GetString("key", &key)) {
-      AutomationJSONReply(this, reply_message)
-          .SendError("Missing key arg.");
-      return;
-    }
-    new VirtualConnectObserver(this, reply_message, service_name);
-    // Connect using a pre-shared key.
-    chromeos::NetworkLibrary::VPNConfigData config_data;
-    config_data.psk = key;
-    config_data.username = username;
-    config_data.user_passphrase = password;
-    network_library->ConnectToUnconfiguredVirtualNetwork(
-        service_name,
-        hostname,
-        chromeos::PROVIDER_TYPE_L2TP_IPSEC_PSK,
-        config_data);
-  } else if (provider_type == VPNProviderTypeToString(
-      chromeos::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT)) {
-    if (!args->GetString("cert_id", &cert_id)) {
-      AutomationJSONReply(this, reply_message)
-          .SendError("Missing a certificate arg.");
-      return;
-    }
-    new VirtualConnectObserver(this, reply_message, service_name);
-    // Connect using a user certificate.
-    chromeos::NetworkLibrary::VPNConfigData config_data;
-    config_data.client_cert_pkcs11_id = cert_id;
-    config_data.username = username;
-    config_data.user_passphrase = password;
-    network_library->ConnectToUnconfiguredVirtualNetwork(
-        service_name,
-        hostname,
-        chromeos::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT,
-        config_data);
-  } else if (provider_type == VPNProviderTypeToString(
-      chromeos::PROVIDER_TYPE_OPEN_VPN)) {
-    std::string otp;
-    args->GetString("otp", &otp);
-    // Connect using OPEN_VPN.
-    chromeos::NetworkLibrary::VPNConfigData config_data;
-    config_data.client_cert_pkcs11_id = cert_id;
-    config_data.username = username;
-    config_data.user_passphrase = password;
-    config_data.otp = otp;
-    network_library->ConnectToUnconfiguredVirtualNetwork(
-        service_name,
-        hostname,
-        chromeos::PROVIDER_TYPE_OPEN_VPN,
-        config_data);
-  } else {
-    AutomationJSONReply(this, reply_message)
-        .SendError("Unsupported provider type.");
-    return;
-  }
-}
-
-void TestingAutomationProvider::ConnectToPrivateNetwork(
-    DictionaryValue* args, IPC::Message* reply_message) {
-  AutomationJSONReply reply(this, reply_message);
-  std::string service_path;
-  if (!args->GetString("service_path", &service_path)) {
-    reply.SendError("Invalid or missing args.");
-    return;
-  }
-
-  // Connect to a remembered VPN by its service_path. Valid service_paths
-  // can be found in the dictionary returned by GetPrivateNetworkInfo.
-  NetworkLibrary* network_library = NetworkLibrary::Get();
-  chromeos::VirtualNetwork* network =
-      network_library->FindVirtualNetworkByPath(service_path);
-  if (!network) {
-    reply.SendError(base::StringPrintf("No virtual network found: %s",
-                                       service_path.c_str()));
-    return;
-  }
-  if (network->NeedMoreInfoToConnect()) {
-    reply.SendError("Virtual network is missing info required to connect.");
-    return;
-  };
-
-  // Set up an observer (it will delete itself).
-  new VirtualConnectObserver(this, reply_message, network->name());
-  network_library->ConnectToVirtualNetwork(network);
-}
-
-void TestingAutomationProvider::GetPrivateNetworkInfo(
-    DictionaryValue* args, IPC::Message* reply_message) {
-  scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
-  NetworkLibrary* network_library = NetworkLibrary::Get();
-  const chromeos::VirtualNetworkVector& virtual_networks =
-      network_library->virtual_networks();
-
-  // Construct a dictionary of fields describing remembered VPNs. Also list
-  // the currently active VPN, if any.
-  if (network_library->virtual_network())
-    return_value->SetString("connected",
-                            network_library->virtual_network()->service_path());
-  for (chromeos::VirtualNetworkVector::const_iterator iter =
-       virtual_networks.begin(); iter != virtual_networks.end(); ++iter) {
-    const chromeos::VirtualNetwork* virt = *iter;
-    DictionaryValue* item = new DictionaryValue;
-    item->SetString("name", virt->name());
-    item->SetString("provider_type",
-                    VPNProviderTypeToString(virt->provider_type()));
-    item->SetString("hostname", virt->server_hostname());
-    item->SetString("key", virt->psk_passphrase());
-    item->SetString("cert_id", virt->client_cert_id());
-    item->SetString("username", virt->username());
-    item->SetString("password", virt->user_passphrase());
-    return_value->Set(virt->service_path(), item);
-  }
-
-  AutomationJSONReply(this, reply_message).SendSuccess(return_value.get());
-}
-
-void TestingAutomationProvider::DisconnectFromPrivateNetwork(
-    DictionaryValue* args, IPC::Message* reply_message) {
-  AutomationJSONReply reply(this, reply_message);
-  NetworkLibrary* network_library = NetworkLibrary::Get();
-  const chromeos::VirtualNetwork* virt = network_library->virtual_network();
-  if (!virt) {
-    reply.SendError("Not connected to any virtual network.");
-    return;
-  }
-
-  network_library->DisconnectFromNetwork(virt);
-  reply.SendSuccess(NULL);
-}
-
 void TestingAutomationProvider::ExecuteJavascriptInOOBEWebUI(
     DictionaryValue* args, IPC::Message* reply_message) {
   std::string javascript, frame_xpath;
   if (!args->GetString("javascript", &javascript)) {
     AutomationJSONReply(this, reply_message)
         .SendError("'javascript' missing or invalid");
     return;
   }
   if (!args->GetString("frame_xpath", &frame_xpath)) {
     AutomationJSONReply(this, reply_message)
@@ skipping 158 matching lines @@
 
 void TestingAutomationProvider::AddChromeosObservers() {
   chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->
       AddObserver(this);
 }
 
 void TestingAutomationProvider::RemoveChromeosObservers() {
   chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->
       RemoveObserver(this);
 }