Allow ProxyConfigService to report "no configuration set"

net/proxy/proxy_config_service_linux_unittest.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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 "net/proxy/proxy_config_service_linux.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/task.h"
 #include "base/threading/thread.h"
-#include "base/synchronization/waitable_event.h"
 #include "net/proxy/proxy_config.h"
 #include "net/proxy/proxy_config_service_common_unittest.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace net {
 namespace {
 
 // Set of values for all environment variables that we might
 // query. NULL represents an unset variable.
@@ skipping 253 matching lines @@
   // default glib main loop, which is the UI thread).
   void SetupAndInitialFetch() {
     MessageLoop* file_loop = io_thread_.message_loop();
     DCHECK_EQ(MessageLoop::TYPE_IO, file_loop->type());
     // We pass the mock IO thread as both the IO and file threads.
     config_service_->SetupAndFetchInitialConfig(
         MessageLoop::current(), io_thread_.message_loop(),
         static_cast<MessageLoopForIO*>(file_loop));
   }
   // Synchronously gets the proxy config.
-  bool SyncGetLatestProxyConfig(net::ProxyConfig* config) {
+  net::ProxyConfigService::ConfigAvailability SyncGetLatestProxyConfig(
+      net::ProxyConfig* config) {
     io_thread_.message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
         this, &SynchConfigGetter::GetLatestConfigOnIOThread));
     Wait();
     *config = proxy_config_;
     return get_latest_config_result_;
   }
 
  private:
   // [Runs on |io_thread_|]
   void Init() {
@@ skipping 20 matching lines @@
   }
 
   base::WaitableEvent event_;
   base::Thread io_thread_;
 
   net::ProxyConfigServiceLinux* config_service_;
 
   // The config obtained by |io_thread_| and read back by the main
   // thread.
   net::ProxyConfig proxy_config_;
