Track sources of proxy settings.

net/proxy/proxy_config.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.h"
 
 #include "base/logging.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "net/proxy/proxy_info.h"
@@ skipping 13 matching lines @@
 }  // namespace
 
 ProxyConfig::ProxyRules::ProxyRules()
     : reverse_bypass(false),
       type(TYPE_NO_RULES) {
 }
 
 ProxyConfig::ProxyRules::~ProxyRules() {
 }
 
-void ProxyConfig::ProxyRules::Apply(const GURL& url, ProxyInfo* result) {
+bool ProxyConfig::ProxyRules::Apply(const GURL& url, ProxyInfo* result) const {
   if (empty()) {
     result->UseDirect();
-    return;
+    return false;
   }
 
   bool bypass_proxy = bypass_rules.Matches(url);
   if (reverse_bypass)
     bypass_proxy = !bypass_proxy;
   if (bypass_proxy) {
     result->UseDirect();
-    return;
+    return true;
   }
 
   switch (type) {
     case ProxyRules::TYPE_SINGLE_PROXY: {
       result->UseProxyServer(single_proxy);
-      return;
+      return true;
     }
     case ProxyRules::TYPE_PROXY_PER_SCHEME: {
       const ProxyServer* entry = MapUrlSchemeToProxy(url.scheme());
       if (entry) {
         result->UseProxyServer(*entry);
+        return true;
       } else {
         // We failed to find a matching proxy server for the current URL
         // scheme. Default to direct.
         result->UseDirect();
+        return false;
       }
-      return;
     }
     default: {
       result->UseDirect();
       NOTREACHED();
-      return;
+      return false;
     }
   }
 }
 
 void ProxyConfig::ProxyRules::ParseFromString(const std::string& proxy_rules) {
   // Reset.
   type = TYPE_NO_RULES;
   single_proxy = ProxyServer();
   proxy_for_http = ProxyServer();
   proxy_for_https = ProxyServer();
@@ skipping 73 matching lines @@
   if (scheme == "http")
     return &proxy_for_http;
   if (scheme == "https")
     return &proxy_for_https;
   if (scheme == "ftp")
     return &proxy_for_ftp;
   return NULL;  // No mapping for this scheme.
 }
 
 ProxyConfig::ProxyConfig()
-    : auto_detect_(false), pac_mandatory_(false), id_(kInvalidConfigID)  {
+    : auto_detect_(false), pac_mandatory_(false),
+      source_(PROXY_CONFIG_SOURCE_UNKNOWN), id_(kInvalidConfigID)  {
 }
 
 ProxyConfig::ProxyConfig(const ProxyConfig& config)
     : auto_detect_(config.auto_detect_),
       pac_url_(config.pac_url_),
       pac_mandatory_(config.pac_mandatory_),
       proxy_rules_(config.proxy_rules_),
+      source_(config.source_),
       id_(config.id_) {
 }
 
 ProxyConfig::~ProxyConfig() {
 }
 
 ProxyConfig& ProxyConfig::operator=(const ProxyConfig& config) {
   auto_detect_ = config.auto_detect_;
   pac_url_ = config.pac_url_;
   pac_mandatory_ = config.pac_mandatory_;
   proxy_rules_ = config.proxy_rules_;
+  source_ = config.source_;
   id_ = config.id_;
   return *this;
 }
 
 bool ProxyConfig::Equals(const ProxyConfig& other) const {
-  // The two configs can have different IDs.  We are just interested in if they
-  // have the same settings.
+  // The two configs can have different IDs and sources.  We are just interested
+  // in if they have the same settings.
   return auto_detect_ == other.auto_detect_ &&
          pac_url_ == other.pac_url_ &&
          pac_mandatory_ == other.pac_mandatory_ &&
          proxy_rules_.Equals(other.proxy_rules());
 }
 
 bool ProxyConfig::HasAutomaticSettings() const {
   return auto_detect_ || has_pac_url();
 }
 
@@ skipping 44 matching lines @@
       for (ProxyBypassRules::RuleList::const_iterator it =
               bypass.rules().begin();
            it != bypass.rules().end(); ++it) {
         list->Append(Value::CreateStringValue((*it)->ToString()));
       }
 
       dict->Set("bypass_list", list);
     }
   }
 
+  // Output the source.
+  dict->SetString("source", ProxyConfigSourceToString(source_));
+
   return dict;
 }
 
 }  // namespace net