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";

[Mattias Nissler (ping if slow), 2011/10/19 19:27:36]

This is for showing the banner, correct? Should we actually show the proxy
banner if it's just a recommended policy? We don't do so for any other
preference, so I don't think proxy should behave differently.

[kuan, 2011/10/20 00:41:11]

this is from sumit.  we used to not allow proxy page to be opened when
use-shared-proxies is off, but now that we allow proxy page to be opened, we
need to tell user why the fields are disabled.

[Mattias Nissler (ping if slow), 2011/10/24 10:18:28]

That is true for managed policy. For recommended policy (which I assume we're
talking about here, since the case handler is for CONFIG_FALLBACK), the
textfields shouldn't be disabled, we should just show the default values. Since
they're still editable, this situation is not really different from the regular
behavior, so why should the user be bothered with where the defaults come from?
Also, all other settings UI only shows the banner for managed policy, so I'd
appreciate if we could stay consistent.

[kuan, 2011/10/25 02:01:54]

i'm simply implementing it according to requirements from sumit and kenmoore,
which were decided after long email thread discussions.  sumit wants users to
know the proxy is recommended, hence the banner.  if u still strongly disagree,
do you mind taking this up with sumit?  i will implement whatever is finally
decided.

[Mattias Nissler (ping if slow), 2011/10/25 12:43:11]

I do feel strong about avoiding inconsistency to how the rest of the settings UI
behaves. Recommended settings are not flagged in any other parts of the UI, and
frankly, I don't think it makes sense to flag them specially. I'll respond on
the mail thread.

In the interest of getting this landed, can you just leave out this part and
make the change later if we actually decide for it?

[kuan, 2011/10/25 16:01:50]

Done.

+         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