-  bool get_latest_config_result_;  // Return value from GetLatestProxyConfig().
+
+  // Return value from GetLatestProxyConfig().
+  net::ProxyConfigService::ConfigAvailability get_latest_config_result_;
 };
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(SynchConfigGetter);
 
 namespace net {
 
 // This test fixture is only really needed for the KDEConfigParser test case,
 // but all the test cases with the same prefix ("ProxyConfigServiceLinuxTest")
 // must use the same test fixture class (also "ProxyConfigServiceLinuxTest").
 class ProxyConfigServiceLinuxTest : public PlatformTest {
@@ skipping 42 matching lines @@
 
   // Inspired from proxy_config_service_win_unittest.cc.
   // Very neat, but harder to track down failures though.
   const struct {
     // Short description to identify the test
     std::string description;
 
     // Input.
     GConfValues values;
 
-    // Expected outputs (fields of the ProxyConfig).
+    // Expected outputs (availability and fields of ProxyConfig).
+    ProxyConfigService::ConfigAvailability availability;
     bool auto_detect;
     GURL pac_url;
     ProxyRulesExpectation proxy_rules;
   } tests[] = {
     {
+      TEST_DESC("Invalid"),
+      { // Input.
+        "",                       // mode
+        "",                       // autoconfig_url
+        "", "", "", "",           // hosts
+        0, 0, 0, 0,               // ports
+        FALSE, FALSE, FALSE,      // use, same, auth
+        empty_ignores,            // ignore_hosts
+      },
+
+      // Expected result.
+      ProxyConfigService::CONFIG_UNSET,
+      false,                      // auto_detect
+      GURL(),                     // pac_url
+      ProxyRulesExpectation::Empty(),
+    },
+
+    {
       TEST_DESC("No proxying"),
       { // Input.
         "none",                   // mode
         "",                       // autoconfig_url
         "", "", "", "",           // hosts
         0, 0, 0, 0,               // ports
         FALSE, FALSE, FALSE,      // use, same, auth
         empty_ignores,            // ignore_hosts
       },
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                      // auto_detect
       GURL(),                     // pac_url
       ProxyRulesExpectation::Empty(),
     },
 
     {
       TEST_DESC("Auto detect"),
       { // Input.
         "auto",                   // mode
         "",                       // autoconfig_url
         "", "", "", "",           // hosts
         0, 0, 0, 0,               // ports
         FALSE, FALSE, FALSE,      // use, same, auth
         empty_ignores,            // ignore_hosts
       },
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       true,                       // auto_detect
       GURL(),                     // pac_url
       ProxyRulesExpectation::Empty(),
     },
 
     {
       TEST_DESC("Valid PAC URL"),
       { // Input.
         "auto",                      // mode
         "http://wpad/wpad.dat",      // autoconfig_url
         "", "", "", "",              // hosts
         0, 0, 0, 0,                  // ports
         FALSE, FALSE, FALSE,         // use, same, auth
         empty_ignores,               // ignore_hosts
       },
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                         // auto_detect
       GURL("http://wpad/wpad.dat"),  // pac_url
       ProxyRulesExpectation::Empty(),
     },
 
     {
       TEST_DESC("Invalid PAC URL"),
       { // Input.
         "auto",                      // mode
         "wpad.dat",                  // autoconfig_url
         "", "", "", "",              // hosts
         0, 0, 0, 0,                  // ports
         FALSE, FALSE, FALSE,         // use, same, auth
         empty_ignores,               // ignore_hosts
       },
 
       // Expected result.
-      false,                         // auto_detect
+      ProxyConfigService::CONFIG_VALID,
+      true,                          // auto_detect
       GURL(),                        // pac_url
       ProxyRulesExpectation::Empty(),
     },
 
     {
       TEST_DESC("Single-host in proxy list"),
       { // Input.
         "manual",                              // mode
         "",                                    // autoconfig_url
         "www.google.com", "", "", "",          // hosts
         80, 0, 0, 0,                           // ports
         TRUE, TRUE, FALSE,                     // use, same, auth
         empty_ignores,                         // ignore_hosts
       },
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::Single(
           "www.google.com:80",  // single proxy
           ""),                  // bypass rules
     },
 
     {
       TEST_DESC("use_http_proxy is honored"),
       { // Input.
         "manual",                              // mode
         "",                                    // autoconfig_url
         "www.google.com", "", "", "",          // hosts
         80, 0, 0, 0,                           // ports
         FALSE, TRUE, FALSE,                    // use, same, auth
         empty_ignores,                         // ignore_hosts
       },
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::Empty(),
     },
 
     {
       TEST_DESC("use_http_proxy and use_same_proxy are optional"),
       { // Input.
         "manual",                                     // mode
         "",                                           // autoconfig_url
         "www.google.com", "", "", "",                 // hosts
         80, 0, 0, 0,                                  // ports
         UNSET, UNSET, FALSE,                          // use, same, auth
         empty_ignores,                                // ignore_hosts
       },
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                          // auto_detect
       GURL(),                                         // pac_url
       ProxyRulesExpectation::PerScheme(
           "www.google.com:80",  // http
           "",                   // https
           "",                   // ftp
           ""),                  // bypass rules
     },
 
     {
       TEST_DESC("Single-host, different port"),
       { // Input.
         "manual",                                     // mode
         "",                                           // autoconfig_url
         "www.google.com", "", "", "",                 // hosts
         88, 0, 0, 0,                                  // ports
         TRUE, TRUE, FALSE,                            // use, same, auth
         empty_ignores,                                // ignore_hosts
       },
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                          // auto_detect
       GURL(),                                         // pac_url
       ProxyRulesExpectation::Single(
           "www.google.com:88",  // single proxy
           ""),                  // bypass rules
     },
 
     {
       TEST_DESC("Per-scheme proxy rules"),
       { // Input.
         "manual",                                     // mode
         "",                                           // autoconfig_url
         "www.google.com",                             // http_host
         "www.foo.com",                                // secure_host
         "ftp.foo.com",                                // ftp
         "",                                           // socks
         88, 110, 121, 0,                              // ports
         TRUE, FALSE, FALSE,                           // use, same, auth
         empty_ignores,                                // ignore_hosts
       },
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                          // auto_detect
       GURL(),                                         // pac_url
       ProxyRulesExpectation::PerScheme(
           "www.google.com:88",  // http
           "www.foo.com:110",    // https
           "ftp.foo.com:121",    // ftp
           ""),                  // bypass rules
     },
 
     {
       TEST_DESC("socks"),
       { // Input.
         "manual",                                     // mode
         "",                                           // autoconfig_url
         "", "", "", "socks.com",                      // hosts
         0, 0, 0, 99,                                  // ports
         TRUE, FALSE, FALSE,                           // use, same, auth
         empty_ignores,                                // ignore_hosts
       },
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                          // auto_detect
       GURL(),                                         // pac_url
       ProxyRulesExpectation::Single(
           "socks5://socks.com:99",  // single proxy
           "")                       // bypass rules
     },
 
     {
       TEST_DESC("Bypass *.google.com"),
       { // Input.
         "manual",                                     // mode
         "",                                           // autoconfig_url
         "www.google.com", "", "", "",                 // hosts
         80, 0, 0, 0,                                  // ports
         TRUE, TRUE, FALSE,                            // use, same, auth
         google_ignores,                               // ignore_hosts
       },
 
+      ProxyConfigService::CONFIG_VALID,
       false,                                          // auto_detect
       GURL(),                                         // pac_url
       ProxyRulesExpectation::Single(
           "www.google.com:80",   // single proxy
           "*.google.com"),       // bypass rules
     },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "] %s", i,
                                     tests[i].description.c_str()));
     MockEnvironment* env = new MockEnvironment;
     MockGConfSettingGetter* gconf_getter = new MockGConfSettingGetter;
     SynchConfigGetter sync_config_getter(
         new ProxyConfigServiceLinux(env, gconf_getter));
     ProxyConfig config;
     gconf_getter->values = tests[i].values;
     sync_config_getter.SetupAndInitialFetch();
-    sync_config_getter.SyncGetLatestProxyConfig(&config);
+    ProxyConfigService::ConfigAvailability availability =
+        sync_config_getter.SyncGetLatestProxyConfig(&config);
+    EXPECT_EQ(tests[i].availability, availability);
 
-    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()));
+    if (availability == ProxyConfigService::CONFIG_VALID) {
+      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(ProxyConfigServiceLinuxTest, BasicEnvTest) {
   // Inspired from proxy_config_service_win_unittest.cc.
   const struct {
     // Short description to identify the test
     std::string description;
 
     // Input.
     EnvVarValues values;
 
-    // Expected outputs (fields of the ProxyConfig).
+    // Expected outputs (availability and fields of ProxyConfig).
+    ProxyConfigService::ConfigAvailability availability;
     bool auto_detect;
     GURL pac_url;
     ProxyRulesExpectation proxy_rules;
   } tests[] = {
     {
       TEST_DESC("No proxying"),
       { // Input.
         NULL,  // DESKTOP_SESSION
         NULL,  // HOME
         NULL,  // KDEHOME
         NULL,  // KDE_SESSION_VERSION
         NULL,  // auto_proxy
         NULL,  // all_proxy
         NULL, NULL, NULL,  // per-proto proxies
         NULL, NULL,  // SOCKS
         "*",  // no_proxy
       },
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                      // auto_detect
       GURL(),                     // pac_url
       ProxyRulesExpectation::Empty(),
     },
 
     {
       TEST_DESC("Auto detect"),
       { // Input.
         NULL,  // DESKTOP_SESSION
         NULL,  // HOME
         NULL,  // KDEHOME
         NULL,  // KDE_SESSION_VERSION
         "",    // auto_proxy
         NULL,  // all_proxy
         NULL, NULL, NULL,  // per-proto proxies
         NULL, NULL,  // SOCKS
         NULL,  // no_proxy
       },
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       true,                       // auto_detect
       GURL(),                     // pac_url
       ProxyRulesExpectation::Empty(),
     },
 
     {
       TEST_DESC("Valid PAC URL"),
       { // Input.
         NULL,  // DESKTOP_SESSION
         NULL,  // HOME
         NULL,  // KDEHOME
         NULL,  // KDE_SESSION_VERSION
         "http://wpad/wpad.dat",  // auto_proxy
         NULL,  // all_proxy
         NULL, NULL, NULL,  // per-proto proxies
         NULL, NULL,  // SOCKS
         NULL,  // no_proxy
       },
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                         // auto_detect
       GURL("http://wpad/wpad.dat"),  // pac_url
       ProxyRulesExpectation::Empty(),
     },
 
     {
       TEST_DESC("Invalid PAC URL"),
       { // Input.
         NULL,  // DESKTOP_SESSION
         NULL,  // HOME
         NULL,  // KDEHOME
         NULL,  // KDE_SESSION_VERSION
         "wpad.dat",  // auto_proxy
         NULL,  // all_proxy
         NULL, NULL, NULL,  // per-proto proxies
         NULL, NULL,  // SOCKS
         NULL,  // no_proxy
       },
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                       // auto_detect
       GURL(),                     // pac_url
       ProxyRulesExpectation::Empty(),
     },
 
     {
       TEST_DESC("Single-host in proxy list"),
       { // Input.
         NULL,  // DESKTOP_SESSION
         NULL,  // HOME
         NULL,  // KDEHOME
         NULL,  // KDE_SESSION_VERSION
         NULL,  // auto_proxy
         "www.google.com",  // all_proxy
         NULL, NULL, NULL,  // per-proto proxies
         NULL, NULL,  // SOCKS
         NULL,  // no_proxy
       },
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::Single(
           "www.google.com:80",  // single proxy
           ""),                  // bypass rules
     },
 
     {
       TEST_DESC("Single-host, different port"),
       { // Input.
         NULL,  // DESKTOP_SESSION
         NULL,  // HOME
         NULL,  // KDEHOME
         NULL,  // KDE_SESSION_VERSION
         NULL,  // auto_proxy
         "www.google.com:99",  // all_proxy
         NULL, NULL, NULL,  // per-proto proxies
         NULL, NULL,  // SOCKS
         NULL,  // no_proxy
       },
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::Single(
           "www.google.com:99",  // single
           ""),                  // bypass rules
     },
 
     {
       TEST_DESC("Tolerate a scheme"),
       { // Input.
         NULL,  // DESKTOP_SESSION
         NULL,  // HOME
         NULL,  // KDEHOME
         NULL,  // KDE_SESSION_VERSION
         NULL,  // auto_proxy
         "http://www.google.com:99",  // all_proxy
         NULL, NULL, NULL,  // per-proto proxies
         NULL, NULL,  // SOCKS
         NULL,  // no_proxy
       },
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::Single(
           "www.google.com:99",  // single proxy
           ""),                  // bypass rules
     },
 
     {
       TEST_DESC("Per-scheme proxy rules"),
       { // Input.
         NULL,  // DESKTOP_SESSION
         NULL,  // HOME
         NULL,  // KDEHOME
         NULL,  // KDE_SESSION_VERSION
         NULL,  // auto_proxy
         NULL,  // all_proxy
         "www.google.com:80", "www.foo.com:110", "ftp.foo.com:121",  // per-proto
         NULL, NULL,  // SOCKS
         NULL,  // no_proxy
       },
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::PerScheme(
           "www.google.com:80",  // http
           "www.foo.com:110",    // https
           "ftp.foo.com:121",    // ftp
           ""),                  // bypass rules
     },
 
     {
       TEST_DESC("socks"),
       { // Input.
         NULL,  // DESKTOP_SESSION
         NULL,  // HOME
         NULL,  // KDEHOME
         NULL,  // KDE_SESSION_VERSION
         NULL,  // auto_proxy
         "",  // all_proxy
         NULL, NULL, NULL,  // per-proto proxies
         "socks.com:888", NULL,  // SOCKS
         NULL,  // no_proxy
       },
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::Single(
           "socks5://socks.com:888",  // single proxy
           ""),                       // bypass rules
     },
 
     {
       TEST_DESC("socks4"),
       { // Input.
         NULL,  // DESKTOP_SESSION
         NULL,  // HOME
         NULL,  // KDEHOME
         NULL,  // KDE_SESSION_VERSION
         NULL,  // auto_proxy
         "",  // all_proxy
         NULL, NULL, NULL,  // per-proto proxies
         "socks.com:888", "4",  // SOCKS
         NULL,  // no_proxy
       },
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::Single(
           "socks4://socks.com:888",  // single proxy
           ""),                       // bypass rules
     },
 
     {
       TEST_DESC("socks default port"),
       { // Input.
         NULL,  // DESKTOP_SESSION
         NULL,  // HOME
         NULL,  // KDEHOME
         NULL,  // KDE_SESSION_VERSION
         NULL,  // auto_proxy
         "",  // all_proxy
         NULL, NULL, NULL,  // per-proto proxies
         "socks.com", NULL,  // SOCKS
         NULL,  // no_proxy
       },
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::Single(
           "socks5://socks.com:1080",  // single proxy
           ""),                        // bypass rules
     },
 
     {
       TEST_DESC("bypass"),
       { // Input.
         NULL,  // DESKTOP_SESSION
         NULL,  // HOME
         NULL,  // KDEHOME
         NULL,  // KDE_SESSION_VERSION
         NULL,  // auto_proxy
         "www.google.com",  // all_proxy
         NULL, NULL, NULL,  // per-proto
         NULL, NULL,  // SOCKS
         ".google.com, foo.com:99, 1.2.3.4:22, 127.0.0.1/8",  // no_proxy
       },
 
+      // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                      // auto_detect
       GURL(),                     // pac_url
       ProxyRulesExpectation::Single(
           "www.google.com:80",
           "*.google.com,*foo.com:99,1.2.3.4:22,127.0.0.1/8"),
     },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "] %s", i,
                                     tests[i].description.c_str()));
     MockEnvironment* env = new MockEnvironment;
     MockGConfSettingGetter* gconf_getter = new MockGConfSettingGetter;
     SynchConfigGetter sync_config_getter(
         new ProxyConfigServiceLinux(env, gconf_getter));
     ProxyConfig config;
     env->values = tests[i].values;
     sync_config_getter.SetupAndInitialFetch();
-    sync_config_getter.SyncGetLatestProxyConfig(&config);
+    ProxyConfigService::ConfigAvailability availability =
+        sync_config_getter.SyncGetLatestProxyConfig(&config);
+    EXPECT_EQ(tests[i].availability, availability);
 
-    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()));
+    if (availability == ProxyConfigService::CONFIG_VALID) {
+      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(ProxyConfigServiceLinuxTest, GconfNotification) {
   MockEnvironment* env = new MockEnvironment;
   MockGConfSettingGetter* gconf_getter = new MockGConfSettingGetter;
   ProxyConfigServiceLinux* service =
       new ProxyConfigServiceLinux(env, gconf_getter);
   SynchConfigGetter sync_config_getter(service);
   ProxyConfig config;
 
   // Start with no proxy.
   gconf_getter->values.mode = "none";
   sync_config_getter.SetupAndInitialFetch();
-  sync_config_getter.SyncGetLatestProxyConfig(&config);
+  EXPECT_EQ(ProxyConfigService::CONFIG_VALID,
+            sync_config_getter.SyncGetLatestProxyConfig(&config));
   EXPECT_FALSE(config.auto_detect());
 
   // Now set to auto-detect.
   gconf_getter->values.mode = "auto";
   // Simulate gconf notification callback.
   service->OnCheckProxyConfigSettings();
-  sync_config_getter.SyncGetLatestProxyConfig(&config);
+  EXPECT_EQ(ProxyConfigService::CONFIG_VALID,
+            sync_config_getter.SyncGetLatestProxyConfig(&config));
   EXPECT_TRUE(config.auto_detect());
 }
 
 TEST_F(ProxyConfigServiceLinuxTest, KDEConfigParser) {
   // One of the tests below needs a worst-case long line prefix. We build it
   // programmatically so that it will always be the right size.
   std::string long_line;
   size_t limit = ProxyConfigServiceLinux::GConfSettingGetter::BUFFER_SIZE - 1;
   for (size_t i = 0; i < limit; ++i)
     long_line += "-";
 
   // Inspired from proxy_config_service_win_unittest.cc.
   const struct {
     // Short description to identify the test
     std::string description;
 
     // Input.
     std::string kioslaverc;
     EnvVarValues env_values;
 
-    // Expected outputs (fields of the ProxyConfig).
+    // Expected outputs (availability and fields of ProxyConfig).
+    ProxyConfigService::ConfigAvailability availability;
     bool auto_detect;
     GURL pac_url;
     ProxyRulesExpectation proxy_rules;
   } tests[] = {
     {
       TEST_DESC("No proxying"),
 
       // Input.
       "[Proxy Settings]\nProxyType=0\n",
       {},                                      // env_values
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                      // auto_detect
       GURL(),                     // pac_url
       ProxyRulesExpectation::Empty(),
     },
 
     {
       TEST_DESC("Auto detect"),
 
       // Input.
       "[Proxy Settings]\nProxyType=3\n",
       {},                                      // env_values
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       true,                       // auto_detect
       GURL(),                     // pac_url
       ProxyRulesExpectation::Empty(),
     },
 
     {
       TEST_DESC("Valid PAC URL"),
 
       // Input.
       "[Proxy Settings]\nProxyType=2\n"
           "Proxy Config Script=http://wpad/wpad.dat\n",
       {},                                      // env_values
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                         // auto_detect
       GURL("http://wpad/wpad.dat"),  // pac_url
       ProxyRulesExpectation::Empty(),
     },
 
     {
       TEST_DESC("Per-scheme proxy rules"),
 
       // Input.
       "[Proxy Settings]\nProxyType=1\nhttpProxy=www.google.com\n"
           "httpsProxy=www.foo.com\nftpProxy=ftp.foo.com\n",
       {},                                      // env_values
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::PerScheme(
           "www.google.com:80",  // http
           "www.foo.com:80",     // https
           "ftp.foo.com:80",     // http
           ""),                  // bypass rules
     },
 
     {
       TEST_DESC("Only HTTP proxy specified"),
 
       // Input.
       "[Proxy Settings]\nProxyType=1\n"
           "httpProxy=www.google.com\n",
       {},                                      // env_values
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::PerScheme(
           "www.google.com:80",  // http
           "",                   // https
           "",                   // ftp
           ""),                  // bypass rules
     },
 
     {
       TEST_DESC("Only HTTP proxy specified, different port"),
 
       // Input.
       "[Proxy Settings]\nProxyType=1\n"
           "httpProxy=www.google.com:88\n",
       {},                                      // env_values
 
       // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::PerScheme(
           "www.google.com:88",  // http
           "",                   // https
           "",                   // ftp
           ""),                  // bypass rules
     },
 
     {
       TEST_DESC("Bypass *.google.com"),
 
       // Input.
       "[Proxy Settings]\nProxyType=1\nhttpProxy=www.google.com\n"
           "NoProxyFor=.google.com\n",
       {},                                      // env_values
 
+      // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::PerScheme(
           "www.google.com:80",  // http
           "",                   // https
           "",                   // ftp
           "*.google.com"),      // bypass rules
     },
 
     {
       TEST_DESC("Bypass *.google.com and *.kde.org"),
 
       // Input.
       "[Proxy Settings]\nProxyType=1\nhttpProxy=www.google.com\n"
           "NoProxyFor=.google.com,.kde.org\n",
       {},                                      // env_values
 
+      // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::PerScheme(
           "www.google.com:80",           // http
           "",                            // https
           "",                            // ftp
           "*.google.com,*.kde.org"),     // bypass rules
     },
 
     {
       TEST_DESC("Correctly parse bypass list with ReversedException"),
 
       // Input.
       "[Proxy Settings]\nProxyType=1\nhttpProxy=www.google.com\n"
           "NoProxyFor=.google.com\nReversedException=true\n",
       {},                                      // env_values
 
+      // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::PerSchemeWithBypassReversed(
           "www.google.com:80",  // http
           "",                   // https
           "",                   // ftp
           "*.google.com"),      // bypass rules
     },
 
     {
       TEST_DESC("Treat all hostname patterns as wildcard patterns"),
 
       // Input.
       "[Proxy Settings]\nProxyType=1\nhttpProxy=www.google.com\n"
           "NoProxyFor=google.com,kde.org,<local>\n",
       {},                                      // env_values
 
+      // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::PerScheme(
           "www.google.com:80",              // http
           "",                               // https
           "",                               // ftp
           "*google.com,*kde.org,<local>"),  // bypass rules
     },
 
     {
       TEST_DESC("Allow trailing whitespace after boolean value"),
 
       // Input.
       "[Proxy Settings]\nProxyType=1\nhttpProxy=www.google.com\n"
           "NoProxyFor=.google.com\nReversedException=true  \n",
       {},                                      // env_values
 
+      // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::PerSchemeWithBypassReversed(
           "www.google.com:80",  // http
           "",                   // https
           "",                   // ftp
           "*.google.com"),      // bypass rules
     },
 
     {
       TEST_DESC("Ignore settings outside [Proxy Settings]"),
 
       // Input.
       "httpsProxy=www.foo.com\n[Proxy Settings]\nProxyType=1\n"
           "httpProxy=www.google.com\n[Other Section]\nftpProxy=ftp.foo.com\n",
       {},                                      // env_values
 
+      // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::PerScheme(
           "www.google.com:80",  // http
           "",                   // https
           "",                   // ftp
           ""),                  // bypass rules
     },
 
     {
       TEST_DESC("Handle CRLF line endings"),
 
       // Input.
       "[Proxy Settings]\r\nProxyType=1\r\nhttpProxy=www.google.com\r\n",
       {},                                      // env_values
 
+      // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::PerScheme(
           "www.google.com:80",  // http
           "",                   // https
           "",                   // ftp
           ""),                  // bypass rules
     },
 
     {
       TEST_DESC("Handle blank lines and mixed line endings"),
 
       // Input.
       "[Proxy Settings]\r\n\nProxyType=1\n\r\nhttpProxy=www.google.com\n\n",
       {},                                      // env_values
 
+      // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::PerScheme(
           "www.google.com:80",  // http
           "",                   // https
           "",                   // ftp
           ""),                  // bypass rules
     },
 
     {
       TEST_DESC("Handle localized settings"),
 
       // Input.
       "[Proxy Settings]\nProxyType[$e]=1\nhttpProxy[$e]=www.google.com\n",
       {},                                      // env_values
 
+      // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::PerScheme(
           "www.google.com:80",  // http
           "",                   // https
           "",                   // ftp
           ""),                  // bypass rules
     },
 
     {
       TEST_DESC("Ignore malformed localized settings"),
 
       // Input.
       "[Proxy Settings]\nProxyType=1\nhttpProxy=www.google.com\n"
           "httpsProxy$e]=www.foo.com\nftpProxy=ftp.foo.com\n",
       {},                                      // env_values
 
+      // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::PerScheme(
           "www.google.com:80",  // http
           "",                   // https
           "ftp.foo.com:80",     // ftp
           ""),                  // bypass rules
     },
 
     {
       TEST_DESC("Handle strange whitespace"),
 
       // Input.
       "[Proxy Settings]\nProxyType [$e] =2\n"
           "  Proxy Config Script =  http:// foo\n",
       {},                                      // env_values
 
+      // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL("http:// foo"),                     // pac_url
       ProxyRulesExpectation::Empty(),
     },
 
     {
       TEST_DESC("Ignore all of a line which is too long"),
 
       // Input.
       std::string("[Proxy Settings]\nProxyType=1\nftpProxy=ftp.foo.com\n") +
           long_line + "httpsProxy=www.foo.com\nhttpProxy=www.google.com\n",
       {},                                          // env_values
 
+      // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                       // auto_detect
       GURL(),                                      // pac_url
       ProxyRulesExpectation::PerScheme(
           "www.google.com:80",  // http
           "",                   // https
           "ftp.foo.com:80",     // ftp
           ""),                  // bypass rules
     },
 
     {
       TEST_DESC("Indirect Proxy - no env vars set"),
 
       // Input.
       "[Proxy Settings]\nProxyType=4\nhttpProxy=http_proxy\n"
           "httpsProxy=https_proxy\nftpProxy=ftp_proxy\nNoProxyFor=no_proxy\n",
       {},                                      // env_values
 
+      // Expected result.
+      ProxyConfigService::CONFIG_UNSET,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::Empty(),
     },
 
     {
       TEST_DESC("Indirect Proxy - with env vars set"),
 
       // Input.
       "[Proxy Settings]\nProxyType=4\nhttpProxy=http_proxy\n"
           "httpsProxy=https_proxy\nftpProxy=ftp_proxy\nNoProxyFor=no_proxy\n",
       {  // env_values
         NULL,  // DESKTOP_SESSION
         NULL,  // HOME
         NULL,  // KDEHOME
         NULL,  // KDE_SESSION_VERSION
         NULL,  // auto_proxy
         NULL,  // all_proxy
         "www.normal.com",  // http_proxy
         "www.secure.com",  // https_proxy
         "ftp.foo.com",  // ftp_proxy
         NULL, NULL,  // SOCKS
         ".google.com, .kde.org",  // no_proxy
       },
 
+      // Expected result.
+      ProxyConfigService::CONFIG_VALID,
       false,                                   // auto_detect
       GURL(),                                  // pac_url
       ProxyRulesExpectation::PerScheme(
           "www.normal.com:80",           // http
           "www.secure.com:80",           // https
           "ftp.foo.com:80",              // ftp
           "*.google.com,*.kde.org"),     // bypass rules
     },
 
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "] %s", i,
                                     tests[i].description.c_str()));
     MockEnvironment* env = new MockEnvironment;
     env->values = tests[i].env_values;
     // Force the KDE getter to be used and tell it where the test is.
     env->values.DESKTOP_SESSION = "kde4";
     env->values.KDEHOME = kde_home_.value().c_str();
     SynchConfigGetter sync_config_getter(
         new ProxyConfigServiceLinux(env));
     ProxyConfig config;
     // Overwrite the kioslaverc file.
     file_util::WriteFile(kioslaverc_, tests[i].kioslaverc.c_str(),
                          tests[i].kioslaverc.length());
     sync_config_getter.SetupAndInitialFetch();
