redesign and reimplement proxy config service and tracker, revise proxy ui on cros

chrome/browser/chromeos/proxy_cros_settings_provider.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/chromeos/proxy_cros_settings_provider.h"
 
 #include "base/string_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros_settings.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_list.h"
 
 namespace chromeos {
 
 static const char kProxyPacUrl[]         = "cros.session.proxy.pacurl";
 static const char kProxySingleHttp[]     = "cros.session.proxy.singlehttp";
 static const char kProxySingleHttpPort[] = "cros.session.proxy.singlehttpport";
 static const char kProxyHttpUrl[]        = "cros.session.proxy.httpurl";
 static const char kProxyHttpPort[]       = "cros.session.proxy.httpport";
 static const char kProxyHttpsUrl[]       = "cros.session.proxy.httpsurl";
@@ skipping 18 matching lines @@
   kProxySingle,
   kProxyFtpUrl,
   kProxyFtpPort,
   kProxySocks,
   kProxySocksPort,
   kProxyIgnoreList,
 };
 
 //------------------ ProxyCrosSettingsProvider: public methods -----------------
 
-ProxyCrosSettingsProvider::ProxyCrosSettingsProvider() { }
+ProxyCrosSettingsProvider::ProxyCrosSettingsProvider(Profile* profile)
+    : profile_(profile) {
+}
 
 void ProxyCrosSettingsProvider::SetCurrentNetwork(const std::string& network) {
-  if (!GetConfigService()->UISetCurrentNetwork(network))
-    return;
+  GetConfigService()->UISetCurrentNetwork(network);
   for (size_t i = 0; i < arraysize(kProxySettings); ++i)
     CrosSettings::Get()->FireObservers(kProxySettings[i]);
 }
 
 void ProxyCrosSettingsProvider::MakeActiveNetworkCurrent() {
-  if (!GetConfigService()->UIMakeActiveNetworkCurrent())
-    return;
+  GetConfigService()->UIMakeActiveNetworkCurrent();
   for (size_t i = 0; i < arraysize(kProxySettings); ++i)
     CrosSettings::Get()->FireObservers(kProxySettings[i]);
 }
 
-bool ProxyCrosSettingsProvider::IsUsingSharedProxies() const {
-  return GetConfigService()->use_shared_proxies();
-}
-
-const std::string& ProxyCrosSettingsProvider::GetCurrentNetworkName() const {
-  return GetConfigService()->current_network_name();
-}
-
 void ProxyCrosSettingsProvider::DoSet(const std::string& path,
                                       Value* in_value) {
   if (!in_value) {
     return;
   }
 
   chromeos::ProxyConfigServiceImpl* config_service = GetConfigService();
   // Retrieve proxy config.
   chromeos::ProxyConfigServiceImpl::ProxyConfig config;
   config_service->UIGetProxyConfig(&config);
@@ skipping 146 matching lines @@
       }
       config_service->UISetProxyConfigBypassRules(bypass_rules);
     }
   }
 }
 
 bool ProxyCrosSettingsProvider::Get(const std::string& path,
                                     Value** out_value) const {
   bool found = false;
   bool managed = false;
+  std::string controlled_by;
   Value* data = NULL;
   chromeos::ProxyConfigServiceImpl* config_service = GetConfigService();
   chromeos::ProxyConfigServiceImpl::ProxyConfig config;
   config_service->UIGetProxyConfig(&config);
 
   if (path == kProxyPacUrl) {
     // Only show pacurl for pac-script mode.
     if (config.mode ==
             chromeos::ProxyConfigServiceImpl::ProxyConfig::MODE_PAC_SCRIPT &&
         config.automatic_proxy.pac_url.is_valid()) {
@@ skipping 19 matching lines @@
         chromeos::ProxyConfigServiceImpl::ProxyConfig::MODE_PAC_SCRIPT) {
       data = Value::CreateIntegerValue(3);
     } else if (config.mode ==
         chromeos::ProxyConfigServiceImpl::ProxyConfig::MODE_SINGLE_PROXY ||
         config.mode ==
         chromeos::ProxyConfigServiceImpl::ProxyConfig::MODE_PROXY_PER_SCHEME) {
       data = Value::CreateIntegerValue(2);
     } else {
       data = Value::CreateIntegerValue(1);
     }
+    switch (config.state) {
+       case ProxyPrefs::CONFIG_POLICY:
+         controlled_by = "policyManagedPrefsBannerText";
+         break;
+       case ProxyPrefs::CONFIG_EXTENSION:
+         controlled_by = "extensionManagedPrefsBannerText";
+         break;
+       case ProxyPrefs::CONFIG_OTHER_PRECEDE:
+         controlled_by = "unmodifiablePrefsBannerText";
+         break;
+       case ProxyPrefs::CONFIG_FALLBACK:
+         controlled_by = config.user_modifiable ?
+             "policyManagedPrefsBannerText" : "enableSharedProxiesBannerText";
+         break;
+       default:
+         if (!config.user_modifiable)
+           controlled_by = "enableSharedProxiesBannerText";
+         break;
+    }
     found = true;
   } else if (path == kProxySingle) {
     data = Value::CreateBooleanValue(config.mode ==
         chromeos::ProxyConfigServiceImpl::ProxyConfig::MODE_SINGLE_PROXY);
     found = true;
   } else if (path == kProxyFtpUrl) {
     data = CreateServerHostValue(config.ftp_proxy);
     found = true;
   } else if (path == kProxySocks) {
     data = CreateServerHostValue(config.socks_proxy);
@@ skipping 18 matching lines @@
     }
     *out_value = list;
     return true;
   }
   if (found) {
     DictionaryValue* dict = new DictionaryValue;
     if (!data)
       data = Value::CreateStringValue("");
     dict->Set("value", data);
     dict->SetBoolean("managed", managed);
+    if (path == kProxyType) {
+      dict->SetString("controlledBy", controlled_by);
+      dict->SetBoolean("disabled", !config.user_modifiable);
+    }
     *out_value = dict;
     return true;
   } else {
     *out_value = NULL;
     return false;
   }
 }
 
 bool ProxyCrosSettingsProvider::HandlesSetting(const std::string& path) const {
   return ::StartsWithASCII(path, "cros.session.proxy", true);
 }
 
 //----------------- ProxyCrosSettingsProvider: private methods -----------------
 
 chromeos::ProxyConfigServiceImpl*
     ProxyCrosSettingsProvider::GetConfigService() const {
-  return g_browser_process->chromeos_proxy_config_service_impl();
+  return profile_->GetProxyConfigTracker();
 }
 
 net::ProxyServer ProxyCrosSettingsProvider::CreateProxyServerFromHost(
     const std::string& host,
     const ProxyConfigServiceImpl::ProxyConfig::ManualProxy& proxy,
     net::ProxyServer::Scheme scheme) const {
   uint16 port = 0;
   if (proxy.server.is_valid())
     port = proxy.server.host_port_pair().port();
   if (host.length() == 0 && port == 0)
@@ skipping 25 matching lines @@
 }
 
 Value* ProxyCrosSettingsProvider::CreateServerPortValue(
     const ProxyConfigServiceImpl::ProxyConfig::ManualProxy& proxy) const {
   return proxy.server.is_valid() ?
          Value::CreateIntegerValue(proxy.server.host_port_pair().port()) :
          NULL;
 }
 
 }  // namespace chromeos