OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/proxy/proxy_resolver_v8_tracing_wrapper.h" | 5 #include "net/proxy/proxy_resolver_v8_tracing_wrapper.h" |
6 | 6 |
7 #include <string> | 7 #include <string> |
8 #include <utility> | 8 #include <utility> |
9 | 9 |
10 #include "base/bind.h" | 10 #include "base/bind.h" |
(...skipping 17 matching lines...) Expand all Loading... |
28 dict->SetInteger("line_number", line_number); | 28 dict->SetInteger("line_number", line_number); |
29 dict->SetString("message", *message); | 29 dict->SetString("message", *message); |
30 return std::move(dict); | 30 return std::move(dict); |
31 } | 31 } |
32 | 32 |
33 class BindingsImpl : public ProxyResolverV8Tracing::Bindings { | 33 class BindingsImpl : public ProxyResolverV8Tracing::Bindings { |
34 public: | 34 public: |
35 BindingsImpl(ProxyResolverErrorObserver* error_observer, | 35 BindingsImpl(ProxyResolverErrorObserver* error_observer, |
36 HostResolver* host_resolver, | 36 HostResolver* host_resolver, |
37 NetLog* net_log, | 37 NetLog* net_log, |
38 const BoundNetLog& bound_net_log) | 38 const NetLogWithSource& net_log_with_source) |
39 : error_observer_(error_observer), | 39 : error_observer_(error_observer), |
40 host_resolver_(host_resolver), | 40 host_resolver_(host_resolver), |
41 net_log_(net_log), | 41 net_log_(net_log), |
42 bound_net_log_(bound_net_log) {} | 42 net_log_with_source_(net_log_with_source) {} |
43 | 43 |
44 // ProxyResolverV8Tracing::Bindings overrides. | 44 // ProxyResolverV8Tracing::Bindings overrides. |
45 void Alert(const base::string16& message) override { | 45 void Alert(const base::string16& message) override { |
46 // Send to the NetLog. | 46 // Send to the NetLog. |
47 LogEventToCurrentRequestAndGlobally( | 47 LogEventToCurrentRequestAndGlobally( |
48 NetLogEventType::PAC_JAVASCRIPT_ALERT, | 48 NetLogEventType::PAC_JAVASCRIPT_ALERT, |
49 NetLog::StringCallback("message", &message)); | 49 NetLog::StringCallback("message", &message)); |
50 } | 50 } |
51 | 51 |
52 void OnError(int line_number, const base::string16& message) override { | 52 void OnError(int line_number, const base::string16& message) override { |
53 // Send the error to the NetLog. | 53 // Send the error to the NetLog. |
54 LogEventToCurrentRequestAndGlobally( | 54 LogEventToCurrentRequestAndGlobally( |
55 NetLogEventType::PAC_JAVASCRIPT_ERROR, | 55 NetLogEventType::PAC_JAVASCRIPT_ERROR, |
56 base::Bind(&NetLogErrorCallback, line_number, &message)); | 56 base::Bind(&NetLogErrorCallback, line_number, &message)); |
57 if (error_observer_) | 57 if (error_observer_) |
58 error_observer_->OnPACScriptError(line_number, message); | 58 error_observer_->OnPACScriptError(line_number, message); |
59 } | 59 } |
60 | 60 |
61 HostResolver* GetHostResolver() override { return host_resolver_; } | 61 HostResolver* GetHostResolver() override { return host_resolver_; } |
62 | 62 |
63 BoundNetLog GetBoundNetLog() override { return bound_net_log_; } | 63 NetLogWithSource GetNetLogWithSource() override { |
| 64 return net_log_with_source_; |
| 65 } |
64 | 66 |
65 private: | 67 private: |
66 void LogEventToCurrentRequestAndGlobally( | 68 void LogEventToCurrentRequestAndGlobally( |
67 NetLogEventType type, | 69 NetLogEventType type, |
68 const NetLog::ParametersCallback& parameters_callback) { | 70 const NetLog::ParametersCallback& parameters_callback) { |
69 bound_net_log_.AddEvent(type, parameters_callback); | 71 net_log_with_source_.AddEvent(type, parameters_callback); |
70 | 72 |
71 // Emit to the global NetLog event stream. | 73 // Emit to the global NetLog event stream. |
72 if (net_log_) | 74 if (net_log_) |
73 net_log_->AddGlobalEntry(type, parameters_callback); | 75 net_log_->AddGlobalEntry(type, parameters_callback); |
74 } | 76 } |
75 | 77 |
76 ProxyResolverErrorObserver* error_observer_; | 78 ProxyResolverErrorObserver* error_observer_; |
77 HostResolver* host_resolver_; | 79 HostResolver* host_resolver_; |
78 NetLog* net_log_; | 80 NetLog* net_log_; |
79 BoundNetLog bound_net_log_; | 81 NetLogWithSource net_log_with_source_; |
80 }; | 82 }; |
81 | 83 |
82 class ProxyResolverV8TracingWrapper : public ProxyResolver { | 84 class ProxyResolverV8TracingWrapper : public ProxyResolver { |
83 public: | 85 public: |
84 ProxyResolverV8TracingWrapper( | 86 ProxyResolverV8TracingWrapper( |
85 std::unique_ptr<ProxyResolverV8Tracing> resolver_impl, | 87 std::unique_ptr<ProxyResolverV8Tracing> resolver_impl, |
86 NetLog* net_log, | 88 NetLog* net_log, |
87 HostResolver* host_resolver, | 89 HostResolver* host_resolver, |
88 std::unique_ptr<ProxyResolverErrorObserver> error_observer); | 90 std::unique_ptr<ProxyResolverErrorObserver> error_observer); |
89 | 91 |
90 int GetProxyForURL(const GURL& url, | 92 int GetProxyForURL(const GURL& url, |
91 ProxyInfo* results, | 93 ProxyInfo* results, |
92 const CompletionCallback& callback, | 94 const CompletionCallback& callback, |
93 RequestHandle* request, | 95 RequestHandle* request, |
94 const BoundNetLog& net_log) override; | 96 const NetLogWithSource& net_log) override; |
95 | 97 |
96 void CancelRequest(RequestHandle request) override; | 98 void CancelRequest(RequestHandle request) override; |
97 | 99 |
98 LoadState GetLoadState(RequestHandle request) const override; | 100 LoadState GetLoadState(RequestHandle request) const override; |
99 | 101 |
100 private: | 102 private: |
101 std::unique_ptr<ProxyResolverV8Tracing> resolver_impl_; | 103 std::unique_ptr<ProxyResolverV8Tracing> resolver_impl_; |
102 NetLog* net_log_; | 104 NetLog* net_log_; |
103 HostResolver* host_resolver_; | 105 HostResolver* host_resolver_; |
104 std::unique_ptr<ProxyResolverErrorObserver> error_observer_; | 106 std::unique_ptr<ProxyResolverErrorObserver> error_observer_; |
105 | 107 |
106 DISALLOW_COPY_AND_ASSIGN(ProxyResolverV8TracingWrapper); | 108 DISALLOW_COPY_AND_ASSIGN(ProxyResolverV8TracingWrapper); |
107 }; | 109 }; |
108 | 110 |
109 ProxyResolverV8TracingWrapper::ProxyResolverV8TracingWrapper( | 111 ProxyResolverV8TracingWrapper::ProxyResolverV8TracingWrapper( |
110 std::unique_ptr<ProxyResolverV8Tracing> resolver_impl, | 112 std::unique_ptr<ProxyResolverV8Tracing> resolver_impl, |
111 NetLog* net_log, | 113 NetLog* net_log, |
112 HostResolver* host_resolver, | 114 HostResolver* host_resolver, |
113 std::unique_ptr<ProxyResolverErrorObserver> error_observer) | 115 std::unique_ptr<ProxyResolverErrorObserver> error_observer) |
114 : resolver_impl_(std::move(resolver_impl)), | 116 : resolver_impl_(std::move(resolver_impl)), |
115 net_log_(net_log), | 117 net_log_(net_log), |
116 host_resolver_(host_resolver), | 118 host_resolver_(host_resolver), |
117 error_observer_(std::move(error_observer)) {} | 119 error_observer_(std::move(error_observer)) {} |
118 | 120 |
119 int ProxyResolverV8TracingWrapper::GetProxyForURL( | 121 int ProxyResolverV8TracingWrapper::GetProxyForURL( |
120 const GURL& url, | 122 const GURL& url, |
121 ProxyInfo* results, | 123 ProxyInfo* results, |
122 const CompletionCallback& callback, | 124 const CompletionCallback& callback, |
123 RequestHandle* request, | 125 RequestHandle* request, |
124 const BoundNetLog& net_log) { | 126 const NetLogWithSource& net_log) { |
125 resolver_impl_->GetProxyForURL( | 127 resolver_impl_->GetProxyForURL( |
126 url, results, callback, request, | 128 url, results, callback, request, |
127 base::WrapUnique(new BindingsImpl(error_observer_.get(), host_resolver_, | 129 base::WrapUnique(new BindingsImpl(error_observer_.get(), host_resolver_, |
128 net_log_, net_log))); | 130 net_log_, net_log))); |
129 return ERR_IO_PENDING; | 131 return ERR_IO_PENDING; |
130 } | 132 } |
131 | 133 |
132 void ProxyResolverV8TracingWrapper::CancelRequest(RequestHandle request) { | 134 void ProxyResolverV8TracingWrapper::CancelRequest(RequestHandle request) { |
133 resolver_impl_->CancelRequest(request); | 135 resolver_impl_->CancelRequest(request); |
134 } | 136 } |
(...skipping 29 matching lines...) Expand all Loading... |
164 std::unique_ptr<ProxyResolverErrorObserver> error_observer = | 166 std::unique_ptr<ProxyResolverErrorObserver> error_observer = |
165 error_observer_factory_.Run(); | 167 error_observer_factory_.Run(); |
166 // Note: Argument evaluation order is unspecified, so make copies before | 168 // Note: Argument evaluation order is unspecified, so make copies before |
167 // passing |v8_resolver| and |error_observer|. | 169 // passing |v8_resolver| and |error_observer|. |
168 std::unique_ptr<ProxyResolverV8Tracing>* v8_resolver_local = | 170 std::unique_ptr<ProxyResolverV8Tracing>* v8_resolver_local = |
169 v8_resolver.get(); | 171 v8_resolver.get(); |
170 ProxyResolverErrorObserver* error_observer_local = error_observer.get(); | 172 ProxyResolverErrorObserver* error_observer_local = error_observer.get(); |
171 factory_impl_->CreateProxyResolverV8Tracing( | 173 factory_impl_->CreateProxyResolverV8Tracing( |
172 pac_script, | 174 pac_script, |
173 base::WrapUnique(new BindingsImpl(error_observer_local, host_resolver_, | 175 base::WrapUnique(new BindingsImpl(error_observer_local, host_resolver_, |
174 net_log_, BoundNetLog())), | 176 net_log_, NetLogWithSource())), |
175 v8_resolver_local, | 177 v8_resolver_local, |
176 base::Bind(&ProxyResolverFactoryV8TracingWrapper::OnProxyResolverCreated, | 178 base::Bind(&ProxyResolverFactoryV8TracingWrapper::OnProxyResolverCreated, |
177 base::Unretained(this), base::Passed(&v8_resolver), resolver, | 179 base::Unretained(this), base::Passed(&v8_resolver), resolver, |
178 callback, base::Passed(&error_observer)), | 180 callback, base::Passed(&error_observer)), |
179 request); | 181 request); |
180 return ERR_IO_PENDING; | 182 return ERR_IO_PENDING; |
181 } | 183 } |
182 | 184 |
183 void ProxyResolverFactoryV8TracingWrapper::OnProxyResolverCreated( | 185 void ProxyResolverFactoryV8TracingWrapper::OnProxyResolverCreated( |
184 std::unique_ptr<std::unique_ptr<ProxyResolverV8Tracing>> v8_resolver, | 186 std::unique_ptr<std::unique_ptr<ProxyResolverV8Tracing>> v8_resolver, |
185 std::unique_ptr<ProxyResolver>* resolver, | 187 std::unique_ptr<ProxyResolver>* resolver, |
186 const CompletionCallback& callback, | 188 const CompletionCallback& callback, |
187 std::unique_ptr<ProxyResolverErrorObserver> error_observer, | 189 std::unique_ptr<ProxyResolverErrorObserver> error_observer, |
188 int error) { | 190 int error) { |
189 if (error == OK) { | 191 if (error == OK) { |
190 resolver->reset(new ProxyResolverV8TracingWrapper( | 192 resolver->reset(new ProxyResolverV8TracingWrapper( |
191 std::move(*v8_resolver), net_log_, host_resolver_, | 193 std::move(*v8_resolver), net_log_, host_resolver_, |
192 std::move(error_observer))); | 194 std::move(error_observer))); |
193 } | 195 } |
194 callback.Run(error); | 196 callback.Run(error); |
195 } | 197 } |
196 | 198 |
197 } // namespace net | 199 } // namespace net |
OLD | NEW |