Adding the ability to alter Chrome's proxy settings via the automation interf...

chrome/browser/automation/automation_provider.cc

 // Copyright (c) 2006-2009 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/automation_provider.h"
 
 #include "app/message_box_flags.h"
 #include "base/file_version_info.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/thread.h"
+#include "base/values.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/app_modal_dialog.h"
 #include "chrome/browser/app_modal_dialog_queue.h"
 #include "chrome/browser/automation/automation_provider_list.h"
 #include "chrome/browser/automation/url_request_failed_dns_job.h"
 #include "chrome/browser/automation/url_request_mock_http_job.h"
 #include "chrome/browser/automation/url_request_slow_download_job.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/dom_operation_notification_details.h"
 #include "chrome/browser/download/download_manager.h"
 #include "chrome/browser/find_bar.h"
 #include "chrome/browser/find_bar_controller.h"
 #include "chrome/browser/find_notification_details.h"
 #include "chrome/browser/location_bar.h"
+#include "chrome/browser/profile_manager.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/ssl/ssl_manager.h"
 #include "chrome/browser/ssl/ssl_blocking_page.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_contents_view.h"
+#include "chrome/common/automation_constants.h"
 #include "chrome/common/chrome_paths.h"
+#include "chrome/common/json_value_serializer.h"
 #include "chrome/common/notification_registrar.h"
 #include "chrome/common/platform_util.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/test/automation/automation_messages.h"
 #include "net/base/cookie_monster.h"
+#include "net/proxy/proxy_service.h"
+#include "net/proxy/proxy_config_service_fixed.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_filter.h"
 
 #if defined(OS_WIN)
 // TODO(port): Port these headers.
 #include "chrome/browser/automation/ui_controls.h"
 #include "chrome/browser/character_encoding.h"
 #include "chrome/browser/download/save_package.h"
 #include "chrome/browser/external_tab_container.h"
 #include "chrome/browser/login_prompt.h"
@@ skipping 997 matching lines @@
     IPC_MESSAGE_HANDLER(AutomationMsg_ConstrainedTitle,
                         GetConstrainedTitle)
     IPC_MESSAGE_HANDLER(AutomationMsg_FindInPage,
                         HandleFindInPageRequest)
     IPC_MESSAGE_HANDLER(AutomationMsg_GetFocusedViewID,
                         GetFocusedViewID)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_InspectElement,
                                     HandleInspectElementRequest)
     IPC_MESSAGE_HANDLER(AutomationMsg_SetFilteredInet,
                         SetFilteredInet);
+    IPC_MESSAGE_HANDLER(AutomationMsg_SetProxyConfig,
+                        SetProxyConfig);
     IPC_MESSAGE_HANDLER(AutomationMsg_DownloadDirectory,
                         GetDownloadDirectory);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_OpenNewBrowserWindow,
                                     OpenNewBrowserWindow);
     IPC_MESSAGE_HANDLER(AutomationMsg_WindowForBrowser,
                         GetWindowForBrowser);
     IPC_MESSAGE_HANDLER(AutomationMsg_AutocompleteEditForBrowser,
                         GetAutocompleteEditForBrowser);
     IPC_MESSAGE_HANDLER(AutomationMsg_BrowserForWindow,
                         GetBrowserForWindow);
@@ skipping 1168 matching lines @@
 };
 
 void AutomationProvider::SetFilteredInet(const IPC::Message& message,
                                          bool enabled) {
   // Since this involves changing the URLRequest ProtocolFactory, we want to
   // run on the main thread.
   g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
       new SetFilteredInetTask(enabled));
 }
 
