Home | History | Annotate | Download | only in prefs 
      1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/prefs/proxy_config_dictionary.h"
      6 
      7 #include "base/basictypes.h"
      8 #include "base/logging.h"
      9 #include "base/values.h"
     10 
     11 namespace {
     12 
     13 // Integer to specify the type of proxy settings.
     14 // See ProxyPrefs for possible values and interactions with the other proxy
     15 // preferences.
     16 const char kProxyMode[] = "mode";
     17 // String specifying the proxy server. For a specification of the expected
     18 // syntax see net::ProxyConfig::ProxyRules::ParseFromString().
     19 const char kProxyServer[] = "server";
     20 // URL to the proxy .pac file.
     21 const char kProxyPacUrl[] = "pac_url";
     22 // Optional boolean flag indicating whether a valid PAC script is mandatory.
     23 // If true, network traffic does not fall back to direct connections in case the
     24 // PAC script is not available.
     25 const char kProxyPacMandatory[] = "pac_mandatory";
     26 // String containing proxy bypass rules. For a specification of the
     27 // expected syntax see net::ProxyBypassRules::ParseFromString().
     28 const char kProxyBypassList[] = "bypass_list";
     29 
     30 }  // namespace
     31 
     32 ProxyConfigDictionary::ProxyConfigDictionary(const base::DictionaryValue* dict)
     33     : dict_(dict->DeepCopy()) {
     34 }
     35 
     36 ProxyConfigDictionary::~ProxyConfigDictionary() {}
     37 
     38 bool ProxyConfigDictionary::GetMode(ProxyPrefs::ProxyMode* out) const {
     39   std::string mode_str;
     40   return dict_->GetString(kProxyMode, &mode_str)
     41       && StringToProxyMode(mode_str, out);
     42 }
     43 
     44 bool ProxyConfigDictionary::GetPacUrl(std::string* out) const {
     45   return dict_->GetString(kProxyPacUrl, out);
     46 }
     47 
     48 bool ProxyConfigDictionary::GetPacMandatory(bool* out) const {
     49   if (!dict_->HasKey(kProxyPacMandatory)) {
     50     *out = false;
     51     return true;
     52   }
     53   return dict_->GetBoolean(kProxyPacMandatory, out);
     54 }
     55 
     56 bool ProxyConfigDictionary::GetProxyServer(std::string* out) const {
     57   return dict_->GetString(kProxyServer, out);
     58 }
     59 
     60 bool ProxyConfigDictionary::GetBypassList(std::string* out) const {
     61   return dict_->GetString(kProxyBypassList, out);
     62 }
     63 
     64 bool ProxyConfigDictionary::HasBypassList() const {
     65   return dict_->HasKey(kProxyBypassList);
     66 }
     67 
     68 const base::DictionaryValue& ProxyConfigDictionary::GetDictionary() const {
     69   return *dict_;
     70 }
     71 
     72 // static
     73 base::DictionaryValue* ProxyConfigDictionary::CreateDirect() {
     74   return CreateDictionary(ProxyPrefs::MODE_DIRECT,
     75                           std::string(),
     76                           false,
     77                           std::string(),
     78                           std::string());
     79 }
     80 
     81 // static
     82 base::DictionaryValue* ProxyConfigDictionary::CreateAutoDetect() {
     83   return CreateDictionary(ProxyPrefs::MODE_AUTO_DETECT,
     84                           std::string(),
     85                           false,
     86                           std::string(),
     87                           std::string());
     88 }
     89 
     90 // static
     91 base::DictionaryValue* ProxyConfigDictionary::CreatePacScript(
     92     const std::string& pac_url,
     93     bool pac_mandatory) {
     94   return CreateDictionary(ProxyPrefs::MODE_PAC_SCRIPT,
     95                           pac_url,
     96                           pac_mandatory,
     97                           std::string(),
     98                           std::string());
     99 }
    100 
    101 // static
    102 base::DictionaryValue* ProxyConfigDictionary::CreateFixedServers(
    103     const std::string& proxy_server,
    104     const std::string& bypass_list) {
    105   if (!proxy_server.empty()) {
    106     return CreateDictionary(ProxyPrefs::MODE_FIXED_SERVERS,
    107                             std::string(),
    108                             false,
    109                             proxy_server,
    110                             bypass_list);
    111   } else {
    112     return CreateDirect();
    113   }
    114 }
    115 
    116 // static
    117 base::DictionaryValue* ProxyConfigDictionary::CreateSystem() {
    118   return CreateDictionary(ProxyPrefs::MODE_SYSTEM,
    119                           std::string(),
    120                           false,
    121                           std::string(),
    122                           std::string());
    123 }
    124 
    125 // static
    126 base::DictionaryValue* ProxyConfigDictionary::CreateDictionary(
    127     ProxyPrefs::ProxyMode mode,
    128     const std::string& pac_url,
    129     bool pac_mandatory,
    130     const std::string& proxy_server,
    131     const std::string& bypass_list) {
    132   base::DictionaryValue* dict = new base::DictionaryValue();
    133   dict->SetString(kProxyMode, ProxyModeToString(mode));
    134   if (!pac_url.empty()) {
    135     dict->SetString(kProxyPacUrl, pac_url);
    136     dict->SetBoolean(kProxyPacMandatory, pac_mandatory);
    137   }
    138   if (!proxy_server.empty())
    139     dict->SetString(kProxyServer, proxy_server);
    140   if (!bypass_list.empty())
    141     dict->SetString(kProxyBypassList, bypass_list);
    142   return dict;
    143 }
    144