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

chrome/browser/net/pref_proxy_config_tracker_unittest.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/net/pref_proxy_config_service.h"
+#include "chrome/browser/net/pref_proxy_config_tracker.h"
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/message_loop.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/prefs/pref_service_mock_builder.h"
 #include "chrome/browser/prefs/proxy_config_dictionary.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_pref_service.h"
@@ skipping 47 matching lines @@
 
 // A mock observer for capturing callbacks.
 class MockObserver : public net::ProxyConfigService::Observer {
  public:
   MOCK_METHOD2(OnProxyConfigChanged,
                void(const net::ProxyConfig&,
                     net::ProxyConfigService::ConfigAvailability));
 };
 
 template<typename TESTBASE>
-class PrefProxyConfigServiceTestBase : public TESTBASE {
+class PrefProxyConfigTrackerTestBase : public TESTBASE {
  protected:
-  PrefProxyConfigServiceTestBase()
+  PrefProxyConfigTrackerTestBase()
       : ui_thread_(BrowserThread::UI, &loop_),
         io_thread_(BrowserThread::IO, &loop_) {}
 
   virtual void Init(PrefService* pref_service) {
     ASSERT_TRUE(pref_service);
-    PrefProxyConfigService::RegisterPrefs(pref_service);
+    PrefProxyConfigTracker::RegisterPrefs(pref_service);
     fixed_config_.set_pac_url(GURL(kFixedPacUrl));
     delegate_service_ =
         new TestProxyConfigService(fixed_config_,
                                    net::ProxyConfigService::CONFIG_VALID);
-    proxy_config_tracker_ = new PrefProxyConfigTracker(pref_service);
     proxy_config_service_.reset(
-        new PrefProxyConfigService(proxy_config_tracker_.get(),
-                                   delegate_service_));
+        new ChromeProxyConfigService(delegate_service_));
+    proxy_config_tracker_.reset(new PrefProxyConfigTracker(pref_service));
+    proxy_config_tracker_->SetChromeProxyConfigService(
+        proxy_config_service_.get());
+    // SetChromeProxyConfigService 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_.RunAllPending();
   }
 
   virtual void TearDown() {
     proxy_config_tracker_->DetachFromPrefService();
     loop_.RunAllPending();
+    proxy_config_tracker_.reset();
     proxy_config_service_.reset();
   }
 
   MessageLoop loop_;
   TestProxyConfigService* delegate_service_; // weak
-  scoped_ptr<PrefProxyConfigService> proxy_config_service_;
+  scoped_ptr<ChromeProxyConfigService> proxy_config_service_;
   net::ProxyConfig fixed_config_;
 
  private:
-  scoped_refptr<PrefProxyConfigTracker> proxy_config_tracker_;
+  scoped_ptr<PrefProxyConfigTracker> proxy_config_tracker_;
   BrowserThread ui_thread_;
   BrowserThread io_thread_;
 };
 
