Allow ProxyConfigService to report "no configuration set"

chrome/browser/net/pref_proxy_config_service_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 "base/command_line.h"
 #include "base/file_path.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/prefs/pref_service_mock_builder.h"
@@ skipping 15 matching lines @@
 // Testing proxy config service that allows us to fire notifications at will.
 class TestProxyConfigService : public net::ProxyConfigService {
  public:
   explicit TestProxyConfigService(const net::ProxyConfig& config)
       : config_(config) {
   }
 
   void SetProxyConfig(const net::ProxyConfig config) {
     config_ = config;
     FOR_EACH_OBSERVER(net::ProxyConfigService::Observer, observers_,
-                      OnProxyConfigChanged(config_));
+                      OnProxyConfigChanged(config, CONFIG_VALID));
   }
 
  private:
   virtual void AddObserver(net::ProxyConfigService::Observer* observer) {
     observers_.AddObserver(observer);
   }
 
   virtual void RemoveObserver(net::ProxyConfigService::Observer* observer) {
     observers_.RemoveObserver(observer);
   }
 
-  virtual bool GetLatestProxyConfig(net::ProxyConfig* config) {
+  virtual net::ProxyConfigService::ConfigAvailability GetLatestProxyConfig(
+      net::ProxyConfig* config) {
     *config = config_;
-    return true;
+    return CONFIG_VALID;
   }
 
   net::ProxyConfig config_;
   ObserverList<net::ProxyConfigService::Observer, true> observers_;
 };
 
 // A mock observer for capturing callbacks.
 class MockObserver : public net::ProxyConfigService::Observer {
  public:
-  MOCK_METHOD1(OnProxyConfigChanged, void(const net::ProxyConfig&));
+  MOCK_METHOD2(OnProxyConfigChanged,
+               void(const net::ProxyConfig&,
+                    net::ProxyConfigService::ConfigAvailability));
 };
 
 template<typename TESTBASE>
 class PrefProxyConfigServiceTestBase : public TESTBASE {
  protected:
   PrefProxyConfigServiceTestBase()
       : ui_thread_(BrowserThread::UI, &loop_),
         io_thread_(BrowserThread::IO, &loop_) {}
 
   virtual void Init(PrefService* pref_service) {
@@ skipping 30 matching lines @@
   virtual void SetUp() {
     pref_service_.reset(new TestingPrefService());
     Init(pref_service_.get());
   }
 
   scoped_ptr<TestingPrefService> pref_service_;
 };
 
 TEST_F(PrefProxyConfigServiceTest, BaseConfiguration) {
   net::ProxyConfig actual_config;
-  proxy_config_service_->GetLatestProxyConfig(&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) {
   pref_service_->SetManagedPref(
       prefs::kProxy,
       ProxyConfigDictionary::CreateFixedServers("http://example.com:3128", ""));
   loop_.RunAllPending();
 
   net::ProxyConfig actual_config;
-  proxy_config_service_->GetLatestProxyConfig(&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,
             actual_config.proxy_rules().type);
   EXPECT_EQ(actual_config.proxy_rules().single_proxy,
             net::ProxyServer::FromURI("http://example.com:3128",
                                       net::ProxyServer::SCHEME_HTTP));
 
   pref_service_->SetManagedPref(prefs::kProxy,
                                 ProxyConfigDictionary::CreateAutoDetect());
   loop_.RunAllPending();
 
-  proxy_config_service_->GetLatestProxyConfig(&actual_config);
+  EXPECT_EQ(net::ProxyConfigService::CONFIG_VALID,
+            proxy_config_service_->GetLatestProxyConfig(&actual_config));
   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) {
+  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))).Times(1);
+  EXPECT_CALL(observer, OnProxyConfigChanged(ProxyConfigMatches(config2),
+                                             CONFIG_VALID)).Times(1);
   delegate_service_->SetProxyConfig(config2);
   loop_.RunAllPending();
   Mock::VerifyAndClearExpectations(&observer);
 
   // Override configuration, this should trigger a notification.
   net::ProxyConfig pref_config;
   pref_config.set_pac_url(GURL(kFixedPacUrl));
 
-  EXPECT_CALL(observer,
-              OnProxyConfigChanged(ProxyConfigMatches(pref_config))).Times(1);
+  EXPECT_CALL(observer, OnProxyConfigChanged(ProxyConfigMatches(pref_config),
+                                             CONFIG_VALID)).Times(1);
   pref_service_->SetManagedPref(
       prefs::kProxy,
       ProxyConfigDictionary::CreatePacScript(kFixedPacUrl));
   loop_.RunAllPending();
   Mock::VerifyAndClearExpectations(&observer);
 
   // Since there are pref overrides, delegate changes should be ignored.
   net::ProxyConfig config3;
   config3.proxy_rules().ParseFromString("http=config3:80");
-  EXPECT_CALL(observer, OnProxyConfigChanged(_)).Times(0);
+  EXPECT_CALL(observer, OnProxyConfigChanged(_, _)).Times(0);
   fixed_config_.set_auto_detect(true);
   delegate_service_->SetProxyConfig(config3);
   loop_.RunAllPending();
   Mock::VerifyAndClearExpectations(&observer);
 
   // Clear the override should switch back to the fixed configuration.
-  EXPECT_CALL(observer,
-              OnProxyConfigChanged(ProxyConfigMatches(config3))).Times(1);
+  EXPECT_CALL(observer, OnProxyConfigChanged(ProxyConfigMatches(config3),
+                                             CONFIG_VALID)).Times(1);
   pref_service_->RemoveManagedPref(prefs::kProxy);
   loop_.RunAllPending();
   Mock::VerifyAndClearExpectations(&observer);
 
   // Delegate service notifications should show up again.
   net::ProxyConfig config4;
   config4.proxy_rules().ParseFromString("socks:config4");
-  EXPECT_CALL(observer,
-              OnProxyConfigChanged(ProxyConfigMatches(config4))).Times(1);
+  EXPECT_CALL(observer, OnProxyConfigChanged(ProxyConfigMatches(config4),
+                                             CONFIG_VALID)).Times(1);
   delegate_service_->SetProxyConfig(config4);
   loop_.RunAllPending();
   Mock::VerifyAndClearExpectations(&observer);
 
   proxy_config_service_->RemoveObserver(&observer);
 }
 
 // Test parameter object for testing command line proxy configuration.
 struct CommandLineTestParams {
   // Explicit assignment operator, so testing::TestWithParam works with MSVC.
@@ skipping 49 matching lines @@
     Init(pref_service_.get());
   }
 
  private:
   CommandLine command_line_;
   scoped_ptr<PrefService> pref_service_;
 };
 
 TEST_P(PrefProxyConfigServiceCommandLineTest, CommandLine) {
   net::ProxyConfig config;
-  proxy_config_service_->GetLatestProxyConfig(&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());
     EXPECT_TRUE(GetParam().proxy_rules.Matches(config.proxy_rules()));
   }
 }
@@ skipping 107 matching lines @@
     net::ProxyRulesExpectation::Empty(),
   },
 };
 
 INSTANTIATE_TEST_CASE_P(
     PrefProxyConfigServiceCommandLineTestInstance,
     PrefProxyConfigServiceCommandLineTest,
     testing::ValuesIn(kCommandLineTestParams));
 
 }  // namespace