Proxy settings automation hooks and related proxy settings fixes.

chrome/browser/automation/testing_automation_provider_chromeos.cc

 // Copyright (c) 2011 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 "base/values.h"
 #include "chrome/browser/automation/automation_provider_json.h"
 #include "chrome/browser/automation/automation_provider_observers.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/browser/chromeos/cros/power_library.h"
 #include "chrome/browser/chromeos/cros/screen_lock_library.h"
 #include "chrome/browser/chromeos/login/existing_user_controller.h"
 #include "chrome/browser/chromeos/login/screen_locker.h"
+#include "chrome/browser/chromeos/proxy_cros_settings_provider.h"
 
 using chromeos::CrosLibrary;
 using chromeos::NetworkLibrary;
 using chromeos::UserManager;
 
 namespace {
 
 DictionaryValue* GetNetworkInfoDict(const chromeos::Network* network) {
   DictionaryValue* item = new DictionaryValue;
   item->SetString("name", network->name());
   item->SetString("device_path", network->device_path());
   item->SetString("ip_address", network->ip_address());
   item->SetString("status", network->GetStateString());
   return item;
 }
 
+Value* GetProxySetting(const std::string& setting_name) {
+  chromeos::ProxyCrosSettingsProvider settings_provider;
+  std::string setting_path = "cros.session.proxy.";
+  setting_path.append(setting_name);
+
+  if (setting_name == "ignorelist") {
+    Value* value;
+    if (settings_provider.Get(setting_path, &value))
+      return value;
+  } else {
+    Value* setting;
+    if (settings_provider.Get(setting_path, &setting)) {
+      DictionaryValue* setting_dict = static_cast<DictionaryValue*>(setting);
+      Value* value;
+      bool found = setting_dict->Remove("value", &value);
+      delete setting;
+      if (found)
+        return value;
+    }
+  }
+  return NULL;
+}
+
 }  // namespace
 
 void TestingAutomationProvider::GetLoginInfo(DictionaryValue* args,
                                              IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
 
   const UserManager* user_manager = UserManager::Get();
   if (!user_manager)
     reply.SendError("No user manager!");
@@ skipping 213 matching lines @@
     return;
   }
 
   NetworkLibrary* network_library = CrosLibrary::Get()->GetNetworkLibrary();
   network_library->RequestNetworkScan();
 
   // Set up an observer (it will delete itself).
   new NetworkScanObserver(this, reply_message);
 }
 
+void TestingAutomationProvider::GetProxySettings(DictionaryValue* args,
+                                                 IPC::Message* reply_message) {
+  const char* settings[] = { "pacurl", "singlehttp", "singlehttpport",
+                             "httpurl", "httpport", "httpsurl", "httpsport",
+                             "type", "single", "ftpurl", "ftpport",
+                             "socks", "socksport", "ignorelist" };
+
+  scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
+  chromeos::ProxyCrosSettingsProvider settings_provider;
+
+  for (size_t i = 0; i < arraysize(settings); ++i) {
+    Value* setting = GetProxySetting(settings[i]);
+    if (setting)
+      return_value->Set(settings[i], setting);
+  }
+
+  AutomationJSONReply(this, reply_message).SendSuccess(return_value.get());
+}
+
+void TestingAutomationProvider::SetProxySettings(DictionaryValue* args,
+                                                IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+  std::string key;
+  Value* value;
+  if (!args->GetString("key", &key) || !args->Get("value", &value)) {
+    reply.SendError("Invalid or missing args.");
+    return;
+  }
+
+  std::string setting_path = "cros.session.proxy.";
+  setting_path.append(key);
+
+  // ProxyCrosSettingsProvider will own the Value* passed to Set().
+  chromeos::ProxyCrosSettingsProvider().Set(setting_path, value->DeepCopy());
+  reply.SendSuccess(NULL);
+}
+
 void TestingAutomationProvider::ConnectToWifiNetwork(
     DictionaryValue* args, IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   std::string service_path, password, identity, certpath;
   if (!args->GetString("service_path", &service_path) ||
       !args->GetString("password", &password) ||
       !args->GetString("identity", &identity) ||
       !args->GetString("certpath", &certpath)) {
     reply.SendError("Invalid or missing args.");
     return;
@@ skipping 36 matching lines @@
   NetworkLibrary* network_library = CrosLibrary::Get()->GetNetworkLibrary();
   const chromeos::WifiNetwork* wifi = network_library->wifi_network();
   if (!wifi) {
     reply.SendError("Not connected to any wifi network.");
     return;
   }
 
   network_library->DisconnectFromWirelessNetwork(wifi);
   reply.SendSuccess(NULL);
 }