-class PrefProxyConfigServiceTest
-    : public PrefProxyConfigServiceTestBase<testing::Test> {
+class PrefProxyConfigTrackerTest
+    : public PrefProxyConfigTrackerTestBase<testing::Test> {
  protected:
   virtual void SetUp() {
     pref_service_.reset(new TestingPrefService());
     Init(pref_service_.get());
   }
 
   scoped_ptr<TestingPrefService> pref_service_;
 };
 
-TEST_F(PrefProxyConfigServiceTest, BaseConfiguration) {
+TEST_F(PrefProxyConfigTrackerTest, BaseConfiguration) {
   net::ProxyConfig actual_config;
   EXPECT_EQ(net::ProxyConfigService::CONFIG_VALID,
             proxy_config_service_->GetLatestProxyConfig(&actual_config));
   EXPECT_EQ(GURL(kFixedPacUrl), actual_config.pac_url());
 }
 
-TEST_F(PrefProxyConfigServiceTest, DynamicPrefOverrides) {
+TEST_F(PrefProxyConfigTrackerTest, DynamicPrefOverrides) {
   pref_service_->SetManagedPref(
       prefs::kProxy,
       ProxyConfigDictionary::CreateFixedServers("http://example.com:3128", ""));
   loop_.RunAllPending();
 
   net::ProxyConfig actual_config;
   EXPECT_EQ(net::ProxyConfigService::CONFIG_VALID,
             proxy_config_service_->GetLatestProxyConfig(&actual_config));
   EXPECT_FALSE(actual_config.auto_detect());
   EXPECT_EQ(net::ProxyConfig::ProxyRules::TYPE_SINGLE_PROXY,
@@ skipping 11 matching lines @@
   EXPECT_TRUE(actual_config.auto_detect());
 }
 
 // Compares proxy configurations, but allows different identifiers.
 MATCHER_P(ProxyConfigMatches, config, "") {
   net::ProxyConfig reference(config);
   reference.set_id(arg.id());
   return reference.Equals(arg);
 }
 
-TEST_F(PrefProxyConfigServiceTest, Observers) {
+TEST_F(PrefProxyConfigTrackerTest, Observers) {
   const net::ProxyConfigService::ConfigAvailability CONFIG_VALID =
       net::ProxyConfigService::CONFIG_VALID;
   MockObserver observer;
   proxy_config_service_->AddObserver(&observer);
 
   // Firing the observers in the delegate should trigger a notification.
   net::ProxyConfig config2;
   config2.set_auto_detect(true);
   EXPECT_CALL(observer, OnProxyConfigChanged(ProxyConfigMatches(config2),
                                              CONFIG_VALID)).Times(1);
@@ skipping 34 matching lines @@
   config4.proxy_rules().ParseFromString("socks:config4");
   EXPECT_CALL(observer, OnProxyConfigChanged(ProxyConfigMatches(config4),
                                              CONFIG_VALID)).Times(1);
   delegate_service_->SetProxyConfig(config4, CONFIG_VALID);
   loop_.RunAllPending();
   Mock::VerifyAndClearExpectations(&observer);
 
   proxy_config_service_->RemoveObserver(&observer);
 }
 
-TEST_F(PrefProxyConfigServiceTest, Fallback) {
+TEST_F(PrefProxyConfigTrackerTest, Fallback) {
   const net::ProxyConfigService::ConfigAvailability CONFIG_VALID =
       net::ProxyConfigService::CONFIG_VALID;
   MockObserver observer;
   net::ProxyConfig actual_config;
   delegate_service_->SetProxyConfig(net::ProxyConfig::CreateDirect(),
                                     net::ProxyConfigService::CONFIG_UNSET);
   proxy_config_service_->AddObserver(&observer);
 
   // Prepare test data.
   net::ProxyConfig recommended_config = net::ProxyConfig::CreateAutoDetect();
@@ skipping 33 matching lines @@
   pref_service_->RemoveManagedPref(prefs::kProxy);
   loop_.RunAllPending();
   Mock::VerifyAndClearExpectations(&observer);
   EXPECT_EQ(CONFIG_VALID,
             proxy_config_service_->GetLatestProxyConfig(&actual_config));
   EXPECT_TRUE(actual_config.Equals(recommended_config));
 
   proxy_config_service_->RemoveObserver(&observer);
 }
 
-TEST_F(PrefProxyConfigServiceTest, ExplicitSystemSettings) {
+TEST_F(PrefProxyConfigTrackerTest, ExplicitSystemSettings) {
   pref_service_->SetRecommendedPref(
       prefs::kProxy,
       ProxyConfigDictionary::CreateAutoDetect());
   pref_service_->SetUserPref(
       prefs::kProxy,
       ProxyConfigDictionary::CreateSystem());
   loop_.RunAllPending();
 
   // Test if we actually use the system setting, which is |kFixedPacUrl|.
   net::ProxyConfig actual_config;
@@ skipping 29 matching lines @@
   bool is_null;
   bool auto_detect;
   GURL pac_url;
   net::ProxyRulesExpectation proxy_rules;
 };
 
 void PrintTo(const CommandLineTestParams& params, std::ostream* os) {
   *os << params.description;
 }
 
-class PrefProxyConfigServiceCommandLineTest
-    : public PrefProxyConfigServiceTestBase<
+class PrefProxyConfigTrackerCommandLineTest
+    : public PrefProxyConfigTrackerTestBase<
           testing::TestWithParam<CommandLineTestParams> > {
  protected:
-  PrefProxyConfigServiceCommandLineTest()
+  PrefProxyConfigTrackerCommandLineTest()
       : command_line_(CommandLine::NO_PROGRAM) {}
 
   virtual void SetUp() {
     for (size_t i = 0; i < arraysize(GetParam().switches); i++) {
       const char* name = GetParam().switches[i].name;
       const char* value = GetParam().switches[i].value;
       if (name && value)
         command_line_.AppendSwitchASCII(name, value);
       else if (name)
         command_line_.AppendSwitch(name);
     }
     pref_service_.reset(
         PrefServiceMockBuilder().WithCommandLine(&command_line_).Create());
     Init(pref_service_.get());
   }
 
  private:
   CommandLine command_line_;
   scoped_ptr<PrefService> pref_service_;
 };
 
-TEST_P(PrefProxyConfigServiceCommandLineTest, CommandLine) {
+TEST_P(PrefProxyConfigTrackerCommandLineTest, CommandLine) {
   net::ProxyConfig config;
   EXPECT_EQ(net::ProxyConfigService::CONFIG_VALID,
             proxy_config_service_->GetLatestProxyConfig(&config));
 
   if (GetParam().is_null) {
     EXPECT_EQ(GURL(kFixedPacUrl), config.pac_url());
   } else {
     EXPECT_NE(GURL(kFixedPacUrl), config.pac_url());
     EXPECT_EQ(GetParam().auto_detect, config.auto_detect());
     EXPECT_EQ(GetParam().pac_url, config.pac_url());
@@ skipping 105 matching lines @@
     },
     // Expected result
     false,                                              // is_null
     true,                                               // auto_detect
     GURL(),                                             // pac_url
     net::ProxyRulesExpectation::Empty(),
   },
 };
 
 INSTANTIATE_TEST_CASE_P(
-    PrefProxyConfigServiceCommandLineTestInstance,
-    PrefProxyConfigServiceCommandLineTest,
+    PrefProxyConfigTrackerCommandLineTestInstance,
+    PrefProxyConfigTrackerCommandLineTest,
     testing::ValuesIn(kCommandLineTestParams));
 
 }  // namespace