Migrate auto_tests about proxy configuration to browser_tests.

chrome/browser/ui/webui/options/preferences_browsertest.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/ui/webui/options/preferences_browsertest.h"
 
 #include <iostream>
 #include <sstream>
 
 #include "base/json/json_reader.h"
@@ skipping 15 matching lines @@
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/browser_test_utils.h"
 #include "googleurl/src/gurl.h"
 #include "policy/policy_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/cros/cros_library.h"
+#include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/browser/chromeos/proxy_cros_settings_parser.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/cros_settings_names.h"
+#include "chrome/browser/prefs/proxy_config_dictionary.h"
+#include "chromeos/network/onc/onc_utils.h"
 #endif
 
 using testing::AllOf;
 using testing::Mock;
 using testing::Property;
 using testing::AnyNumber;
 using testing::Return;
 using testing::_;
 
 namespace base {
@@ skipping 21 matching lines @@
 }
 
 PreferencesBrowserTest::~PreferencesBrowserTest() {
 }
 
 // Navigates to the settings page, causing the JavaScript pref handling code to
 // load and injects JavaScript testing code.
 void PreferencesBrowserTest::SetUpOnMainThread() {
   ui_test_utils::NavigateToURL(browser(),
                                GURL(chrome::kChromeUISettingsFrameURL));
+  SetUpPrefs();
+}
+
+void PreferencesBrowserTest::SetUpPrefs() {
   content::WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
   ASSERT_TRUE(web_contents);
   render_view_host_ = web_contents->GetRenderViewHost();
   ASSERT_TRUE(render_view_host_);
   pref_change_registrar_.Init(components::UserPrefs::Get(browser()->profile()));
   pref_service_ = browser()->profile()->GetPrefs();
   ASSERT_TRUE(content::ExecuteScript(render_view_host_,
       "function TestEnv() {"
       "  this.sentinelName_ = 'download.prompt_for_download';"
@@ skipping 224 matching lines @@
        name != pref_names.end(); ++name)
     javascript << "testEnv.addPref('" << name->c_str() << "');";
   javascript << "testEnv.setupAndReply();";
   std::string temp_observed_json;
   if (!observed_json)
     observed_json = &temp_observed_json;
   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
       render_view_host_, javascript.str(), observed_json));
 }
 
+void PreferencesBrowserTest::SetPref(const std::string& name,
+                                     const std::string& type,
+                                     const base::Value* value,
+                                     bool commit,
+                                     std::string* observed_json) {
+  scoped_ptr<base::Value> commit_ptr(new base::FundamentalValue(commit));
+  std::stringstream javascript;
+  javascript << "testEnv.runAndReply(function() {"
+             << "  Preferences.set" << type << "Pref("
+             << "      '" << name << "',"
+             << "      " << *value << ","
+             << "      " << *commit_ptr << ");"
+             << "});";
+  ASSERT_TRUE(content::ExecuteScriptAndExtractString(
+      render_view_host_, javascript.str(), observed_json));
+}
+
 void PreferencesBrowserTest::VerifySetPref(const std::string& name,
                                            const std::string& type,
                                            const base::Value* value,
                                            bool commit) {
   if (commit)
     ExpectSetCommit(name, value);
   else
     ExpectNoCommit(name);
-  scoped_ptr<base::Value> commit_ptr(new base::FundamentalValue(commit));
-  std::string value_json;
-  std::string commit_json;
-  base::JSONWriter::Write(value, &value_json);
-  base::JSONWriter::Write(commit_ptr.get(), &commit_json);
-  std::stringstream javascript;
-  javascript << "testEnv.runAndReply(function() {"
-             << "    Preferences.set" << type.c_str() << "Pref("
-             << "      '" << name.c_str() << "',"
-             << "      " << value_json.c_str() << ","
-             << "      " << commit_json.c_str() << ");});";
   std::string observed_json;
-  ASSERT_TRUE(content::ExecuteScriptAndExtractString(
-      render_view_host_, javascript.str(), &observed_json));
+  SetPref(name, type, value, commit, &observed_json);
   VerifyObservedPref(observed_json, name, value, std::string(), false, !commit);
   VerifyAndClearExpectations();
 }
 
 void PreferencesBrowserTest::VerifyClearPref(const std::string& name,
                                              const base::Value* value,
                                              bool commit) {
   if (commit)
     ExpectClearCommit(name);
   else
@@ skipping 344 matching lines @@
   // FIXME(bartfab): Find a way to simulate enterprise enrollment in browser
   // tests. Only if Chrome thinks that it is enrolled will the device prefs be
   // decorated with "controlledBy: policy".
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
   VerifyObservedPrefs(observed_json, pref_names_, decorated_non_default_values,
                       "", true, false);
 
   STLDeleteElements(&decorated_non_default_values);
 }
 
