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/net/pref_proxy_config_service.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 20 matching lines @@
   kProxyFtpPort,
   kProxySocks,
   kProxySocksPort,
   kProxyIgnoreList,
 };
 
 //------------------ ProxyCrosSettingsProvider: public methods -----------------
 
 ProxyCrosSettingsProvider::ProxyCrosSettingsProvider() { }
 
+void ProxyCrosSettingsProvider::SetCurrentUserProfile(Profile* profile) {
+  GetConfigService()->UISetCurrentUserProfile(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;
   }
 
@@ skipping 150 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.source) {
+       case PrefProxyConfigTracker::CONFIG_SOURCE_POLICY:
+         controlled_by = "policyManagedPrefsBannerText";
+         break;
+       case PrefProxyConfigTracker::CONFIG_SOURCE_EXTENSION:
+         controlled_by = "extensionManagedPrefsBannerText";
+         break;
+       case PrefProxyConfigTracker::CONFIG_SOURCE_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) {

[Mattias Nissler (ping if slow), 2011/10/07 13:32:10]

why only kProxyType?

[kuan, 2011/10/18 16:25:35]

this is because all the other input fields are enabled or disabled in javascript
based on the value of this input field; u cannot disable a field in native code
and then call "field.disabled = true" in javascript, 'cos they have different
disabled reasons.

+      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);
@@ skipping 42 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