arc: update proxy settings from UI and ONC policy.

chrome/browser/chromeos/proxy_config_service_impl.cc

 // Copyright (c) 2012 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_config_service_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/net/proxy_config_handler.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/network/network_profile.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.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 "components/proxy_config/proxy_prefs.h"
 #include "components/user_manager/user_manager.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace chromeos {
 
 namespace {
 
 // Writes the proxy config of |network| to |proxy_config|.  Set |onc_source| to
 // the source of this configuration. Returns false if no
@@ skipping 131 matching lines @@
       return false;
     }
   }
 
   // This network is shared and not managed by the user's domain.
   bool use_shared_proxies = profile_prefs->GetBoolean(prefs::kUseSharedProxies);
   VLOG(1) << "Use proxy of shared network: " << use_shared_proxies;
   return !use_shared_proxies;
 }
 
+// static
+std::unique_ptr<ProxyConfigDictionary>
+ProxyConfigServiceImpl::GetDefaultProxyConfigDictionary(
+    const PrefService* profile_prefs) {
+  const chromeos::NetworkState* network = chromeos::NetworkHandler::Get()
+                                              ->network_state_handler()
+                                              ->DefaultNetwork();
+  if (network) {
+    // Apply Pref Proxy configuration if available.
+    net::ProxyConfig pref_proxy_config;
+    ProxyPrefs::ConfigState pref_state =
+        PrefProxyConfigTrackerImpl::ReadPrefConfig(profile_prefs,
+                                                   &pref_proxy_config);
+    if (PrefProxyConfigTrackerImpl::PrefPrecedes(pref_state)) {
+      const PrefService::Preference* const pref =
+          profile_prefs->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);
+    }

[stevenjb, 2016/09/06 15:49:06]

This section doesn't depend on |network|. We should move it before the
DefaultNetwork() call, unless we only want to return a proxy result if we are
connected to a network in which case I would early exit if !network and add a
comment.

[Polina Bondarenko, 2016/09/06 19:38:46]

Done.

+
+    // Apply network proxy configuration.
+    ::onc::ONCSource onc_source;
+    std::unique_ptr<ProxyConfigDictionary> proxy_config =
+        chromeos::proxy_config::GetProxyConfigForNetwork(
+            profile_prefs, g_browser_process->local_state(), *network,
+            &onc_source);
+    if (!chromeos::ProxyConfigServiceImpl::IgnoreProxy(
+            profile_prefs, network->profile_path(), onc_source))
+      return proxy_config;
+  }
+
+  return base::MakeUnique<ProxyConfigDictionary>(
+      ProxyConfigDictionary::CreateDirect());
+}
+
 void ProxyConfigServiceImpl::DetermineEffectiveConfigFromDefaultNetwork() {
   if (!NetworkHandler::IsInitialized())
     return;
 
   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
   const NetworkState* network = handler->DefaultNetwork();
 
   // Get prefs proxy config if available.
   net::ProxyConfig pref_config;
   ProxyPrefs::ConfigState pref_state = GetProxyConfig(&pref_config);
@@ skipping 57 matching lines @@
       std::unique_ptr<base::DictionaryValue> config_dict(
           effective_config.ToValue());
       VLOG(1) << this << ": Proxy changed: "
               << ProxyPrefs::ConfigStateToDebugString(active_config_state_)
               << ", " << *config_dict;
     }
   }
 }
 
 }  // namespace chromeos