-    sync_config_getter.SyncGetLatestProxyConfig(&config);
+    ProxyConfigService::ConfigAvailability availability =
+        sync_config_getter.SyncGetLatestProxyConfig(&config);
+    EXPECT_EQ(tests[i].availability, availability);
 
-    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()));
+    if (availability == ProxyConfigService::CONFIG_VALID) {
+      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(ProxyConfigServiceLinuxTest, KDEHomePicker) {
   // Auto detect proxy settings.
   std::string slaverc3 = "[Proxy Settings]\nProxyType=3\n";
   // Valid PAC URL.
   std::string slaverc4 = "[Proxy Settings]\nProxyType=2\n"
                              "Proxy Config Script=http://wpad/wpad.dat\n";
   GURL slaverc4_pac_url("http://wpad/wpad.dat");
 
   // Overwrite the .kde kioslaverc file.
   file_util::WriteFile(kioslaverc_, slaverc3.c_str(), slaverc3.length());
 
   // If .kde4 exists it will mess up the first test. It should not, as
   // we created the directory for $HOME in the test setup.
   CHECK(!file_util::DirectoryExists(kde4_home_));
 
   { SCOPED_TRACE("KDE4, no .kde4 directory, verify fallback");
     MockEnvironment* env = new MockEnvironment;
     env->values.DESKTOP_SESSION = "kde4";
     env->values.HOME = user_home_.value().c_str();
     SynchConfigGetter sync_config_getter(
         new ProxyConfigServiceLinux(env));
     ProxyConfig config;
     sync_config_getter.SetupAndInitialFetch();
-    sync_config_getter.SyncGetLatestProxyConfig(&config);
+    EXPECT_EQ(ProxyConfigService::CONFIG_VALID,
+              sync_config_getter.SyncGetLatestProxyConfig(&config));
     EXPECT_TRUE(config.auto_detect());
     EXPECT_EQ(GURL(), config.pac_url());
   }
 
   // Now create .kde4 and put a kioslaverc in the config directory.
   // Note that its timestamp will be at least as new as the .kde one.
   file_util::CreateDirectory(kde4_config_);
   file_util::WriteFile(kioslaverc4_, slaverc4.c_str(), slaverc4.length());
   CHECK(file_util::PathExists(kioslaverc4_));
 
   { SCOPED_TRACE("KDE4, .kde4 directory present, use it");
     MockEnvironment* env = new MockEnvironment;
     env->values.DESKTOP_SESSION = "kde4";
     env->values.HOME = user_home_.value().c_str();
     SynchConfigGetter sync_config_getter(
         new ProxyConfigServiceLinux(env));
     ProxyConfig config;
     sync_config_getter.SetupAndInitialFetch();
-    sync_config_getter.SyncGetLatestProxyConfig(&config);
+    EXPECT_EQ(ProxyConfigService::CONFIG_VALID,
+              sync_config_getter.SyncGetLatestProxyConfig(&config));
     EXPECT_FALSE(config.auto_detect());
     EXPECT_EQ(slaverc4_pac_url, config.pac_url());
   }
 
   { SCOPED_TRACE("KDE3, .kde4 directory present, ignore it");
     MockEnvironment* env = new MockEnvironment;
     env->values.DESKTOP_SESSION = "kde";
     env->values.HOME = user_home_.value().c_str();
     SynchConfigGetter sync_config_getter(
         new ProxyConfigServiceLinux(env));
     ProxyConfig config;
     sync_config_getter.SetupAndInitialFetch();
-    sync_config_getter.SyncGetLatestProxyConfig(&config);
+    EXPECT_EQ(ProxyConfigService::CONFIG_VALID,
+              sync_config_getter.SyncGetLatestProxyConfig(&config));
     EXPECT_TRUE(config.auto_detect());
     EXPECT_EQ(GURL(), config.pac_url());
   }
 
   { SCOPED_TRACE("KDE4, .kde4 directory present, KDEHOME set to .kde");
     MockEnvironment* env = new MockEnvironment;
     env->values.DESKTOP_SESSION = "kde4";
     env->values.HOME = user_home_.value().c_str();
     env->values.KDEHOME = kde_home_.value().c_str();
     SynchConfigGetter sync_config_getter(
         new ProxyConfigServiceLinux(env));
     ProxyConfig config;
     sync_config_getter.SetupAndInitialFetch();
-    sync_config_getter.SyncGetLatestProxyConfig(&config);
+    EXPECT_EQ(ProxyConfigService::CONFIG_VALID,
+              sync_config_getter.SyncGetLatestProxyConfig(&config));
     EXPECT_TRUE(config.auto_detect());
     EXPECT_EQ(GURL(), config.pac_url());
   }
 
   // Finally, make the .kde4 config directory older than the .kde directory
   // and make sure we then use .kde instead of .kde4 since it's newer.
   file_util::SetLastModifiedTime(kde4_config_, base::Time());
 
   { SCOPED_TRACE("KDE4, very old .kde4 directory present, use .kde");
     MockEnvironment* env = new MockEnvironment;
     env->values.DESKTOP_SESSION = "kde4";
     env->values.HOME = user_home_.value().c_str();
     SynchConfigGetter sync_config_getter(
         new ProxyConfigServiceLinux(env));
     ProxyConfig config;
     sync_config_getter.SetupAndInitialFetch();
-    sync_config_getter.SyncGetLatestProxyConfig(&config);
+    EXPECT_EQ(ProxyConfigService::CONFIG_VALID,
+              sync_config_getter.SyncGetLatestProxyConfig(&config));
     EXPECT_TRUE(config.auto_detect());
     EXPECT_EQ(GURL(), config.pac_url());
   }
 }
 
 }  // namespace net