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

chrome/browser/ui/webui/options/chromeos/internet_options_handler.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/ui/webui/options/chromeos/internet_options_handler.h"
 
 #include <ctype.h>
 
 #include <map>
 #include <string>
@@ skipping 14 matching lines @@
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/choose_mobile_network_dialog.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros_settings.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/mobile_config.h"
 #include "chrome/browser/chromeos/options/network_config_view.h"
 #include "chrome/browser/chromeos/sim_dialog_delegate.h"
 #include "chrome/browser/chromeos/status/network_menu_icon.h"
 #include "chrome/browser/chromeos/user_cros_settings_provider.h"
-#include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/views/window.h"
 #include "chrome/browser/ui/webui/web_ui_util.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
-#include "chrome/common/pref_names.h"
 #include "chrome/common/time_format.h"
 #include "content/common/notification_service.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "grit/theme_resources.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "views/widget/widget.h"
@@ skipping 58 matching lines @@
   localized_strings->SetString("activate_button",
       l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_ACTIVATE));
   localized_strings->SetString("buyplan_button",
       l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_BUY_PLAN));
 
   localized_strings->SetString("changeProxyButton",
       l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_CHANGE_PROXY_BUTTON));
-  localized_strings->SetString("enableSharedProxiesHint",
-      l10n_util::GetStringFUTF16(
-          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_ENABLE_SHARED_PROXIES_HINT,
-          l10n_util::GetStringUTF16(IDS_OPTIONS_SETTINGS_USE_SHARED_PROXIES)));
-  localized_strings->SetString("policyManagedProxyText",
-      l10n_util::GetStringUTF16(
-          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_POLICY_MANAGED_PROXY_TEXT));
-  localized_strings->SetString("extensionManagedProxyText",
-      l10n_util::GetStringUTF16(
-        IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_EXTENSION_MANAGED_PROXY_TEXT));
-  localized_strings->SetString("unmodifiableProxyText",
-      l10n_util::GetStringUTF16(
-          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_UNMODIFIABLE_PROXY_TEXT));
 
   localized_strings->SetString("wifiNetworkTabLabel",
       l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_INTERNET_TAB_WIFI));
   localized_strings->SetString("vpnTabLabel",
       l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_INTERNET_TAB_VPN));
   localized_strings->SetString("cellularPlanTabLabel",
       l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_INTERNET_TAB_PLAN));
