Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(172)

Side by Side Diff: net/proxy/proxy_resolver_v8_tracing_wrapper.cc

Issue 2351513002: net: rename BoundNetLog to NetLogWithSource (Closed)
Patch Set: one more fix, content bound_net_log_ Created 4 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698