arc: update proxy settings from UI and ONC policy.

chrome/browser/chromeos/arc/arc_settings_service.cc

 // Copyright 2015 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/arc/arc_settings_service.h"
 
 #include <string>
 
 #include "base/gtest_prod_util.h"
 #include "base/json/json_writer.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/arc/arc_auth_service.h"
+#include "chrome/browser/chromeos/net/proxy_config_handler.h"
+#include "chrome/browser/chromeos/proxy_config_service_impl.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/pref_names.h"
+#include "chromeos/network/network_handler.h"
+#include "chromeos/network/network_state.h"
+#include "chromeos/network/network_state_handler.h"
+#include "chromeos/network/network_state_handler_observer.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "chromeos/settings/timezone_settings.h"
 #include "components/arc/intent_helper/font_size_util.h"
 #include "components/prefs/pref_change_registrar.h"
 #include "components/prefs/pref_service.h"
+#include "components/proxy_config/pref_proxy_config_tracker_impl.h"
 #include "components/proxy_config/proxy_config_dictionary.h"
 #include "components/proxy_config/proxy_config_pref_names.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "net/proxy/proxy_config.h"
 
 using ::chromeos::CrosSettings;
 using ::chromeos::system::TimezoneSettings;
 
 namespace {
 
-bool GetHttpProxyServer(const ProxyConfigDictionary& proxy_config_dict,
+std::unique_ptr<ProxyConfigDictionary> GetProxyConfig(
+    const chromeos::NetworkState* network) {
+  Profile* profile = ProfileManager::GetActiveUserProfile();
+
+  // Apply Pref Proxy configuration if available.
+  net::ProxyConfig pref_proxy_config;
+  ProxyPrefs::ConfigState pref_state =
+      PrefProxyConfigTrackerImpl::ReadPrefConfig(profile->GetPrefs(),
+                                                 &pref_proxy_config);
+  if (PrefProxyConfigTrackerImpl::PrefPrecedes(pref_state)) {
+    const PrefService::Preference* const pref =
+        profile->GetPrefs()->FindPreference(proxy_config::prefs::kProxy);
+    const base::DictionaryValue* proxy_config_value;
+    bool value_exists = pref->GetValue()->GetAsDictionary(&proxy_config_value);
+    DCHECK(value_exists);
+
+    return base::MakeUnique<ProxyConfigDictionary>(proxy_config_value);
+  }
+
+  // Apply network proxy configuration.
+  onc::ONCSource onc_source;
+  std::unique_ptr<ProxyConfigDictionary> proxy_config =
+      chromeos::proxy_config::GetProxyConfigForNetwork(
+          profile->GetPrefs(), g_browser_process->local_state(), *network,
+          &onc_source);
+  if (chromeos::ProxyConfigServiceImpl::IgnoreProxy(
+          profile->GetPrefs(), network->profile_path(), onc_source)) {

[stevenjb, 2016/09/02 16:20:55]

Can we put this logic into proxy_config_service_impl.cc? It is similar to 
ProxyConfigServiceImpl::DetermineEffectiveConfigFromDefaultNetwork(). Combining
them might be difficult so I don't think we need to do that, but I would like to
keep the logic in the same place so that if we add it somewhere else we don't
create a third copy of effectively the same logic.

e.g.
proxy_config = chromeos::proxy_config::GetDefaultProxyConfigDictionary(...);
if (proxy_config)
  return proxy_config;

Also, this way we don't need know the implementation details of NetworkState in
this class, GetDefaultProxyConfigDictionary can grab the default network itself.

[Polina Bondarenko, 2016/09/05 20:08:45]

Moved all logic to ProxyConfigServiceImpl and removed GetProxyConfig at all.

+    return base::MakeUnique<ProxyConfigDictionary>(
+        ProxyConfigDictionary::CreateDirect());
+  }

[stevenjb, 2016/09/02 16:20:55]

nit: I would invert this to make the positive results conditional and the
default an empty config.

[Polina Bondarenko, 2016/09/05 20:08:45]

Done.

+  return proxy_config;
+}
+
+bool GetHttpProxyServer(const ProxyConfigDictionary* proxy_config_dict,
                         std::string* host,
                         int* port) {
   std::string proxy_rules_string;
-  if (!proxy_config_dict.GetProxyServer(&proxy_rules_string))
+  if (!proxy_config_dict->GetProxyServer(&proxy_rules_string))
     return false;
 
   net::ProxyConfig::ProxyRules proxy_rules;
   proxy_rules.ParseFromString(proxy_rules_string);
 
   const net::ProxyList* proxy_list = nullptr;
   if (proxy_rules.type == net::ProxyConfig::ProxyRules::TYPE_SINGLE_PROXY) {
     proxy_list = &proxy_rules.single_proxies;
   } else if (proxy_rules.type ==
              net::ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME) {
@@ skipping 10 matching lines @@
 
 }  // namespace
 
 namespace arc {
 
 // Listens to changes for select Chrome settings (prefs) that Android cares
 // about and sends the new values to Android to keep the state in sync.
 class ArcSettingsServiceImpl
     : public chromeos::system::TimezoneSettings::Observer,
       public device::BluetoothAdapter::Observer,
-      public ArcAuthService::Observer {
+      public ArcAuthService::Observer,
+      public chromeos::NetworkStateHandlerObserver {
  public:
   explicit ArcSettingsServiceImpl(ArcBridgeService* arc_bridge_service);
   ~ArcSettingsServiceImpl() override;
 
   // Called when a Chrome pref we have registered an observer for has changed.
   // Obtains the new pref value and sends it to Android.
   void OnPrefChanged(const std::string& pref_name) const;
 
   // TimezoneSettings::Observer:
   void TimezoneChanged(const icu::TimeZone& timezone) override;
 
   // BluetoothAdapter::Observer:
   void AdapterPoweredChanged(device::BluetoothAdapter* adapter,
                              bool powered) override;
 
   // ArcAuthService::Observer:
   void OnInitialStart() override;
 
+  // NetworkStateHandlerObserver:
+  void DefaultNetworkChanged(const chromeos::NetworkState* network) override;
+
  private:
   // Registers to observe changes for Chrome settings we care about.
   void StartObservingSettingsChanges();
 
   // Stops listening for Chrome settings changes.
   void StopObservingSettingsChanges();
 
   // Retrieves Chrome's state for the settings that need to be synced on each
   // Android boot and send it to Android.
   void SyncRuntimeSettings() const;
   // Send settings that need to be synced only on Android first start to
   // Android.
   void SyncInitialSettings() const;
   void SyncFontSize() const;
   void SyncLocale() const;
-  void SyncProxySettings() const;
   void SyncReportingConsent() const;
   void SyncSpokenFeedbackEnabled() const;
   void SyncTimeZone() const;
   void SyncUse24HourClock() const;
   void SyncBackupEnabled() const;
   void SyncLocationServiceEnabled() const;
 
   void OnBluetoothAdapterInitialized(
       scoped_refptr<device::BluetoothAdapter> adapter);
 
   // Registers to listen to a particular perf.
   void AddPrefToObserve(const std::string& pref_name);
 
   // Returns the integer value of the pref.  pref_name must exist.
   int GetIntegerPref(const std::string& pref_name) const;
 
   // Sends boolean pref broadcast to the delegate.
   void SendBoolPrefSettingsBroadcast(const std::string& pref_name,
                                      const std::string& action) const;
 
   // Sends a broadcast to the delegate.
   void SendSettingsBroadcast(const std::string& action,
                              const base::DictionaryValue& extras) const;
 
+  // Sends proxy settings broadcast to the delegate.
+  void SendProxySettingsBroadcast(const ProxyConfigDictionary* proxy_config);
+
   // Manages pref observation registration.
   PrefChangeRegistrar registrar_;
 
   std::unique_ptr<chromeos::CrosSettings::ObserverSubscription>
       reporting_consent_subscription_;
   ArcBridgeService* const arc_bridge_service_;
 
   scoped_refptr<device::BluetoothAdapter> bluetooth_adapter_;
 
+  // Do not send the same proxy configuration.
+  std::unique_ptr<base::DictionaryValue> last_proxy_extras_;
+
   // WeakPtrFactory to use for callback for getting the bluetooth adapter.
   base::WeakPtrFactory<ArcSettingsServiceImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ArcSettingsServiceImpl);
 };
 
 ArcSettingsServiceImpl::ArcSettingsServiceImpl(
     ArcBridgeService* arc_bridge_service)
     : arc_bridge_service_(arc_bridge_service), weak_factory_(this) {
   StartObservingSettingsChanges();
@@ skipping 15 matching lines @@
 
 void ArcSettingsServiceImpl::StartObservingSettingsChanges() {
   Profile* profile = ProfileManager::GetActiveUserProfile();
   registrar_.Init(profile->GetPrefs());
 
   AddPrefToObserve(prefs::kWebKitDefaultFixedFontSize);
   AddPrefToObserve(prefs::kWebKitDefaultFontSize);
   AddPrefToObserve(prefs::kWebKitMinimumFontSize);
   AddPrefToObserve(prefs::kAccessibilitySpokenFeedbackEnabled);
   AddPrefToObserve(prefs::kUse24HourClock);
-  AddPrefToObserve(proxy_config::prefs::kProxy);
   AddPrefToObserve(prefs::kArcBackupRestoreEnabled);
 
   reporting_consent_subscription_ = CrosSettings::Get()->AddSettingsObserver(
       chromeos::kStatsReportingPref,
       base::Bind(&ArcSettingsServiceImpl::SyncReportingConsent,
                  base::Unretained(this)));
 
   TimezoneSettings::GetInstance()->AddObserver(this);
 
   if (device::BluetoothAdapterFactory::IsBluetoothAdapterAvailable()) {
     device::BluetoothAdapterFactory::GetAdapter(
         base::Bind(&ArcSettingsServiceImpl::OnBluetoothAdapterInitialized,
                    weak_factory_.GetWeakPtr()));
   }
+
+  chromeos::NetworkHandler::Get()->network_state_handler()->AddObserver(
+      this, FROM_HERE);
+  const chromeos::NetworkState* network = chromeos::NetworkHandler::Get()
+                                              ->network_state_handler()
+                                              ->DefaultNetwork();
+  if (network) {
+    std::unique_ptr<ProxyConfigDictionary> proxy_config =
+        GetProxyConfig(network);
+    SendProxySettingsBroadcast(proxy_config.get());
+  }

[stevenjb, 2016/09/02 16:20:55]

This could be:
proxy_config = GetProxyConfig();
if (proxy_config)
  SendProxySettingsBroadcast(proxy_config.get());

Which would probably be better, since proxy_config might be based on the prefs,
not the default network.

[Polina Bondarenko, 2016/09/05 20:08:45]

Done.

 }
 
 void ArcSettingsServiceImpl::OnBluetoothAdapterInitialized(
     scoped_refptr<device::BluetoothAdapter> adapter) {
   DCHECK(adapter);
   bluetooth_adapter_ = adapter;
   bluetooth_adapter_->AddObserver(this);
 
   AdapterPoweredChanged(adapter.get(), adapter->IsPowered());
 }
 
 void ArcSettingsServiceImpl::OnInitialStart() {
   SyncInitialSettings();
 }
 
 void ArcSettingsServiceImpl::SyncRuntimeSettings() const {
   SyncFontSize();
   SyncLocale();
-  SyncProxySettings();
   SyncReportingConsent();
   SyncSpokenFeedbackEnabled();
   SyncTimeZone();
   SyncUse24HourClock();
 
   const PrefService* const prefs =
       ProfileManager::GetActiveUserProfile()->GetPrefs();
   if (prefs->IsManagedPreference(prefs::kArcBackupRestoreEnabled))
     SyncBackupEnabled();
   if (prefs->IsManagedPreference(prefs::kArcLocationServiceEnabled))
     SyncLocationServiceEnabled();
 }
 
 void ArcSettingsServiceImpl::SyncInitialSettings() const {
   SyncBackupEnabled();
   SyncLocationServiceEnabled();
 }
 
 void ArcSettingsServiceImpl::StopObservingSettingsChanges() {
   registrar_.RemoveAll();
   reporting_consent_subscription_.reset();
 
   TimezoneSettings::GetInstance()->RemoveObserver(this);
+  chromeos::NetworkHandler::Get()->network_state_handler()->RemoveObserver(
+      this, FROM_HERE);
 }
 
 void ArcSettingsServiceImpl::AddPrefToObserve(const std::string& pref_name) {
   registrar_.Add(pref_name, base::Bind(&ArcSettingsServiceImpl::OnPrefChanged,
                                        base::Unretained(this)));
 }
 
 void ArcSettingsServiceImpl::AdapterPoweredChanged(
     device::BluetoothAdapter* adapter,
     bool powered) {
   base::DictionaryValue extras;
   extras.SetBoolean("enable", powered);
   SendSettingsBroadcast("org.chromium.arc.intent_helper.SET_BLUETOOTH_STATE",
                         extras);
 }
 
 void ArcSettingsServiceImpl::OnPrefChanged(const std::string& pref_name) const {
   if (pref_name == prefs::kAccessibilitySpokenFeedbackEnabled) {
     SyncSpokenFeedbackEnabled();
   } else if (pref_name == prefs::kWebKitDefaultFixedFontSize ||
              pref_name == prefs::kWebKitDefaultFontSize ||
              pref_name == prefs::kWebKitMinimumFontSize) {
     SyncFontSize();
   } else if (pref_name == prefs::kUse24HourClock) {
     SyncUse24HourClock();
-  } else if (pref_name == proxy_config::prefs::kProxy) {
-    SyncProxySettings();
   } else {
     LOG(ERROR) << "Unknown pref changed.";
   }
 }
 
 void ArcSettingsServiceImpl::TimezoneChanged(const icu::TimeZone& timezone) {
   SyncTimeZone();
 }
 
 int ArcSettingsServiceImpl::GetIntegerPref(const std::string& pref_name) const {
@@ skipping 76 matching lines @@
   DCHECK(pref);
   bool use24HourClock = false;
   bool value_exists = pref->GetValue()->GetAsBoolean(&use24HourClock);
   DCHECK(value_exists);
   base::DictionaryValue extras;
   extras.SetBoolean("use24HourClock", use24HourClock);
   SendSettingsBroadcast("org.chromium.arc.intent_helper.SET_USE_24_HOUR_CLOCK",
                         extras);
 }
 
-void ArcSettingsServiceImpl::SyncProxySettings() const {
-  const PrefService::Preference* const pref =
-      registrar_.prefs()->FindPreference(proxy_config::prefs::kProxy);
-  const base::DictionaryValue* proxy_config_value;
-  bool value_exists = pref->GetValue()->GetAsDictionary(&proxy_config_value);
-  DCHECK(value_exists);
-
-  ProxyConfigDictionary proxy_config_dict(proxy_config_value);
-
+void ArcSettingsServiceImpl::SendProxySettingsBroadcast(
+    const ProxyConfigDictionary* proxy_config_dict) {
   ProxyPrefs::ProxyMode mode;
-  if (!proxy_config_dict.GetMode(&mode))
+  if (!proxy_config_dict || !proxy_config_dict->GetMode(&mode))
     mode = ProxyPrefs::MODE_DIRECT;
 
   base::DictionaryValue extras;
   extras.SetString("mode", ProxyPrefs::ProxyModeToString(mode));
 
   switch (mode) {
     case ProxyPrefs::MODE_DIRECT:
       break;
     case ProxyPrefs::MODE_SYSTEM:
       VLOG(1) << "The system mode is not translated.";
       return;
     case ProxyPrefs::MODE_AUTO_DETECT:
       extras.SetString("pacUrl", "http://wpad/wpad.dat");
       break;
     case ProxyPrefs::MODE_PAC_SCRIPT: {
       std::string pac_url;
-      if (!proxy_config_dict.GetPacUrl(&pac_url)) {
+      if (!proxy_config_dict->GetPacUrl(&pac_url)) {
         LOG(ERROR) << "No pac URL for pac_script proxy mode.";
         return;
       }
       extras.SetString("pacUrl", pac_url);
       break;
     }
     case ProxyPrefs::MODE_FIXED_SERVERS: {
       std::string host;
       int port = 0;
       if (!GetHttpProxyServer(proxy_config_dict, &host, &port)) {
         LOG(ERROR) << "No Http proxy server is sent.";
         return;
       }
       extras.SetString("host", host);
       extras.SetInteger("port", port);
 
       std::string bypass_list;
-      if (proxy_config_dict.GetBypassList(&bypass_list) &&
+      if (proxy_config_dict->GetBypassList(&bypass_list) &&
           !bypass_list.empty()) {
         extras.SetString("bypassList", bypass_list);
       }
       break;
     }
     default:
       LOG(ERROR) << "Incorrect proxy mode.";
       return;
   }
 
-  SendSettingsBroadcast("org.chromium.arc.intent_helper.SET_PROXY", extras);
+  if (!last_proxy_extras_ || !last_proxy_extras_->Equals(&extras)) {
+    last_proxy_extras_.reset();
+    last_proxy_extras_ = base::DictionaryValue::From(extras.CreateDeepCopy());
+    SendSettingsBroadcast("org.chromium.arc.intent_helper.SET_PROXY", extras);
+  }
 }
 
 void ArcSettingsServiceImpl::SyncBackupEnabled() const {
   SendBoolPrefSettingsBroadcast(
       prefs::kArcBackupRestoreEnabled,
       "org.chromium.arc.intent_helper.SET_BACKUP_ENABLED");
 }
 
 void ArcSettingsServiceImpl::SyncLocationServiceEnabled() const {
   SendBoolPrefSettingsBroadcast(
@@ skipping 13 matching lines @@
   bool write_success = base::JSONWriter::Write(extras, &extras_json);
   DCHECK(write_success);
 
   if (arc_bridge_service_->intent_helper()->version() >= 1) {
     arc_bridge_service_->intent_helper()->instance()->SendBroadcast(
         action, "org.chromium.arc.intent_helper",
         "org.chromium.arc.intent_helper.SettingsReceiver", extras_json);
   }
 }
 
+void ArcSettingsServiceImpl::DefaultNetworkChanged(
+    const chromeos::NetworkState* network) {
+  std::unique_ptr<ProxyConfigDictionary> proxy_config = GetProxyConfig(network);
+  SendProxySettingsBroadcast(proxy_config.get());

[stevenjb, 2016/09/02 16:20:55]

Do we want to cache the proxy config and only broadcast it if it changes?

Also, we should observe changes to proxy_config::prefs::kProxy also.

[Polina Bondarenko, 2016/09/05 20:08:45]

Yes, added check of the source to reduce the amount of unnecessary calls. 
Fixed, +ONC policy changes.

+}
+
 ArcSettingsService::ArcSettingsService(ArcBridgeService* bridge_service)
     : ArcService(bridge_service) {
   arc_bridge_service()->intent_helper()->AddObserver(this);
 }
 
 ArcSettingsService::~ArcSettingsService() {
   arc_bridge_service()->intent_helper()->RemoveObserver(this);
 }
 
 void ArcSettingsService::OnInstanceReady() {
   impl_.reset(new ArcSettingsServiceImpl(arc_bridge_service()));
 }
 
 void ArcSettingsService::OnInstanceClosed() {
   impl_.reset();
 }
 
 }  // namespace arc