@@ skipping 530 matching lines @@
 
   cros_->SetIPConfig(chromeos::NetworkIPConfig(network->device_path(),
       dhcp_str == "true" ? chromeos::IPCONFIG_TYPE_DHCP :
                            chromeos::IPCONFIG_TYPE_IPV4,
       address, netmask, gateway, name_servers));
 }
 
 void InternetOptionsHandler::PopulateDictionaryDetails(
     const chromeos::Network* network) {
   DCHECK(network);
-  bool use_shared_proxies = false;
-  if (proxy_settings()) {
+  if (proxy_settings())
     proxy_settings()->SetCurrentNetwork(network->service_path());
-    use_shared_proxies = proxy_settings()->IsUsingSharedProxies();
-  }
   DictionaryValue dictionary;
   std::string hardware_address;
   chromeos::NetworkIPConfigVector ipconfigs = cros_->GetIPConfigs(
       network->device_path(), &hardware_address,
       chromeos::NetworkLibrary::FORMAT_COLON_SEPARATED_HEX);
   if (!hardware_address.empty())
     dictionary.SetString("hardwareAddress", hardware_address);
   for (chromeos::NetworkIPConfigVector::const_iterator it = ipconfigs.begin();
        it != ipconfigs.end(); ++it) {
     const chromeos::NetworkIPConfig& ipconfig = *it;
     scoped_ptr<DictionaryValue> ipconfig_dict(new DictionaryValue());
     ipconfig_dict->SetString("address", ipconfig.address);
     ipconfig_dict->SetString("subnetAddress", ipconfig.netmask);
     ipconfig_dict->SetString("gateway", ipconfig.gateway);
     ipconfig_dict->SetString("dns", ipconfig.name_servers);
     if (ipconfig.type == chromeos::IPCONFIG_TYPE_DHCP)
       dictionary.Set("ipconfigDHCP", ipconfig_dict.release());
     else if (ipconfig.type == chromeos::IPCONFIG_TYPE_IPV4)
       dictionary.Set("ipconfigStatic", ipconfig_dict.release());
   }
 
   chromeos::ConnectionType type = network->type();
   dictionary.SetInteger("type", type);
   dictionary.SetString("servicePath", network->service_path());
   dictionary.SetBoolean("connecting", network->connecting());
   dictionary.SetBoolean("connected", network->connected());
   dictionary.SetString("connectionState", network->GetStateString());
 
-  // Determine if proxy is configurable.
-  // First check proxy prefs.
-  bool proxy_configurable = true;
-  std::string change_proxy_text;
-  if (web_ui_) {
-    const PrefService::Preference* proxy_pref =
-      Profile::FromWebUI(web_ui_)->GetPrefs()->FindPreference(prefs::kProxy);
-    if (proxy_pref && (!proxy_pref->IsUserModifiable() ||
-                       proxy_pref->HasUserSetting())) {
-      proxy_configurable = false;
-      // Provide reason that proxy is managed by admin or extension.
-      if (proxy_pref->IsManaged())
-        change_proxy_text = "policyManagedProxyText";
-      else if (proxy_pref->IsExtensionControlled())
-        change_proxy_text = "extensionManagedProxyText";
-      else
-        change_proxy_text = "unmodifiableProxyText";
-    }
-  }
-  // Next check network type and use-shared-proxies.
-  chromeos::NetworkProfileType profile = network->profile_type();
-  bool shared_network = type == chromeos::TYPE_ETHERNET ||
-                        profile == chromeos::PROFILE_SHARED;
-  if (proxy_configurable) {  // Only check more if proxy  is still configurable.
-    proxy_configurable = profile == chromeos::PROFILE_USER ||
-        (shared_network && use_shared_proxies);
-  }
-  // If no reason has been set yet, provide hint to configure shared proxy.
-  if (change_proxy_text.empty() && shared_network && !use_shared_proxies)
-    change_proxy_text = "enableSharedProxiesHint";
-  // Lastly, store proxy-configurable flag and, if available, text to display.
-  dictionary.SetBoolean("proxyConfigurable", proxy_configurable);
-  if (!change_proxy_text.empty())
-    dictionary.SetString("changeProxyText", change_proxy_text);
+  // Only show proxy for remembered networks.
+  chromeos::NetworkProfileType network_profile = network->profile_type();
+  dictionary.SetBoolean("showProxy", network_profile != chromeos::PROFILE_NONE);
 
   // Hide the dhcp/static radio if not ethernet or wifi (or if not enabled)
   bool staticIPConfig = CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableStaticIPConfig);
   dictionary.SetBoolean("showStaticIPConfig", staticIPConfig &&
       (type == chromeos::TYPE_WIFI || type == chromeos::TYPE_ETHERNET));
 
-  if (network->profile_type() == chromeos::PROFILE_USER) {
+  if (network_profile == chromeos::PROFILE_USER) {
     dictionary.SetBoolean("showPreferred", true);
     dictionary.SetBoolean("preferred", network->preferred());
   } else {
     dictionary.SetBoolean("showPreferred", false);
     dictionary.SetBoolean("preferred", false);
   }
   dictionary.SetBoolean("autoConnect", network->auto_connect());
 
   if (type == chromeos::TYPE_WIFI) {
     dictionary.SetBoolean("deviceConnected", cros_->wifi_connected());
@@ skipping 552 matching lines @@
   dictionary->Set("wirelessList", GetWirelessList());
   dictionary->Set("vpnList", GetVPNList());
   dictionary->Set("rememberedList", GetRememberedList());
   dictionary->SetBoolean("wifiAvailable", cros_->wifi_available());
   dictionary->SetBoolean("wifiBusy", cros_->wifi_busy());
   dictionary->SetBoolean("wifiEnabled", cros_->wifi_enabled());
   dictionary->SetBoolean("cellularAvailable", cros_->cellular_available());
   dictionary->SetBoolean("cellularBusy", cros_->cellular_busy());
   dictionary->SetBoolean("cellularEnabled", cros_->cellular_enabled());
 }