Track sources of proxy settings.

net/proxy/proxy_config_service_linux.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 "net/proxy/proxy_config_service_linux.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #if defined(USE_GCONF)
 #include <gconf/gconf-client.h>
@@ skipping 302 matching lines @@
     }
     // Simulate a change to avoid possibly losing updates before this point.
     OnChangeNotification();
     return true;
   }
 
   virtual base::MessageLoopProxy* GetNotificationLoop() OVERRIDE {
     return loop_;
   }
 
-  virtual const char* GetDataSource() OVERRIDE {
-    return "gconf";
+  virtual ProxyConfigSource GetConfigSource() OVERRIDE {
+    return PROXY_CONFIG_SOURCE_GCONF;
   }
 
   virtual bool GetString(StringSetting key, std::string* result) OVERRIDE {
     switch (key) {
       case PROXY_MODE:
         return GetStringByPath("/system/proxy/mode", result);
       case PROXY_AUTOCONF_URL:
         return GetStringByPath("/system/proxy/autoconfig_url", result);
       case PROXY_HTTP_HOST:
         return GetStringByPath("/system/http_proxy/host", result);
@@ skipping 296 matching lines @@
                      G_CALLBACK(OnGSettingsChangeNotification), this);
     // Simulate a change to avoid possibly losing updates before this point.
     OnChangeNotification();
     return true;
   }
 
   virtual base::MessageLoopProxy* GetNotificationLoop() OVERRIDE {
     return loop_;
   }
 
-  virtual const char* GetDataSource() OVERRIDE {
-    return "gsettings";
+  virtual ProxyConfigSource GetConfigSource() OVERRIDE {
+    return PROXY_CONFIG_SOURCE_GSETTINGS;
   }
 
   virtual bool GetString(StringSetting key, std::string* result) OVERRIDE {
     DCHECK(client_);
     switch (key) {
       case PROXY_MODE:
         return GetStringByPath(client_, "mode", result);
       case PROXY_AUTOCONF_URL:
         return GetStringByPath(client_, "autoconfig-url", result);
       case PROXY_HTTP_HOST:
@@ skipping 386 matching lines @@
   // Implement base::MessagePumpLibevent::Watcher.
   void OnFileCanReadWithoutBlocking(int fd) {
     DCHECK_EQ(fd, inotify_fd_);
     DCHECK(MessageLoop::current() == file_loop_);
     OnChangeNotification();
   }
   void OnFileCanWriteWithoutBlocking(int fd) {
     NOTREACHED();
   }
 
-  virtual const char* GetDataSource() OVERRIDE {
-    return "KDE";
+  virtual ProxyConfigSource GetConfigSource() OVERRIDE {
+    return PROXY_CONFIG_SOURCE_KDE;
   }
 
   virtual bool GetString(StringSetting key, std::string* result) OVERRIDE {
     string_map_type::iterator it = string_table_.find(key);
     if (it == string_table_.end())
       return false;
     *result = it->second;
     return true;
   }
   virtual bool GetBool(BoolSetting key, bool* result) OVERRIDE {
@@ skipping 569 matching lines @@
   // and only fall back to gconf if env vars were unset. But
   // gnome-terminal "helpfully" sets http_proxy and no_proxy, and it
   // does so even if the proxy mode is set to auto, which would
   // mislead us.
 
   bool got_config = false;
   if (setting_getter_.get() &&
       setting_getter_->Init(glib_default_loop, file_loop) &&
       GetConfigFromSettings(&cached_config_)) {
     cached_config_.set_id(1);  // Mark it as valid.
+    cached_config_.set_source(setting_getter_->GetConfigSource());
     VLOG(1) << "Obtained proxy settings from "
-            << setting_getter_->GetDataSource();
+            << ProxyConfigSourceToString(cached_config_.source());
 
     // If gconf proxy mode is "none", meaning direct, then we take
     // that to be a valid config and will not check environment
     // variables. The alternative would have been to look for a proxy
     // whereever we can find one.
     got_config = true;
 
     // Keep a copy of the config for use from this thread for
     // comparison with updated settings when we get notifications.
     reference_config_ = cached_config_;
@@ skipping 19 matching lines @@
       }
     }
   }
 
   if (!got_config) {
     // We fall back on environment variables.
     //
     // Consulting environment variables doesn't need to be done from the
     // default glib main loop, but it's a tiny enough amount of work.
     if (GetConfigFromEnv(&cached_config_)) {
+      cached_config_.set_source(PROXY_CONFIG_SOURCE_ENV);
       cached_config_.set_id(1);  // Mark it as valid.
       VLOG(1) << "Obtained proxy settings from environment variables";
     }
   }
 }
 
 // Depending on the SettingGetter in use, this method will be called
 // on either the UI thread (GConf) or the file thread (KDE).
 void ProxyConfigServiceLinux::Delegate::SetUpNotifications() {
   scoped_refptr<base::MessageLoopProxy> required_loop =
@@ skipping 114 matching lines @@
 void ProxyConfigServiceLinux::RemoveObserver(Observer* observer) {
   delegate_->RemoveObserver(observer);
 }
 
 ProxyConfigService::ConfigAvailability
     ProxyConfigServiceLinux::GetLatestProxyConfig(ProxyConfig* config) {
   return delegate_->GetLatestProxyConfig(config);
 }
 
 }  // namespace net