| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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 "net/proxy/proxy_list.h" | |
| 6 | |
| 7 #include "base/callback.h" | |
| 8 #include "base/logging.h" | |
| 9 #include "base/strings/string_tokenizer.h" | |
| 10 #include "base/time/time.h" | |
| 11 #include "base/values.h" | |
| 12 #include "net/proxy/proxy_server.h" | |
| 13 | |
| 14 using base::TimeDelta; | |
| 15 using base::TimeTicks; | |
| 16 | |
| 17 namespace net { | |
| 18 | |
| 19 ProxyList::ProxyList() { | |
| 20 } | |
| 21 | |
| 22 ProxyList::~ProxyList() { | |
| 23 } | |
| 24 | |
| 25 void ProxyList::Set(const std::string& proxy_uri_list) { | |
| 26 proxies_.clear(); | |
| 27 base::StringTokenizer str_tok(proxy_uri_list, ";"); | |
| 28 while (str_tok.GetNext()) { | |
| 29 ProxyServer uri = ProxyServer::FromURI( | |
| 30 str_tok.token_begin(), str_tok.token_end(), ProxyServer::SCHEME_HTTP); | |
| 31 // Silently discard malformed inputs. | |
| 32 if (uri.is_valid()) | |
| 33 proxies_.push_back(uri); | |
| 34 } | |
| 35 } | |
| 36 | |
| 37 void ProxyList::SetSingleProxyServer(const ProxyServer& proxy_server) { | |
| 38 proxies_.clear(); | |
| 39 AddProxyServer(proxy_server); | |
| 40 } | |
| 41 | |
| 42 void ProxyList::AddProxyServer(const ProxyServer& proxy_server) { | |
| 43 if (proxy_server.is_valid()) | |
| 44 proxies_.push_back(proxy_server); | |
| 45 } | |
| 46 | |
| 47 void ProxyList::DeprioritizeBadProxies( | |
| 48 const ProxyRetryInfoMap& proxy_retry_info) { | |
| 49 // Partition the proxy list in two: | |
| 50 // (1) the known bad proxies | |
| 51 // (2) everything else | |
| 52 std::vector<ProxyServer> good_proxies; | |
| 53 std::vector<ProxyServer> bad_proxies_to_try; | |
| 54 | |
| 55 std::vector<ProxyServer>::const_iterator iter = proxies_.begin(); | |
| 56 for (; iter != proxies_.end(); ++iter) { | |
| 57 ProxyRetryInfoMap::const_iterator bad_proxy = | |
| 58 proxy_retry_info.find(iter->ToURI()); | |
| 59 if (bad_proxy != proxy_retry_info.end()) { | |
| 60 // This proxy is bad. Check if it's time to retry. | |
| 61 if (bad_proxy->second.bad_until >= TimeTicks::Now()) { | |
| 62 // still invalid. | |
| 63 if (bad_proxy->second.try_while_bad) | |
| 64 bad_proxies_to_try.push_back(*iter); | |
| 65 continue; | |
| 66 } | |
| 67 } | |
| 68 good_proxies.push_back(*iter); | |
| 69 } | |
| 70 | |
| 71 // "proxies_ = good_proxies + bad_proxies" | |
| 72 proxies_.swap(good_proxies); | |
| 73 proxies_.insert(proxies_.end(), bad_proxies_to_try.begin(), | |
| 74 bad_proxies_to_try.end()); | |
| 75 } | |
| 76 | |
| 77 void ProxyList::RemoveProxiesWithoutScheme(int scheme_bit_field) { | |
| 78 for (std::vector<ProxyServer>::iterator it = proxies_.begin(); | |
| 79 it != proxies_.end(); ) { | |
| 80 if (!(scheme_bit_field & it->scheme())) { | |
| 81 it = proxies_.erase(it); | |
| 82 continue; | |
| 83 } | |
| 84 ++it; | |
| 85 } | |
| 86 } | |
| 87 | |
| 88 void ProxyList::Clear() { | |
| 89 proxies_.clear(); | |
| 90 } | |
| 91 | |
| 92 bool ProxyList::IsEmpty() const { | |
| 93 return proxies_.empty(); | |
| 94 } | |
| 95 | |
| 96 size_t ProxyList::size() const { | |
| 97 return proxies_.size(); | |
| 98 } | |
| 99 | |
| 100 // Returns true if |*this| lists the same proxies as |other|. | |
| 101 bool ProxyList::Equals(const ProxyList& other) const { | |
| 102 if (size() != other.size()) | |
| 103 return false; | |
| 104 return proxies_ == other.proxies_; | |
| 105 } | |
| 106 | |
| 107 const ProxyServer& ProxyList::Get() const { | |
| 108 DCHECK(!proxies_.empty()); | |
| 109 return proxies_[0]; | |
| 110 } | |
| 111 | |
| 112 void ProxyList::SetFromPacString(const std::string& pac_string) { | |
| 113 base::StringTokenizer entry_tok(pac_string, ";"); | |
| 114 proxies_.clear(); | |
| 115 while (entry_tok.GetNext()) { | |
| 116 ProxyServer uri = ProxyServer::FromPacString( | |
| 117 entry_tok.token_begin(), entry_tok.token_end()); | |
| 118 // Silently discard malformed inputs. | |
| 119 if (uri.is_valid()) | |
| 120 proxies_.push_back(uri); | |
| 121 } | |
| 122 | |
| 123 // If we failed to parse anything from the PAC results list, fallback to | |
| 124 // DIRECT (this basically means an error in the PAC script). | |
| 125 if (proxies_.empty()) { | |
| 126 proxies_.push_back(ProxyServer::Direct()); | |
| 127 } | |
| 128 } | |
| 129 | |
| 130 std::string ProxyList::ToPacString() const { | |
| 131 std::string proxy_list; | |
| 132 std::vector<ProxyServer>::const_iterator iter = proxies_.begin(); | |
| 133 for (; iter != proxies_.end(); ++iter) { | |
| 134 if (!proxy_list.empty()) | |
| 135 proxy_list += ";"; | |
| 136 proxy_list += iter->ToPacString(); | |
| 137 } | |
| 138 return proxy_list.empty() ? std::string() : proxy_list; | |
| 139 } | |
| 140 | |
| 141 base::ListValue* ProxyList::ToValue() const { | |
| 142 base::ListValue* list = new base::ListValue(); | |
| 143 for (size_t i = 0; i < proxies_.size(); ++i) | |
| 144 list->AppendString(proxies_[i].ToURI()); | |
| 145 return list; | |
| 146 } | |
| 147 | |
| 148 bool ProxyList::Fallback(ProxyRetryInfoMap* proxy_retry_info, | |
| 149 int net_error, | |
| 150 const BoundNetLog& net_log) { | |
| 151 | |
| 152 // TODO(eroman): It would be good if instead of removing failed proxies | |
| 153 // from the list, we simply annotated them with the error code they failed | |
| 154 // with. Of course, ProxyService::ReconsiderProxyAfterError() would need to | |
| 155 // be given this information by the network transaction. | |
| 156 // | |
| 157 // The advantage of this approach is when the network transaction | |
| 158 // fails, we could output the full list of proxies that were attempted, and | |
| 159 // why each one of those failed (as opposed to just the last failure). | |
| 160 // | |
| 161 // And also, before failing the transaction wholesale, we could go back and | |
| 162 // retry the "bad proxies" which we never tried to begin with. | |
| 163 // (RemoveBadProxies would annotate them as 'expected bad' rather then delete | |
| 164 // them from the list, so we would know what they were). | |
| 165 | |
| 166 if (proxies_.empty()) { | |
| 167 NOTREACHED(); | |
| 168 return false; | |
| 169 } | |
| 170 // By default, proxies are not retried for 5 minutes. | |
| 171 UpdateRetryInfoOnFallback(proxy_retry_info, | |
| 172 TimeDelta::FromMinutes(5), | |
| 173 true, | |
| 174 ProxyServer(), | |
| 175 net_error, | |
| 176 net_log); | |
| 177 | |
| 178 // Remove this proxy from our list. | |
| 179 proxies_.erase(proxies_.begin()); | |
| 180 return !proxies_.empty(); | |
| 181 } | |
| 182 | |
| 183 void ProxyList::AddProxyToRetryList(ProxyRetryInfoMap* proxy_retry_info, | |
| 184 base::TimeDelta retry_delay, | |
| 185 bool try_while_bad, | |
| 186 const ProxyServer& proxy_to_retry, | |
| 187 int net_error, | |
| 188 const BoundNetLog& net_log) const { | |
| 189 // Mark this proxy as bad. | |
| 190 std::string proxy_key = proxy_to_retry.ToURI(); | |
| 191 ProxyRetryInfoMap::iterator iter = proxy_retry_info->find(proxy_key); | |
| 192 if (iter != proxy_retry_info->end()) { | |
| 193 // TODO(nsylvain): This is not the first time we get this. We should | |
| 194 // double the retry time. Bug 997660. | |
| 195 iter->second.bad_until = TimeTicks::Now() + iter->second.current_delay; | |
| 196 } else { | |
| 197 ProxyRetryInfo retry_info; | |
| 198 retry_info.current_delay = retry_delay; | |
| 199 retry_info.bad_until = TimeTicks().Now() + retry_info.current_delay; | |
| 200 retry_info.try_while_bad = try_while_bad; | |
| 201 retry_info.net_error = net_error; | |
| 202 (*proxy_retry_info)[proxy_key] = retry_info; | |
| 203 } | |
| 204 net_log.AddEvent(NetLog::TYPE_PROXY_LIST_FALLBACK, | |
| 205 NetLog::StringCallback("bad_proxy", &proxy_key)); | |
| 206 } | |
| 207 | |
| 208 void ProxyList::UpdateRetryInfoOnFallback( | |
| 209 ProxyRetryInfoMap* proxy_retry_info, | |
| 210 base::TimeDelta retry_delay, | |
| 211 bool reconsider, | |
| 212 const ProxyServer& another_proxy_to_bypass, | |
| 213 int net_error, | |
| 214 const BoundNetLog& net_log) const { | |
| 215 DCHECK(retry_delay != base::TimeDelta()); | |
| 216 | |
| 217 if (proxies_.empty()) { | |
| 218 NOTREACHED(); | |
| 219 return; | |
| 220 } | |
| 221 | |
| 222 if (!proxies_[0].is_direct()) { | |
| 223 AddProxyToRetryList(proxy_retry_info, | |
| 224 retry_delay, | |
| 225 reconsider, | |
| 226 proxies_[0], | |
| 227 net_error, | |
| 228 net_log); | |
| 229 | |
| 230 // If an additional proxy to bypass is specified, add it to the retry map | |
| 231 // as well. | |
| 232 if (another_proxy_to_bypass.is_valid()) { | |
| 233 AddProxyToRetryList(proxy_retry_info, | |
| 234 retry_delay, | |
| 235 reconsider, | |
| 236 another_proxy_to_bypass, | |
| 237 net_error, | |
| 238 net_log); | |
| 239 } | |
| 240 } | |
| 241 } | |
| 242 | |
| 243 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master