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
11namespace {
12
13// Integer to specify the type of proxy settings.
14// See ProxyPrefs for possible values and interactions with the other proxy
15// preferences.
16const char kProxyMode[] = "mode";
17// String specifying the proxy server. For a specification of the expected
18// syntax see net::ProxyConfig::ProxyRules::ParseFromString().
19const char kProxyServer[] = "server";
20// URL to the proxy .pac file.
21const 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.
25const char kProxyPacMandatory[] = "pac_mandatory";
26// String containing proxy bypass rules. For a specification of the
27// expected syntax see net::ProxyBypassRules::ParseFromString().
28const char kProxyBypassList[] = "bypass_list";
29
30}  // namespace
31
32ProxyConfigDictionary::ProxyConfigDictionary(const base::DictionaryValue* dict)
33    : dict_(dict->DeepCopy()) {
34}
35
36ProxyConfigDictionary::~ProxyConfigDictionary() {}
37
38bool 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
44bool ProxyConfigDictionary::GetPacUrl(std::string* out) const {
45  return dict_->GetString(kProxyPacUrl, out);
46}
47
48bool 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
56bool ProxyConfigDictionary::GetProxyServer(std::string* out) const {
57  return dict_->GetString(kProxyServer, out);
58}
59
60bool ProxyConfigDictionary::GetBypassList(std::string* out) const {
61  return dict_->GetString(kProxyBypassList, out);
62}
63
64bool ProxyConfigDictionary::HasBypassList() const {
65  return dict_->HasKey(kProxyBypassList);
66}
67
68const base::DictionaryValue& ProxyConfigDictionary::GetDictionary() const {
69  return *dict_;
70}
71
72// static
73base::DictionaryValue* ProxyConfigDictionary::CreateDirect() {
74  return CreateDictionary(ProxyPrefs::MODE_DIRECT,
75                          std::string(),
76                          false,
77                          std::string(),
78                          std::string());
79}
80
81// static
82base::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
91base::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
102base::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
117base::DictionaryValue* ProxyConfigDictionary::CreateSystem() {
118  return CreateDictionary(ProxyPrefs::MODE_SYSTEM,
119                          std::string(),
120                          false,
121                          std::string(),
122                          std::string());
123}
124
125// static
126base::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