OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 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 "chromeos/dbus/services/proxy_resolution_service_provider.h" | 5 #include "chromeos/dbus/services/proxy_resolution_service_provider.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
| 8 #include "base/bind_helpers.h" |
| 9 #include "base/logging.h" |
8 #include "base/macros.h" | 10 #include "base/macros.h" |
9 #include "base/memory/ptr_util.h" | 11 #include "base/memory/ptr_util.h" |
10 #include "base/run_loop.h" | 12 #include "base/run_loop.h" |
11 #include "base/single_thread_task_runner.h" | 13 #include "base/single_thread_task_runner.h" |
| 14 #include "base/test/thread_test_helper.h" |
| 15 #include "base/threading/thread.h" |
12 #include "base/threading/thread_task_runner_handle.h" | 16 #include "base/threading/thread_task_runner_handle.h" |
| 17 #include "base/time/time.h" |
13 #include "chromeos/dbus/services/service_provider_test_helper.h" | 18 #include "chromeos/dbus/services/service_provider_test_helper.h" |
14 #include "dbus/message.h" | 19 #include "dbus/message.h" |
15 #include "net/base/net_errors.h" | 20 #include "net/base/net_errors.h" |
16 #include "net/proxy/mock_proxy_resolver.h" | 21 #include "net/proxy/mock_proxy_resolver.h" |
17 #include "net/proxy/proxy_config_service_fixed.h" | 22 #include "net/proxy/proxy_config_service_fixed.h" |
18 #include "net/proxy/proxy_info.h" | 23 #include "net/proxy/proxy_info.h" |
19 #include "net/proxy/proxy_resolver.h" | 24 #include "net/proxy/proxy_resolver.h" |
20 #include "net/url_request/url_request_context.h" | 25 #include "net/url_request/url_request_context.h" |
21 #include "net/url_request/url_request_test_util.h" | 26 #include "net/url_request/url_request_test_util.h" |
22 #include "third_party/cros_system_api/dbus/service_constants.h" | 27 #include "third_party/cros_system_api/dbus/service_constants.h" |
23 | 28 |
24 namespace chromeos { | 29 namespace chromeos { |
25 | 30 |
26 namespace { | 31 namespace { |
27 | 32 |
28 // ProxyResolutionServiceProvider will return the proxy info as a D-Bus | 33 // ProxyResolutionServiceProvider will return the proxy info as a D-Bus |
29 // signal, to the following signal interface and the signal name. | 34 // signal, to the following signal interface and the signal name. |
30 const char kReturnSignalInterface[] = "org.chromium.TestInterface"; | 35 const char kReturnSignalInterface[] = "org.chromium.TestInterface"; |
31 const char kReturnSignalName[] = "TestSignal"; | 36 const char kReturnSignalName[] = "TestSignal"; |
32 | 37 |
| 38 // Maximum time to wait for D-Bus signals to be received, in seconds. |
| 39 int kSignalTimeoutSec = 60; |
| 40 |
| 41 // Runs pending, non-delayed tasks on |task_runner|. Note that delayed tasks or |
| 42 // additional tasks posted by pending tests will not be run. |
| 43 void RunPendingTasks(scoped_refptr<base::SingleThreadTaskRunner> task_runner) { |
| 44 scoped_refptr<base::ThreadTestHelper> helper = |
| 45 new base::ThreadTestHelper(task_runner); |
| 46 ASSERT_TRUE(helper->Run()); |
| 47 } |
| 48 |
33 // Trivial net::ProxyResolver implementation that returns canned data either | 49 // Trivial net::ProxyResolver implementation that returns canned data either |
34 // synchronously or asynchronously. | 50 // synchronously or asynchronously. |
35 class TestProxyResolver : public net::ProxyResolver { | 51 class TestProxyResolver : public net::ProxyResolver { |
36 public: | 52 public: |
37 explicit TestProxyResolver( | 53 explicit TestProxyResolver( |
38 scoped_refptr<base::SingleThreadTaskRunner> network_task_runner) | 54 scoped_refptr<base::SingleThreadTaskRunner> network_task_runner) |
39 : network_task_runner_(network_task_runner) { | 55 : network_task_runner_(network_task_runner) { |
40 proxy_info_.UseDirect(); | 56 proxy_info_.UseDirect(); |
41 } | 57 } |
42 ~TestProxyResolver() override = default; | 58 ~TestProxyResolver() override = default; |
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
103 | 119 |
104 // Test ProxyResolutionServiceProvider::Delegate implementation. | 120 // Test ProxyResolutionServiceProvider::Delegate implementation. |
105 class TestDelegate : public ProxyResolutionServiceProvider::Delegate { | 121 class TestDelegate : public ProxyResolutionServiceProvider::Delegate { |
106 public: | 122 public: |
107 explicit TestDelegate( | 123 explicit TestDelegate( |
108 const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner, | 124 const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner, |
109 net::ProxyResolver* proxy_resolver) | 125 net::ProxyResolver* proxy_resolver) |
110 : proxy_resolver_(proxy_resolver), | 126 : proxy_resolver_(proxy_resolver), |
111 context_getter_( | 127 context_getter_( |
112 new net::TestURLRequestContextGetter(network_task_runner)) { | 128 new net::TestURLRequestContextGetter(network_task_runner)) { |
| 129 network_task_runner->PostTask( |
| 130 FROM_HERE, base::Bind(&TestDelegate::CreateProxyServiceOnNetworkThread, |
| 131 base::Unretained(this))); |
| 132 RunPendingTasks(network_task_runner); |
| 133 } |
| 134 |
| 135 ~TestDelegate() override { |
| 136 context_getter_->GetNetworkTaskRunner()->PostTask( |
| 137 FROM_HERE, base::Bind(&TestDelegate::DeleteProxyServiceOnNetworkThread, |
| 138 base::Unretained(this))); |
| 139 RunPendingTasks(context_getter_->GetNetworkTaskRunner()); |
| 140 } |
| 141 |
| 142 // ProxyResolutionServiceProvider::Delegate: |
| 143 scoped_refptr<net::URLRequestContextGetter> GetRequestContext() override { |
| 144 return context_getter_; |
| 145 } |
| 146 |
| 147 private: |
| 148 // Helper method for the constructor that initializes |proxy_service_| and |
| 149 // injects it into |context_getter_|'s context. |
| 150 void CreateProxyServiceOnNetworkThread() { |
| 151 CHECK(context_getter_->GetNetworkTaskRunner()->BelongsToCurrentThread()); |
| 152 |
113 // The config's autodetect property needs to be set in order for | 153 // The config's autodetect property needs to be set in order for |
114 // net::ProxyService to send requests to our resolver. | 154 // net::ProxyService to send requests to our resolver. |
115 net::ProxyConfig config = net::ProxyConfig::CreateAutoDetect(); | 155 net::ProxyConfig config = net::ProxyConfig::CreateAutoDetect(); |
116 proxy_service_ = base::MakeUnique<net::ProxyService>( | 156 proxy_service_ = base::MakeUnique<net::ProxyService>( |
117 base::MakeUnique<net::ProxyConfigServiceFixed>(config), | 157 base::MakeUnique<net::ProxyConfigServiceFixed>(config), |
118 base::MakeUnique<TestProxyResolverFactory>(proxy_resolver_), | 158 base::MakeUnique<TestProxyResolverFactory>(proxy_resolver_), |
119 nullptr /* net_log */); | 159 nullptr /* net_log */); |
120 context_getter_->GetURLRequestContext()->set_proxy_service( | 160 context_getter_->GetURLRequestContext()->set_proxy_service( |
121 proxy_service_.get()); | 161 proxy_service_.get()); |
122 } | 162 } |
123 ~TestDelegate() override = default; | |
124 | 163 |
125 // ProxyResolutionServiceProvider::Delegate: | 164 // Helper method for the destructor that resets |proxy_service_|. |
126 scoped_refptr<net::URLRequestContextGetter> GetRequestContext() override { | 165 void DeleteProxyServiceOnNetworkThread() { |
127 return context_getter_; | 166 CHECK(context_getter_->GetNetworkTaskRunner()->BelongsToCurrentThread()); |
| 167 proxy_service_.reset(); |
128 } | 168 } |
129 | 169 |
130 private: | |
131 net::ProxyResolver* proxy_resolver_; // Not owned. | 170 net::ProxyResolver* proxy_resolver_; // Not owned. |
| 171 |
| 172 // Created, used, and destroyed on the network thread (since net::ProxyService |
| 173 // derives from base::NonThreadSafe). |
132 std::unique_ptr<net::ProxyService> proxy_service_; | 174 std::unique_ptr<net::ProxyService> proxy_service_; |
| 175 |
133 scoped_refptr<net::TestURLRequestContextGetter> context_getter_; | 176 scoped_refptr<net::TestURLRequestContextGetter> context_getter_; |
134 | 177 |
135 DISALLOW_COPY_AND_ASSIGN(TestDelegate); | 178 DISALLOW_COPY_AND_ASSIGN(TestDelegate); |
136 }; | 179 }; |
137 | 180 |
138 } // namespace | 181 } // namespace |
139 | 182 |
140 class ProxyResolutionServiceProviderTest : public testing::Test { | 183 class ProxyResolutionServiceProviderTest : public testing::Test { |
141 public: | 184 public: |
142 ProxyResolutionServiceProviderTest() = default; | 185 ProxyResolutionServiceProviderTest() : network_thread_("NetworkThread") { |
143 ~ProxyResolutionServiceProviderTest() override = default; | 186 CHECK(network_thread_.Start()); |
144 | 187 |
145 // testing::Test: | 188 proxy_resolver_ = |
146 void SetUp() override { | 189 base::MakeUnique<TestProxyResolver>(network_thread_.task_runner()); |
147 proxy_resolver_ = base::MakeUnique<TestProxyResolver>( | |
148 base::ThreadTaskRunnerHandle::Get()); | |
149 service_provider_ = base::MakeUnique<ProxyResolutionServiceProvider>( | 190 service_provider_ = base::MakeUnique<ProxyResolutionServiceProvider>( |
150 base::MakeUnique<TestDelegate>(base::ThreadTaskRunnerHandle::Get(), | 191 base::MakeUnique<TestDelegate>(network_thread_.task_runner(), |
151 proxy_resolver_.get())); | 192 proxy_resolver_.get())); |
152 test_helper_.SetUp(kResolveNetworkProxy, service_provider_.get()); | 193 test_helper_.SetUp(kResolveNetworkProxy, service_provider_.get()); |
153 } | 194 } |
154 void TearDown() override { | 195 |
| 196 ~ProxyResolutionServiceProviderTest() override { |
155 test_helper_.TearDown(); | 197 test_helper_.TearDown(); |
| 198 |
| 199 // URLRequestContextGetter posts a task to delete itself to its task runner, |
| 200 // so give it a chance to do that. |
| 201 service_provider_.reset(); |
| 202 RunPendingTasks(network_thread_.task_runner()); |
| 203 |
| 204 network_thread_.Stop(); |
156 } | 205 } |
157 | 206 |
158 protected: | 207 protected: |
159 // Arguments extracted from a D-Bus signal. | 208 // Arguments extracted from a D-Bus signal. |
160 struct SignalInfo { | 209 struct SignalInfo { |
161 std::string source_url; | 210 std::string source_url; |
162 std::string proxy_info; | 211 std::string proxy_info; |
163 std::string error_message; | 212 std::string error_message; |
164 }; | 213 }; |
165 | 214 |
166 // Called when a signal is received. | 215 // Called when a signal is received. |
167 void OnSignalReceived(dbus::Signal* signal) { | 216 void OnSignalReceived(dbus::Signal* signal) { |
168 EXPECT_EQ(kReturnSignalInterface, signal->GetInterface()); | 217 EXPECT_EQ(kReturnSignalInterface, signal->GetInterface()); |
169 EXPECT_EQ(kReturnSignalName, signal->GetMember()); | 218 EXPECT_EQ(kReturnSignalName, signal->GetMember()); |
170 | 219 |
171 ASSERT_FALSE(signal_); | 220 ASSERT_FALSE(signal_); |
172 signal_ = base::MakeUnique<SignalInfo>(); | 221 signal_ = base::MakeUnique<SignalInfo>(); |
173 | 222 |
174 // The signal should contain three strings. | 223 // The signal should contain three strings. |
175 dbus::MessageReader reader(signal); | 224 dbus::MessageReader reader(signal); |
176 EXPECT_TRUE(reader.PopString(&signal_->source_url)); | 225 EXPECT_TRUE(reader.PopString(&signal_->source_url)); |
177 EXPECT_TRUE(reader.PopString(&signal_->proxy_info)); | 226 EXPECT_TRUE(reader.PopString(&signal_->proxy_info)); |
178 EXPECT_TRUE(reader.PopString(&signal_->error_message)); | 227 EXPECT_TRUE(reader.PopString(&signal_->error_message)); |
| 228 |
| 229 // Stop the message loop. |
| 230 ASSERT_FALSE(quit_closure_.is_null()) << "Unexpected D-Bus signal"; |
| 231 quit_closure_.Run(); |
| 232 quit_closure_.Reset(); |
179 } | 233 } |
180 | 234 |
181 // Called when connected to a signal. | 235 // Called when connected to a signal. |
182 void OnConnectedToSignal(const std::string& signal_interface, | 236 void OnConnectedToSignal(const std::string& signal_interface, |
183 const std::string& signal_name, | 237 const std::string& signal_name, |
184 bool success){ | 238 bool success){ |
185 EXPECT_EQ(kReturnSignalInterface, signal_interface); | 239 EXPECT_EQ(kReturnSignalInterface, signal_interface); |
186 EXPECT_EQ(kReturnSignalName, signal_name); | 240 EXPECT_EQ(kReturnSignalName, signal_name); |
187 EXPECT_TRUE(success); | 241 EXPECT_TRUE(success); |
188 } | 242 } |
(...skipping 20 matching lines...) Expand all Loading... |
209 // signal. OnSignalReceived() will be called upon the delivery. | 263 // signal. OnSignalReceived() will be called upon the delivery. |
210 test_helper_.SetUpReturnSignal( | 264 test_helper_.SetUpReturnSignal( |
211 kReturnSignalInterface, kReturnSignalName, | 265 kReturnSignalInterface, kReturnSignalName, |
212 base::Bind(&ProxyResolutionServiceProviderTest::OnSignalReceived, | 266 base::Bind(&ProxyResolutionServiceProviderTest::OnSignalReceived, |
213 base::Unretained(this)), | 267 base::Unretained(this)), |
214 base::Bind(&ProxyResolutionServiceProviderTest::OnConnectedToSignal, | 268 base::Bind(&ProxyResolutionServiceProviderTest::OnConnectedToSignal, |
215 base::Unretained(this))); | 269 base::Unretained(this))); |
216 } | 270 } |
217 | 271 |
218 *response_out = test_helper_.CallMethod(&method_call); | 272 *response_out = test_helper_.CallMethod(&method_call); |
219 base::RunLoop().RunUntilIdle(); | 273 |
| 274 // If a signal is being emitted, run the main message loop until it's |
| 275 // received or we get tired of waiting. |
| 276 if (request_signal) { |
| 277 base::RunLoop run_loop; |
| 278 quit_closure_ = run_loop.QuitClosure(); |
| 279 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( |
| 280 FROM_HERE, quit_closure_, |
| 281 base::TimeDelta::FromSeconds(kSignalTimeoutSec)); |
| 282 run_loop.Run(); |
| 283 } |
| 284 |
220 *signal_out = std::move(signal_); | 285 *signal_out = std::move(signal_); |
221 } | 286 } |
222 | 287 |
| 288 // Thread used to perform network operations. |
| 289 base::Thread network_thread_; |
| 290 |
223 // Information about the last D-Bus signal received by OnSignalReceived(). | 291 // Information about the last D-Bus signal received by OnSignalReceived(). |
224 std::unique_ptr<SignalInfo> signal_; | 292 std::unique_ptr<SignalInfo> signal_; |
225 | 293 |
| 294 // Closure used to stop the message loop after receiving a D-Bus signal. |
| 295 base::Closure quit_closure_; |
| 296 |
226 std::unique_ptr<TestProxyResolver> proxy_resolver_; | 297 std::unique_ptr<TestProxyResolver> proxy_resolver_; |
227 std::unique_ptr<ProxyResolutionServiceProvider> service_provider_; | 298 std::unique_ptr<ProxyResolutionServiceProvider> service_provider_; |
228 ServiceProviderTestHelper test_helper_; | 299 ServiceProviderTestHelper test_helper_; |
| 300 |
| 301 DISALLOW_COPY_AND_ASSIGN(ProxyResolutionServiceProviderTest); |
229 }; | 302 }; |
230 | 303 |
231 // Tests that synchronously-resolved proxy information is returned via a signal. | 304 // Tests that synchronously-resolved proxy information is returned via a signal. |
232 TEST_F(ProxyResolutionServiceProviderTest, SignalSync) { | 305 TEST_F(ProxyResolutionServiceProviderTest, SignalSync) { |
233 const char kSourceURL[] = "http://www.gmail.com/"; | 306 const char kSourceURL[] = "http://www.gmail.com/"; |
234 | 307 |
235 std::unique_ptr<dbus::Response> response; | 308 std::unique_ptr<dbus::Response> response; |
236 std::unique_ptr<SignalInfo> signal; | 309 std::unique_ptr<SignalInfo> signal; |
237 CallMethod(kSourceURL, true /* request_signal */, &response, &signal); | 310 CallMethod(kSourceURL, true /* request_signal */, &response, &signal); |
238 | 311 |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
303 EXPECT_TRUE(reader.PopString(&proxy_info)); | 376 EXPECT_TRUE(reader.PopString(&proxy_info)); |
304 EXPECT_TRUE(reader.PopString(&error)); | 377 EXPECT_TRUE(reader.PopString(&error)); |
305 EXPECT_EQ(proxy_resolver_->proxy_info().ToPacString(), proxy_info); | 378 EXPECT_EQ(proxy_resolver_->proxy_info().ToPacString(), proxy_info); |
306 EXPECT_EQ("", error); | 379 EXPECT_EQ("", error); |
307 | 380 |
308 // No signal should've been emitted. | 381 // No signal should've been emitted. |
309 EXPECT_FALSE(signal); | 382 EXPECT_FALSE(signal); |
310 } | 383 } |
311 | 384 |
312 } // namespace chromeos | 385 } // namespace chromeos |
OLD | NEW |