Initial import of the Chrome Frame codebase. Integration in chrome.gyp coming...

chrome_frame/np_proxy_service.cc

+// Copyright (c) 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 "base/string_util.h"
+#include "chrome/common/automation_constants.h"
+#include "chrome/common/json_value_serializer.h"
+#include "chrome_frame/np_proxy_service.h"
+#include "chrome_frame/np_browser_functions.h"
+
+#include "net/proxy/proxy_config.h"
+
+#include "third_party/xulrunner-sdk/win/include/xpcom/nsXPCOM.h"
+#include "third_party/xulrunner-sdk/win/include/xpcom/nsIObserverService.h"
+#include "third_party/xulrunner-sdk/win/include/xpcom/nsISupportsUtils.h"
+#include "third_party/xulrunner-sdk/win/include/xpcom/nsStringAPI.h"
+
+ASSOCIATE_IID(NS_IOBSERVERSERVICE_IID_STR, nsIObserverService);
+ASSOCIATE_IID(NS_IPREFBRANCH_IID_STR, nsIPrefBranch);
+
+// Firefox preference names.
+const char* kProxyObserverRoot = "network.";
+const char* kProxyObserverBranch = "proxy.";
+const char* kProxyType = "proxy.type";
+const char* kProxyAutoconfigUrl = "proxy.autoconfig_url";
+const char* kProxyBypassList = "proxy.no_proxies_on";
+
+const int kInvalidIntPref = -1;
+
+// These are the proxy schemes that Chrome knows about at the moment.
+// SOCKS is a notable ommission here, this will need to be updated when
+// Chrome supports SOCKS proxies.
+const NpProxyService::ProxyNames NpProxyService::kProxyInfo[] = {
+    {"http", "proxy.http", "proxy.http_port"},
+    {"https", "proxy.ssl", "proxy.ssl_port"},
+    {"ftp", "proxy.ftp", "proxy.ftp_port"} };
+
+NpProxyService::NpProxyService(void)
+    : type_(PROXY_CONFIG_LAST), auto_detect_(false), no_proxy_(false),
+      system_config_(false), automation_client_(NULL) {
+}
+
+NpProxyService::~NpProxyService(void) {
+}
+
+bool NpProxyService::Initialize(NPP instance,
+    ChromeFrameAutomationClient* automation_client) {
+  DCHECK(automation_client);
+  automation_client_ = automation_client;
+
+  // Get the pref service
+  bool result = false;
+  ScopedNsPtr<nsISupports> service_manager_base;
+  npapi::GetValue(instance, NPNVserviceManager, service_manager_base.Receive());
+  if (service_manager_base != NULL) {
+    service_manager_.QueryFrom(service_manager_base);
+    if (service_manager_.get() == NULL) {
+      DLOG(ERROR) << "Failed to create ServiceManager. This only works in FF.";
+    } else {
+      service_manager_->GetServiceByContractID(
+          NS_PREFSERVICE_CONTRACTID, NS_GET_IID(nsIPrefService),
+          reinterpret_cast<void**>(pref_service_.Receive()));
+      if (!pref_service_) {
+        DLOG(ERROR) << "Failed to create PreferencesService";
+      } else {
+        result = InitializePrefBranch(pref_service_);
+      }
+    }
+  }
+  return result;
+}
+
+bool NpProxyService::InitializePrefBranch(nsIPrefService* pref_service) {
+  DCHECK(pref_service);
+  // Note that we cannot persist a reference to the pref branch because we
+  // also act as an observer of changes to the branch. As per
+  // nsIPrefBranch2.h, this would result in a circular reference between us
+  // and the pref branch, which can impede cleanup. There are workarounds,
+  // but let's try just not caching the branch reference for now.
+  bool result = false;
+  ScopedNsPtr<nsIPrefBranch> pref_branch;
+
+  pref_service->ReadUserPrefs(nsnull);
+  pref_service->GetBranch(kProxyObserverRoot, pref_branch.Receive());
+
+  if (!pref_branch) {
+    DLOG(ERROR) << "Failed to get nsIPrefBranch";
+  } else {
+    if (!ReadProxySettings(pref_branch.get())) {
+      DLOG(ERROR) << "Could not read proxy settings.";
+    } else {
+      observer_pref_branch_.QueryFrom(pref_branch);
+      if (!observer_pref_branch_) {
+        DLOG(ERROR) << "Failed to get observer nsIPrefBranch2";
+      } else {
+        nsresult res = observer_pref_branch_->AddObserver(kProxyObserverBranch,
+                                                          this, PR_FALSE);
+        result = NS_SUCCEEDED(res);
+      }
+    }
+  }
+  return result;
+}
+
+bool NpProxyService::UnInitialize() {
+  // Fail early if this was never created - we may not be running on FF.
+  if (!pref_service_)
+    return false;
+
+  // Unhook ourselves as an observer.
+  nsresult res = NS_ERROR_FAILURE;
+  if (observer_pref_branch_)
+    res = observer_pref_branch_->RemoveObserver(kProxyObserverBranch, this);
+
+  return NS_SUCCEEDED(res);
+}
+
+NS_IMETHODIMP NpProxyService::Observe(nsISupports* subject, const char* topic,
+                                     const PRUnichar* data) {
+  if (!subject || !topic) {
+    NOTREACHED();
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  std::string topic_str(topic);
+  nsresult res = NS_OK;
+  if (topic_str == NS_PREFBRANCH_PREFCHANGE_TOPIC_ID) {
+    // Looks like our proxy settings changed. We need to reload!
+    // I have observed some extremely strange behaviour here. Specifically,
+    // we are supposed to be able to QI |subject| and get from it an
+    // nsIPrefBranch from which we can query new values. This has erratic
+    // behaviour, specifically subject starts returning null on all member
+    // queries. So I am using the cached nsIPrefBranch2 (that we used to add
+    // the observer) to do the querying.
+    if (NS_SUCCEEDED(res)) {
+      if (!ReadProxySettings(observer_pref_branch_)) {
+        res = NS_ERROR_UNEXPECTED;
+      } else {
+        std::string proxy_settings;
+        if (GetProxyValueJSONString(&proxy_settings))
+          automation_client_->SetProxySettings(proxy_settings);
+      }
+    }
+  } else {
+    NOTREACHED();
+  }
+
+  return res;
+}
+
+std::string NpProxyService::GetStringPref(nsIPrefBranch* pref_branch,
+                                         const char* pref_name) {
+  nsCString pref_string;
+  std::string result;
+  nsresult rv = pref_branch->GetCharPref(pref_name, getter_Copies(pref_string));
+  if (SUCCEEDED(rv) && pref_string.get()) {
+    result = pref_string.get();
+  }
+  return result;
+}
+
+int NpProxyService::GetIntPref(nsIPrefBranch* pref_branch,
+                              const char* pref_name) {
+  PRInt32 pref_int;
+  int result = kInvalidIntPref;
+  nsresult rv = pref_branch->GetIntPref(pref_name, &pref_int);
+  if (SUCCEEDED(rv)) {
+    result = pref_int;
+  }
+  return result;
+}
+
+bool NpProxyService::GetBoolPref(nsIPrefBranch* pref_branch,
+                                const char* pref_name) {
+  PRBool pref_bool;
+  bool result = false;
+  nsresult rv = pref_branch->GetBoolPref(pref_name, &pref_bool);
+  if (SUCCEEDED(rv)) {
+    result = pref_bool == PR_TRUE;
+  }
+  return result;
+}
+
+void NpProxyService::Reset() {
+  type_ = PROXY_CONFIG_LAST;
+  auto_detect_ = false;
+  no_proxy_ = false;
+  system_config_ = false;
+  manual_proxies_.clear();
+  pac_url_.clear();
+  proxy_bypass_list_.clear();
+}
+
+bool NpProxyService::ReadProxySettings(nsIPrefBranch* pref_branch) {
+  DCHECK(pref_branch);
+
+  // Clear our current settings.
+  Reset();
+  type_ = GetIntPref(pref_branch, kProxyType);
+  if (type_ == kInvalidIntPref) {
+    NOTREACHED();
+    return false;
+  }
+
+  switch (type_) {
+    case PROXY_CONFIG_DIRECT:
+    case PROXY_CONFIG_DIRECT4X:
+      no_proxy_ = true;
+      break;
+    case PROXY_CONFIG_SYSTEM:
+      // _SYSTEM is documented as "Use system settings if available, otherwise
+      // DIRECT". It isn't clear under what circumstances system settings would
+      // be unavailable, but I'll special-case this nonetheless and have
+      // GetProxyValueJSONString() return empty if we get this proxy type.
+      DLOG(WARNING) << "Received PROXY_CONFIG_SYSTEM proxy type.";
+      system_config_ = true;
+      break;
+    case PROXY_CONFIG_WPAD:
+      auto_detect_ = true;
+      break;
+    case PROXY_CONFIG_PAC:
+      pac_url_ = GetStringPref(pref_branch, kProxyAutoconfigUrl);
+      break;
+    case PROXY_CONFIG_MANUAL:
+      // Read in the values for each of the known schemes.
+      for (int i = 0; i < arraysize(kProxyInfo); i++) {
+        ManualProxyEntry entry;
+        entry.url = GetStringPref(pref_branch, kProxyInfo[i].pref_name);
+        entry.port = GetIntPref(pref_branch, kProxyInfo[i].port_pref_name);
+        if (!entry.url.empty() && entry.port != kInvalidIntPref) {
+          entry.scheme = kProxyInfo[i].chrome_scheme;
+          manual_proxies_.push_back(entry);
+        }
+      }
+
+      // Also pick up the list of URLs we bypass proxies for.
+      proxy_bypass_list_ = GetStringPref(pref_branch, kProxyBypassList);
+      break;
+    default:
+      NOTREACHED();
+      return false;
+  }
+  return true;
+}
+
+DictionaryValue* NpProxyService::BuildProxyValueSet() {
+  scoped_ptr<DictionaryValue> proxy_settings_value(new DictionaryValue);
+
+  if (auto_detect_) {
+    proxy_settings_value->SetBoolean(automation::kJSONProxyAutoconfig,
+                                     auto_detect_);
+  }
+
+  if (no_proxy_) {
+    proxy_settings_value->SetBoolean(automation::kJSONProxyNoProxy, no_proxy_);
+  }
+
+  if (!pac_url_.empty()) {
+    proxy_settings_value->SetString(automation::kJSONProxyPacUrl, pac_url_);
+  }
+
+  if (!proxy_bypass_list_.empty()) {
+    proxy_settings_value->SetString(automation::kJSONProxyBypassList,
+                                    proxy_bypass_list_);
+  }
+
+  // Fill in the manual proxy settings. Build a string representation that
+  // corresponds to the format of the input parameter to
+  // ProxyConfig::ProxyRules::ParseFromString.
+  std::string manual_proxy_settings;
+  ManualProxyList::const_iterator iter(manual_proxies_.begin());
+  for (; iter != manual_proxies_.end(); iter++) {
+    DCHECK(!iter->scheme.empty());
+    DCHECK(!iter->url.empty());
+    DCHECK(iter->port != kInvalidIntPref);
+    manual_proxy_settings += iter->scheme;
+    manual_proxy_settings += "=";
+    manual_proxy_settings += iter->url;
+    manual_proxy_settings += ":";
+    manual_proxy_settings += IntToString(iter->port);
+    manual_proxy_settings += ";";
+  }
+
+  if (!manual_proxy_settings.empty()) {
+    proxy_settings_value->SetString(automation::kJSONProxyServer,
+                                    manual_proxy_settings);
+  }
+
+  return proxy_settings_value.release();
+}
+
+bool NpProxyService::GetProxyValueJSONString(std::string* output) {
+  DCHECK(output);
+  output->empty();
+
+  // If we detected a PROXY_CONFIG_SYSTEM config type or failed to obtain the
+  // pref service then return false here to make Chrome continue using its
+  // default proxy settings.
+  if (system_config_ || !pref_service_)
+    return false;
+
+  scoped_ptr<DictionaryValue> proxy_settings_value(BuildProxyValueSet());
+
+  JSONStringValueSerializer serializer(output);
+  return serializer.Serialize(*static_cast<Value*>(proxy_settings_value.get()));
+}