+class SetProxyConfigTask : public Task {
+ public:
+  explicit SetProxyConfigTask(net::ProxyService* proxy_service,
+                              const std::string& new_proxy_config)
+      : proxy_service_(proxy_service), proxy_config_(new_proxy_config) {}
+  virtual void Run() {
+    // First, deserialize the JSON string. If this fails, log and bail.
+    JSONStringValueSerializer deserializer(proxy_config_);
+    std::string error_message;
+    scoped_ptr<Value> root(deserializer.Deserialize(&error_message));
+    if (!root.get() || root->GetType() != Value::TYPE_DICTIONARY) {
+      DLOG(WARNING) << "Received bad JSON string for ProxyConfig: "
+                    << error_message;
+      return;
+    }
+
+    scoped_ptr<DictionaryValue> dict(
+        static_cast<DictionaryValue*>(root.release()));
+    // Now put together a proxy configuration from the deserialized string.
+    net::ProxyConfig pc;
+    PopulateProxyConfig(*dict.get(), &pc);
+
+    DCHECK(proxy_service_);
+    scoped_ptr<net::ProxyConfigService> proxy_config_service(
+        new net::ProxyConfigServiceFixed(pc));
+    proxy_service_->ResetConfigService(proxy_config_service.release());
+  }
+
+  void PopulateProxyConfig(const DictionaryValue& dict, net::ProxyConfig* pc) {
+    DCHECK(pc);
+    bool no_proxy = false;
+    if (dict.GetBoolean(automation::kJSONProxyNoProxy, &no_proxy)) {
+      // Make no changes to the ProxyConfig.
+      return;
+    }
+    bool auto_config;
+    if (dict.GetBoolean(automation::kJSONProxyAutoconfig, &auto_config)) {
+      pc->auto_detect = true;
+    }
+    std::string pac_url;
+    if (dict.GetString(automation::kJSONProxyPacUrl, &pac_url)) {
+      pc->pac_url = GURL(pac_url);
+    }
+    std::string proxy_bypass_list;
+    if (dict.GetString(automation::kJSONProxyBypassList, &proxy_bypass_list)) {
+      pc->ParseNoProxyList(proxy_bypass_list);
+    }
+    std::string proxy_server;
+    if (dict.GetString(automation::kJSONProxyServer, &proxy_server)) {
+      pc->proxy_rules.ParseFromString(proxy_server);
+    }
+  }
+
+ private:
+  net::ProxyService* proxy_service_;
+  std::string proxy_config_;
+};
+
+
+void AutomationProvider::SetProxyConfig(const std::string& new_proxy_config) {
+  URLRequestContext* context = Profile::GetDefaultRequestContext();
+  // If we don't have a default request context yet then we have to create
+  // one.
+  bool run_on_ui_thread = false;
+  if (!context) {
+    FilePath user_data_dir;
+    PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
+    ProfileManager* profile_manager = g_browser_process->profile_manager();
+    DCHECK(profile_manager);
+    Profile* profile = profile_manager->GetDefaultProfile(user_data_dir);
+    DCHECK(profile);
+    context = profile->GetRequestContext();
+    run_on_ui_thread = true;
+  }
+  DCHECK(context);
+  // Every URLRequestContext should have a proxy service.
+  net::ProxyService* proxy_service = context->proxy_service();
+  DCHECK(proxy_service);
+
+  // If we just now created the URLRequestContext then we can immediately
+  // set the proxy settings on this (the UI) thread. If there was already
+  // a URLRequestContext, then run the reset on the IO thread.
+  if (run_on_ui_thread) {
+    SetProxyConfigTask set_proxy_config_task(proxy_service, new_proxy_config);
+    set_proxy_config_task.Run();
+  } else {
+    g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
+        new SetProxyConfigTask(proxy_service, new_proxy_config));
+  }
+}
+
 void AutomationProvider::GetDownloadDirectory(
     int handle, std::wstring* download_directory) {
   DLOG(INFO) << "Handling download directory request";
   if (tab_tracker_->ContainsHandle(handle)) {
     NavigationController* tab = tab_tracker_->GetResource(handle);
     DownloadManager* dlm = tab->profile()->GetDownloadManager();
     DCHECK(dlm);
     *download_directory = dlm->download_path().ToWStringHack();
   }
 }
@@ skipping 701 matching lines @@
         DLOG(WARNING) << "SetParent failed. Error 0x%x" << GetLastError();
     }
   }
 }
 #endif
 
 void AutomationProvider::GetWindowTitle(int handle, string16* text) {
   gfx::NativeWindow window = window_tracker_->GetResource(handle);
   text->assign(platform_util::GetWindowTitle(window));
 }