Fix proxy from user policy on shared networks.

chrome/browser/chromeos/proxy_config_service_impl_unittest.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 <vector>
 
 #include "base/format_macros.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/strings/stringprintf.h"
+#include "chrome/browser/chromeos/net/proxy_config_handler.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
 #include "chrome/browser/chromeos/ui_proxy_config.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_profile_client.h"
 #include "chromeos/dbus/shill_service_client.h"
 #include "chromeos/network/network_handler.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/pref_registry/testing_pref_service_syncable.h"
 #include "content/public/test/test_browser_thread.h"
+#include "net/proxy/proxy_config.h"
 #include "net/proxy/proxy_config_service_common_unittest.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using content::BrowserThread;
 
 namespace chromeos {
 
 namespace {
 
@@ skipping 161 matching lines @@
     // Expected result.
     false,                          // auto_detect
     GURL(),                         // pac_url
     net::ProxyRulesExpectation::Single(  // proxy_rules
         "www.google.com:80",             // single proxy
         // bypass_rules
         "*.google.com,*foo.com:99,1.2.3.4:22,127.0.0.1/8,<local>"),
   },
 };  // tests
 
+const char kEthernetPolicy[] =
+    "    { \"GUID\": \"{485d6076-dd44-6b6d-69787465725f5040}\","
+    "      \"Type\": \"Ethernet\","
+    "      \"Name\": \"MyEthernet\","
+    "      \"Ethernet\": {"
+    "        \"Authentication\": \"None\" },"
+    "      \"ProxySettings\": {"
+    "        \"PAC\": \"http://domain.com/x\","
+    "        \"Type\": \"PAC\" }"
+    "    }";
+
 const char kUserProfilePath[] = "user_profile";
 
 }  // namespace
 
 class ProxyConfigServiceImplTest : public testing::Test {
  protected:
   ProxyConfigServiceImplTest()
       : ui_thread_(BrowserThread::UI, &loop_),
         io_thread_(BrowserThread::IO, &loop_) {}
 
   void SetUp() override {
     DBusThreadManager::Initialize();
     NetworkHandler::Initialize();
 
-    SetUpNetwork();
+    PrefProxyConfigTrackerImpl::RegisterPrefs(pref_service_.registry());
+    chromeos::proxy_config::RegisterPrefs(pref_service_.registry());
+    PrefProxyConfigTrackerImpl::RegisterProfilePrefs(profile_prefs_.registry());
+    chromeos::proxy_config::RegisterProfilePrefs(profile_prefs_.registry());
+  }
 
-    PrefProxyConfigTrackerImpl::RegisterPrefs(pref_service_.registry());
-
-    // Create a ProxyConfigServiceImpl like for the system request context.
-    config_service_impl_.reset(
-        new ProxyConfigServiceImpl(NULL,  // no profile prefs
-                                   &pref_service_));
+  void SetUpProxyConfigService(bool with_profile_prefs) {

[Andrew T Wilson (Slow), 2015/02/20 13:38:57]

Consider just passing in the PrefService* | or nullptr rather than a boolean
here.

[pneubeck (no reviews), 2015/02/20 13:51:23]

Done.

+    config_service_impl_.reset(new ProxyConfigServiceImpl(
+        with_profile_prefs ? &profile_prefs_ : nullptr, &pref_service_));
     proxy_config_service_ =
         config_service_impl_->CreateTrackingProxyConfigService(
             scoped_ptr<net::ProxyConfigService>());
 
     // CreateTrackingProxyConfigService triggers update of initial prefs proxy
     // config by tracker to chrome proxy config service, so flush all pending
     // tasks so that tests start fresh.
     loop_.RunUntilIdle();
   }
 
-  void SetUpNetwork() {
+  void SetUpPrivateWiFi() {
     ShillProfileClient::TestInterface* profile_test =
         DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface();
     ShillServiceClient::TestInterface* service_test =
         DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
 
     // Process any pending notifications before clearing services.
     loop_.RunUntilIdle();
     service_test->ClearServices();
 
     // Sends a notification about the added profile.
     profile_test->AddProfile(kUserProfilePath, "user_hash");
 
     service_test->AddService("/service/stub_wifi2",
                              "stub_wifi2" /* guid */,
                              "wifi2_PSK",
                              shill::kTypeWifi, shill::kStateOnline,
                              true /* visible */);
     profile_test->AddService(kUserProfilePath, "/service/stub_wifi2");
 
     loop_.RunUntilIdle();
   }
 
+  void SetUpSharedEthernet() {
+    ShillProfileClient::TestInterface* profile_test =
+        DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface();
+    ShillServiceClient::TestInterface* service_test =
+        DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
+
+    // Process any pending notifications before clearing services.
+    loop_.RunUntilIdle();
+    service_test->ClearServices();
+
+    // Sends a notification about the added profile.
+    profile_test->AddProfile(kUserProfilePath, "user_hash");
+
+    service_test->AddService("/service/ethernet", "stub_ethernet" /* guid */,
+                             "eth0", shill::kTypeEthernet, shill::kStateOnline,
+                             true /* visible */);
+    profile_test->AddService(NetworkProfileHandler::GetSharedProfilePath(),
+                             "/service/ethernet");
+
+    loop_.RunUntilIdle();
+  }
+
   void TearDown() override {
     config_service_impl_->DetachFromPrefService();
     loop_.RunUntilIdle();
     config_service_impl_.reset();
     proxy_config_service_.reset();
     NetworkHandler::Shutdown();
     DBusThreadManager::Shutdown();
   }
 
   void InitConfigWithTestInput(const Input& input,
                                base::DictionaryValue* result) {
-    base::DictionaryValue* new_config = NULL;
+    scoped_ptr<base::DictionaryValue> new_config;
     switch (input.mode) {
       case MK_MODE(DIRECT):
-        new_config = ProxyConfigDictionary::CreateDirect();
+        new_config.reset(ProxyConfigDictionary::CreateDirect());
         break;
       case MK_MODE(AUTO_DETECT):
-        new_config = ProxyConfigDictionary::CreateAutoDetect();
+        new_config.reset(ProxyConfigDictionary::CreateAutoDetect());
         break;
       case MK_MODE(PAC_SCRIPT):
-        new_config =
-            ProxyConfigDictionary::CreatePacScript(input.pac_url, false);
+        new_config.reset(
+            ProxyConfigDictionary::CreatePacScript(input.pac_url, false));
         break;
       case MK_MODE(SINGLE_PROXY):
       case MK_MODE(PROXY_PER_SCHEME):
-        new_config =
-          ProxyConfigDictionary::CreateFixedServers(input.server,
-                                                    input.bypass_rules);
+        new_config.reset(ProxyConfigDictionary::CreateFixedServers(
+            input.server, input.bypass_rules));
         break;
     }
-    result->Swap(new_config);
-    delete new_config;
+    result->Swap(new_config.get());
   }
 
-  void SetConfig(base::DictionaryValue* pref_proxy_config_dict) {
+  void SetUserConfigInShill(base::DictionaryValue* pref_proxy_config_dict) {
     std::string proxy_config;
     if (pref_proxy_config_dict)
       base::JSONWriter::Write(pref_proxy_config_dict, &proxy_config);
 
     NetworkStateHandler* network_state_handler =
         NetworkHandler::Get()->network_state_handler();
     const NetworkState* network = network_state_handler->DefaultNetwork();
     ASSERT_TRUE(network);
     DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface()->
         SetServiceProperty(network->path(),
@@ skipping 11 matching lines @@
     net::ProxyConfigService::ConfigAvailability availability =
         proxy_config_service_->GetLatestProxyConfig(config);
 
     EXPECT_EQ(net::ProxyConfigService::CONFIG_VALID, availability);
   }
 
   base::MessageLoop loop_;
   scoped_ptr<net::ProxyConfigService> proxy_config_service_;
   scoped_ptr<ProxyConfigServiceImpl> config_service_impl_;
   TestingPrefServiceSimple pref_service_;
+  user_prefs::TestingPrefServiceSyncable profile_prefs_;
 
  private:
   ScopedTestDeviceSettingsService test_device_settings_service_;
   ScopedTestCrosSettings test_cros_settings_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread io_thread_;
 };
 
 TEST_F(ProxyConfigServiceImplTest, NetworkProxy) {
+  SetUpPrivateWiFi();
+  // Create a ProxyConfigServiceImpl like for the system request context.
+  SetUpProxyConfigService(false /* no profile prefs */);
   for (size_t i = 0; i < arraysize(tests); ++i) {
     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "] %s", i,
                                     tests[i].description.c_str()));
 
     base::DictionaryValue test_config;
     InitConfigWithTestInput(tests[i].input, &test_config);
-    SetConfig(&test_config);
+    SetUserConfigInShill(&test_config);
 
     net::ProxyConfig config;
     SyncGetLatestProxyConfig(&config);
 
     EXPECT_EQ(tests[i].auto_detect, config.auto_detect());
     EXPECT_EQ(tests[i].pac_url, config.pac_url());
     EXPECT_TRUE(tests[i].proxy_rules.Matches(config.proxy_rules()));
   }
 }
 
 TEST_F(ProxyConfigServiceImplTest, DynamicPrefsOverride) {
+  SetUpPrivateWiFi();
+  // Create a ProxyConfigServiceImpl like for the system request context.
+  SetUpProxyConfigService(false /* no profile prefs */);
   // Groupings of 3 test inputs to use for managed, recommended and network
   // proxies respectively.  Only valid and non-direct test inputs are used.
   const size_t proxies[][3] = {
     { 1, 2, 4, },
     { 1, 4, 2, },
     { 4, 2, 1, },
     { 2, 1, 4, },
     { 2, 4, 5, },
     { 2, 5, 4, },
     { 5, 4, 2, },
@@ skipping 24 matching lines @@
 
     base::DictionaryValue managed_config;
     InitConfigWithTestInput(managed_params.input, &managed_config);
     base::DictionaryValue recommended_config;
     InitConfigWithTestInput(recommended_params.input, &recommended_config);
     base::DictionaryValue network_config;
     InitConfigWithTestInput(network_params.input, &network_config);
 
     // Managed proxy pref should take effect over recommended proxy and
     // non-existent network proxy.
-    SetConfig(NULL);
+    SetUserConfigInShill(nullptr);
     pref_service_.SetManagedPref(prefs::kProxy, managed_config.DeepCopy());
     pref_service_.SetRecommendedPref(prefs::kProxy,
                                      recommended_config.DeepCopy());
     net::ProxyConfig actual_config;
     SyncGetLatestProxyConfig(&actual_config);
     EXPECT_EQ(managed_params.auto_detect, actual_config.auto_detect());
     EXPECT_EQ(managed_params.pac_url, actual_config.pac_url());
     EXPECT_TRUE(managed_params.proxy_rules.Matches(
         actual_config.proxy_rules()));
 
     // Recommended proxy pref should take effect when managed proxy pref is
     // removed.
     pref_service_.RemoveManagedPref(prefs::kProxy);
     SyncGetLatestProxyConfig(&actual_config);
     EXPECT_EQ(recommended_params.auto_detect, actual_config.auto_detect());
     EXPECT_EQ(recommended_params.pac_url, actual_config.pac_url());
     EXPECT_TRUE(recommended_params.proxy_rules.Matches(
         actual_config.proxy_rules()));
 
     // Network proxy should take take effect over recommended proxy pref.
-    SetConfig(&network_config);
+    SetUserConfigInShill(&network_config);
     SyncGetLatestProxyConfig(&actual_config);
     EXPECT_EQ(network_params.auto_detect, actual_config.auto_detect());
     EXPECT_EQ(network_params.pac_url, actual_config.pac_url());
     EXPECT_TRUE(network_params.proxy_rules.Matches(
         actual_config.proxy_rules()));
 
     // Managed proxy pref should take effect over network proxy.
     pref_service_.SetManagedPref(prefs::kProxy, managed_config.DeepCopy());
     SyncGetLatestProxyConfig(&actual_config);
     EXPECT_EQ(managed_params.auto_detect, actual_config.auto_detect());
@@ skipping 13 matching lines @@
     // Removing recommended proxy pref should have no effect on network proxy.
     pref_service_.RemoveRecommendedPref(prefs::kProxy);
     SyncGetLatestProxyConfig(&actual_config);
     EXPECT_EQ(network_params.auto_detect, actual_config.auto_detect());
     EXPECT_EQ(network_params.pac_url, actual_config.pac_url());
     EXPECT_TRUE(network_params.proxy_rules.Matches(
         actual_config.proxy_rules()));
   }
 }
 
+// Tests whether the proxy settings from user policy are used for ethernet even
+// if 'UseSharedProxies' is set to false.
+// See https://crbug.com/454966 .
+TEST_F(ProxyConfigServiceImplTest, SharedEthernetAndUserPolicy) {
+  SetUpSharedEthernet();
+  SetUpProxyConfigService(true /* with profile prefs */);
+
+  scoped_ptr<base::DictionaryValue> ethernet_policy(
+      chromeos::onc::ReadDictionaryFromJson(kEthernetPolicy));
+
+  scoped_ptr<base::ListValue> network_configs(new base::ListValue);
+  network_configs->Append(ethernet_policy.release());
+
+  profile_prefs_.SetUserPref(prefs::kUseSharedProxies,
+                             new base::FundamentalValue(false));
+  profile_prefs_.SetManagedPref(prefs::kOpenNetworkConfiguration,
+                                network_configs.release());
+
+  net::ProxyConfig actual_config;
+  SyncGetLatestProxyConfig(&actual_config);
+  net::ProxyConfig expected_config =
+      net::ProxyConfig::CreateFromCustomPacURL(GURL("http://domain.com/x"));
+  EXPECT_TRUE(expected_config.Equals(actual_config));
+}
+
 }  // namespace chromeos