-// Verifies that initializing the JavaScript Preferences class fires the correct
-// notifications in JavaScript for pref values handled by the Chrome OS proxy
-// settings parser.
-IN_PROC_BROWSER_TEST_F(PreferencesBrowserTest, ChromeOSProxyFetchPrefs) {
-  std::string observed_json;
+class ProxyPreferencesBrowserTest : public PreferencesBrowserTest {
+ public:
+  virtual void SetUpOnMainThread() OVERRIDE {
+    scoped_ptr<base::DictionaryValue> proxy_config_dict(
+        ProxyConfigDictionary::CreateFixedServers(
+            "127.0.0.1:8080",
+            "*.google.com, 1.2.3.4:22"));
 
+    std::string proxy_config;
+    base::JSONWriter::Write(proxy_config_dict.get(), &proxy_config);
+
+    GetActiveNetwork()->SetProxyConfig(proxy_config);
+
+    ui_test_utils::NavigateToURL(browser(),
+                                 GURL(chrome::kChromeUIProxySettingsURL));
+    SetUpPrefs();
+  }
+
+ protected:
+  chromeos::Network* GetActiveNetwork() {
+    chromeos::NetworkLibrary* network_library =
+        chromeos::CrosLibrary::Get()->GetNetworkLibrary();
+    return const_cast<chromeos::Network*>(network_library->active_network());
+  }
+
+  void SetProxyPref(const std::string& name, const base::Value& value) {
+    std::string type;
+    switch (value.GetType()) {
+      case base::Value::TYPE_BOOLEAN:
+        type = "Boolean";
+        break;
+      case base::Value::TYPE_INTEGER:
+        type = "Integer";
+        break;
+      case base::Value::TYPE_STRING:
+        type = "String";
+        break;
+      default:
+        ASSERT_TRUE(false);
+    }
+
+    std::string observed_json;
+    SetPref(name, type, &value, true, &observed_json);
+  }
+
+  void VerifyCurrentProxyServer(const std::string& expected_server) {
+    scoped_ptr<base::DictionaryValue> proxy_config =
+        chromeos::onc::ReadDictionaryFromJson(
+            GetActiveNetwork()->proxy_config());
+
+    ProxyConfigDictionary proxy_dict(proxy_config.get());
+    std::string actual_proxy_server;
+    EXPECT_TRUE(proxy_dict.GetProxyServer(&actual_proxy_server));
+    EXPECT_EQ(expected_server, actual_proxy_server);
+  }
+};
+
+// Verifies that proxy settings are correctly pushed to JavaScript during
+// initialization of the proxy settings page.
+IN_PROC_BROWSER_TEST_F(ProxyPreferencesBrowserTest,
+                       ChromeOSInitializeProxy) {
   // Boolean pref.
   pref_names_.push_back(chromeos::kProxySingle);
-  default_values_.push_back(new base::FundamentalValue(false));
   non_default_values_.push_back(new base::FundamentalValue(true));
 
   // Integer pref.
   pref_names_.push_back(chromeos::kProxySingleHttpPort);
-  default_values_.push_back(new base::StringValue(""));
   non_default_values_.push_back(new base::FundamentalValue(8080));
 
   // String pref.
   pref_names_.push_back(chromeos::kProxySingleHttp);
-  default_values_.push_back(new base::StringValue(""));
   non_default_values_.push_back(new base::StringValue("127.0.0.1"));
 
   // List pref.
   pref_names_.push_back(chromeos::kProxyIgnoreList);
-  default_values_.push_back(new base::ListValue());
   base::ListValue* list = new base::ListValue();
-  list->Append(new base::StringValue("www.google.com"));
-  list->Append(new base::StringValue("example.com"));
+  list->Append(new base::StringValue("*.google.com"));
+  list->Append(new base::StringValue("1.2.3.4:22"));
   non_default_values_.push_back(list);
 
-  // Verify notifications when default values are in effect.
-  SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
-  VerifyObservedPrefs(observed_json, pref_names_, default_values_,
-                      "", false, false);
-
-  // Verify notifications when user-modified values are in effect.
-  Profile* profile = browser()->profile();
-  // Do not set the Boolean pref. It will toogle automatically.
-  for (size_t i = 1; i < pref_names_.size(); ++i)
-    chromeos::proxy_cros_settings_parser::SetProxyPrefValue(
-        profile, pref_names_[i], non_default_values_[i]->DeepCopy());
+  std::string observed_json;
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
   VerifyObservedPrefs(observed_json, pref_names_, non_default_values_,
                       "", false, false);
 }
 
+// Verifies that modifications to the proxy settings are correctly pushed from
+// JavaScript to the ProxyConfig property stored in the network configuration.
+IN_PROC_BROWSER_TEST_F(ProxyPreferencesBrowserTest, ChromeOSSetProxy) {
+  ASSERT_NO_FATAL_FAILURE(SetupJavaScriptTestEnvironment(pref_names_, NULL));
+
+  SetProxyPref(chromeos::kProxySingleHttpPort, base::FundamentalValue(123));
+  SetProxyPref(chromeos::kProxySingleHttp, base::StringValue("www.adomain.xy"));
+
+  VerifyCurrentProxyServer("www.adomain.xy:123");
+}
+
+// Verify that default proxy ports are used and that ports can be updated
+// without affecting the previously set hosts.
+IN_PROC_BROWSER_TEST_F(ProxyPreferencesBrowserTest, ChromeOSProxyDefaultPorts) {
+  ASSERT_NO_FATAL_FAILURE(SetupJavaScriptTestEnvironment(pref_names_, NULL));
+
+  // Set to manual, per scheme proxy.
+  SetProxyPref(chromeos::kProxySingle, base::FundamentalValue(false));
+
+  // Set hosts but no ports.
+  SetProxyPref(chromeos::kProxyHttpUrl, base::StringValue("a.com"));
+  SetProxyPref(chromeos::kProxyHttpsUrl, base::StringValue("4.3.2.1"));
+  SetProxyPref(chromeos::kProxyFtpUrl, base::StringValue("c.com"));
+  SetProxyPref(chromeos::kProxySocks, base::StringValue("d.com"));
+
+  // Verify default ports.
+  VerifyCurrentProxyServer(
+      "http=a.com:80;https=4.3.2.1:80;ftp=c.com:80;socks=socks4://d.com:1080");
+
+  // Set and verify the ports.
+  SetProxyPref(chromeos::kProxyHttpPort, base::FundamentalValue(1));
+  SetProxyPref(chromeos::kProxyHttpsPort, base::FundamentalValue(2));
+  SetProxyPref(chromeos::kProxyFtpPort, base::FundamentalValue(3));
+  SetProxyPref(chromeos::kProxySocksPort, base::FundamentalValue(4));
+
+  VerifyCurrentProxyServer(
+      "http=a.com:1;https=4.3.2.1:2;ftp=c.com:3;socks=socks4://d.com:4");
+}
+
 #endif