OLD | NEW |
(Empty) | |
| 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 |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "net/dns/host_resolver_mojo.h" |
| 6 |
| 7 #include <string> |
| 8 |
| 9 #include "base/barrier_closure.h" |
| 10 #include "base/memory/scoped_vector.h" |
| 11 #include "base/run_loop.h" |
| 12 #include "net/base/net_errors.h" |
| 13 #include "net/base/request_priority.h" |
| 14 #include "net/dns/type_converters.h" |
| 15 #include "testing/gtest/include/gtest/gtest.h" |
| 16 #include "third_party/mojo/src/mojo/public/cpp/bindings/binding.h" |
| 17 #include "third_party/mojo/src/mojo/public/cpp/bindings/error_handler.h" |
| 18 |
| 19 namespace net { |
| 20 namespace { |
| 21 |
| 22 enum class ConnectionErrorSource { |
| 23 NONE, |
| 24 RESOLVER, |
| 25 REQUEST, |
| 26 CLIENT, |
| 27 }; |
| 28 |
| 29 void OnResolveComplete(int* error_out, |
| 30 const base::Closure& quit_run_loop, |
| 31 int error) { |
| 32 if (!quit_run_loop.is_null()) |
| 33 quit_run_loop.Run(); |
| 34 *error_out = error; |
| 35 } |
| 36 |
| 37 void Fail(int result) { |
| 38 FAIL() << "Unexpected callback called with error " << result; |
| 39 } |
| 40 |
| 41 class MockMojoHostResolverRequest : public mojo::ErrorHandler { |
| 42 public: |
| 43 MockMojoHostResolverRequest(interfaces::HostResolverRequestClientPtr client, |
| 44 const base::Closure& error_callback); |
| 45 void OnConnectionError() override; |
| 46 |
| 47 private: |
| 48 interfaces::HostResolverRequestClientPtr client_; |
| 49 const base::Closure error_callback_; |
| 50 }; |
| 51 |
| 52 MockMojoHostResolverRequest::MockMojoHostResolverRequest( |
| 53 interfaces::HostResolverRequestClientPtr client, |
| 54 const base::Closure& error_callback) |
| 55 : client_(client.Pass()), error_callback_(error_callback) { |
| 56 client_.set_error_handler(this); |
| 57 } |
| 58 |
| 59 void MockMojoHostResolverRequest::OnConnectionError() { |
| 60 error_callback_.Run(); |
| 61 } |
| 62 |
| 63 struct HostResolverAction { |
| 64 public: |
| 65 enum Action { |
| 66 COMPLETE, |
| 67 DROP, |
| 68 RETAIN, |
| 69 }; |
| 70 |
| 71 static scoped_ptr<HostResolverAction> ReturnError(int error) { |
| 72 scoped_ptr<HostResolverAction> result(new HostResolverAction); |
| 73 result->error = error; |
| 74 return result.Pass(); |
| 75 } |
| 76 |
| 77 static scoped_ptr<HostResolverAction> ReturnResult( |
| 78 const AddressList& address_list) { |
| 79 scoped_ptr<HostResolverAction> result(new HostResolverAction); |
| 80 result->addresses = interfaces::AddressList::From(address_list); |
| 81 return result.Pass(); |
| 82 } |
| 83 |
| 84 static scoped_ptr<HostResolverAction> DropRequest() { |
| 85 scoped_ptr<HostResolverAction> result(new HostResolverAction); |
| 86 result->action = DROP; |
| 87 return result.Pass(); |
| 88 } |
| 89 |
| 90 static scoped_ptr<HostResolverAction> RetainRequest() { |
| 91 scoped_ptr<HostResolverAction> result(new HostResolverAction); |
| 92 result->action = RETAIN; |
| 93 return result.Pass(); |
| 94 } |
| 95 |
| 96 Action action = COMPLETE; |
| 97 interfaces::AddressListPtr addresses; |
| 98 int error = OK; |
| 99 }; |
| 100 |
| 101 class MockMojoHostResolver : public interfaces::HostResolver, |
| 102 public mojo::ErrorHandler { |
| 103 public: |
| 104 explicit MockMojoHostResolver( |
| 105 mojo::InterfaceRequest<interfaces::HostResolver> request, |
| 106 const base::Closure& resolver_connection_error_callback, |
| 107 const base::Closure& request_connection_error_callback); |
| 108 |
| 109 void AddAction(scoped_ptr<HostResolverAction> action); |
| 110 |
| 111 const mojo::Array<interfaces::HostResolverRequestInfoPtr>& requests() { |
| 112 return requests_received_; |
| 113 } |
| 114 |
| 115 private: |
| 116 // interfaces::HostResolver override. |
| 117 void Resolve(interfaces::HostResolverRequestInfoPtr request_info, |
| 118 interfaces::HostResolverRequestClientPtr client) override; |
| 119 |
| 120 // mojo::ErrorHandler override. |
| 121 void OnConnectionError() override; |
| 122 |
| 123 mojo::Binding<interfaces::HostResolver> binding_; |
| 124 ScopedVector<HostResolverAction> actions_; |
| 125 size_t results_returned_ = 0; |
| 126 mojo::Array<interfaces::HostResolverRequestInfoPtr> requests_received_; |
| 127 const base::Closure resolver_connection_error_callback_; |
| 128 const base::Closure request_connection_error_callback_; |
| 129 ScopedVector<MockMojoHostResolverRequest> requests_; |
| 130 }; |
| 131 |
| 132 MockMojoHostResolver::MockMojoHostResolver( |
| 133 mojo::InterfaceRequest<interfaces::HostResolver> request, |
| 134 const base::Closure& resolver_connection_error_callback, |
| 135 const base::Closure& request_connection_error_callback) |
| 136 : binding_(this, request.Pass()), |
| 137 resolver_connection_error_callback_(resolver_connection_error_callback), |
| 138 request_connection_error_callback_(request_connection_error_callback) { |
| 139 binding_.set_error_handler(this); |
| 140 } |
| 141 |
| 142 void MockMojoHostResolver::OnConnectionError() { |
| 143 resolver_connection_error_callback_.Run(); |
| 144 } |
| 145 |
| 146 void MockMojoHostResolver::AddAction(scoped_ptr<HostResolverAction> action) { |
| 147 actions_.push_back(action.release()); |
| 148 } |
| 149 |
| 150 void MockMojoHostResolver::Resolve( |
| 151 interfaces::HostResolverRequestInfoPtr request_info, |
| 152 interfaces::HostResolverRequestClientPtr client) { |
| 153 requests_received_.push_back(request_info.Pass()); |
| 154 ASSERT_LE(results_returned_, actions_.size()); |
| 155 switch (actions_[results_returned_]->action) { |
| 156 case HostResolverAction::COMPLETE: |
| 157 client->ReportResult(actions_[results_returned_]->error, |
| 158 actions_[results_returned_]->addresses.Pass()); |
| 159 break; |
| 160 case HostResolverAction::RETAIN: |
| 161 requests_.push_back(new MockMojoHostResolverRequest( |
| 162 client.Pass(), request_connection_error_callback_)); |
| 163 break; |
| 164 case HostResolverAction::DROP: |
| 165 client.reset(); |
| 166 break; |
| 167 } |
| 168 results_returned_++; |
| 169 } |
| 170 |
| 171 } // namespace |
| 172 |
| 173 class HostResolverMojoTest : public testing::Test, public mojo::ErrorHandler { |
| 174 protected: |
| 175 void SetUp() override { |
| 176 interfaces::HostResolverPtr resolver_ptr; |
| 177 mock_resolver_.reset(new MockMojoHostResolver( |
| 178 mojo::GetProxy(&resolver_ptr), |
| 179 base::Bind(&HostResolverMojoTest::HandleConnectionError, |
| 180 base::Unretained(this), ConnectionErrorSource::RESOLVER), |
| 181 base::Bind(&HostResolverMojoTest::HandleConnectionError, |
| 182 base::Unretained(this), ConnectionErrorSource::REQUEST))); |
| 183 resolver_.reset(new HostResolverMojo(resolver_ptr.Pass(), this)); |
| 184 } |
| 185 |
| 186 void OnConnectionError() override { |
| 187 HandleConnectionError(ConnectionErrorSource::CLIENT); |
| 188 } |
| 189 |
| 190 void HandleConnectionError(ConnectionErrorSource source) { |
| 191 if (!run_loop_quit_closure_.is_null()) |
| 192 run_loop_quit_closure_.Run(); |
| 193 ASSERT_EQ(expected_connection_error_source_, source); |
| 194 } |
| 195 |
| 196 int Resolve(const HostResolver::RequestInfo& request_info, |
| 197 AddressList* result) { |
| 198 HostResolver::RequestHandle request_handle = nullptr; |
| 199 base::RunLoop run_loop; |
| 200 int error = 1; |
| 201 resolver_->Resolve( |
| 202 request_info, DEFAULT_PRIORITY, result, |
| 203 base::Bind(&OnResolveComplete, &error, run_loop.QuitClosure()), |
| 204 &request_handle, BoundNetLog()); |
| 205 run_loop.Run(); |
| 206 return error; |
| 207 } |
| 208 |
| 209 void WaitForConnectionError(ConnectionErrorSource source) { |
| 210 expected_connection_error_source_ = source; |
| 211 base::RunLoop run_loop; |
| 212 run_loop_quit_closure_ = run_loop.QuitClosure(); |
| 213 run_loop.Run(); |
| 214 } |
| 215 |
| 216 scoped_ptr<MockMojoHostResolver> mock_resolver_; |
| 217 |
| 218 scoped_ptr<HostResolverMojo> resolver_; |
| 219 |
| 220 ConnectionErrorSource expected_connection_error_source_ = |
| 221 ConnectionErrorSource::NONE; |
| 222 base::Closure run_loop_quit_closure_; |
| 223 }; |
| 224 |
| 225 TEST_F(HostResolverMojoTest, Basic) { |
| 226 AddressList address_list; |
| 227 IPAddressNumber address_number; |
| 228 ASSERT_TRUE(ParseIPLiteralToNumber("1.2.3.4", &address_number)); |
| 229 address_list.push_back(IPEndPoint(address_number, 12345)); |
| 230 address_list.push_back( |
| 231 IPEndPoint(ConvertIPv4NumberToIPv6Number(address_number), 12345)); |
| 232 mock_resolver_->AddAction(HostResolverAction::ReturnResult(address_list)); |
| 233 HostResolver::RequestInfo request_info( |
| 234 HostPortPair::FromString("example.com:12345")); |
| 235 AddressList result; |
| 236 EXPECT_EQ(OK, Resolve(request_info, &result)); |
| 237 ASSERT_EQ(2u, result.size()); |
| 238 EXPECT_EQ(address_list[0], result[0]); |
| 239 EXPECT_EQ(address_list[1], result[1]); |
| 240 |
| 241 ASSERT_EQ(1u, mock_resolver_->requests().size()); |
| 242 interfaces::HostResolverRequestInfo& request = *mock_resolver_->requests()[0]; |
| 243 EXPECT_EQ("example.com", request.host.To<std::string>()); |
| 244 EXPECT_EQ(12345, request.port); |
| 245 EXPECT_EQ(interfaces::ADDRESS_FAMILY_UNSPECIFIED, request.address_family); |
| 246 EXPECT_FALSE(request.is_my_ip_address); |
| 247 } |
| 248 |
| 249 TEST_F(HostResolverMojoTest, Multiple) { |
| 250 AddressList address_list; |
| 251 IPAddressNumber address_number; |
| 252 ASSERT_TRUE(ParseIPLiteralToNumber("1.2.3.4", &address_number)); |
| 253 address_list.push_back(IPEndPoint(address_number, 12345)); |
| 254 mock_resolver_->AddAction(HostResolverAction::ReturnResult(address_list)); |
| 255 mock_resolver_->AddAction( |
| 256 HostResolverAction::ReturnError(ERR_NAME_NOT_RESOLVED)); |
| 257 HostResolver::RequestInfo request_info1( |
| 258 HostPortPair::FromString("example.com:12345")); |
| 259 request_info1.set_address_family(ADDRESS_FAMILY_IPV4); |
| 260 request_info1.set_is_my_ip_address(true); |
| 261 HostResolver::RequestInfo request_info2( |
| 262 HostPortPair::FromString("example.org:80")); |
| 263 request_info2.set_address_family(ADDRESS_FAMILY_IPV6); |
| 264 AddressList result1; |
| 265 AddressList result2; |
| 266 HostResolver::RequestHandle request_handle1 = nullptr; |
| 267 HostResolver::RequestHandle request_handle2 = nullptr; |
| 268 int error1 = 1; |
| 269 int error2 = 1; |
| 270 base::RunLoop run_loop; |
| 271 base::Closure barrier = base::BarrierClosure(2, run_loop.QuitClosure()); |
| 272 resolver_->Resolve(request_info1, DEFAULT_PRIORITY, &result1, |
| 273 base::Bind(&OnResolveComplete, &error1, barrier), |
| 274 &request_handle1, BoundNetLog()); |
| 275 resolver_->Resolve(request_info2, DEFAULT_PRIORITY, &result2, |
| 276 base::Bind(&OnResolveComplete, &error2, barrier), |
| 277 &request_handle2, BoundNetLog()); |
| 278 run_loop.Run(); |
| 279 EXPECT_EQ(OK, error1); |
| 280 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, error2); |
| 281 ASSERT_EQ(1u, result1.size()); |
| 282 EXPECT_EQ(address_list[0], result1[0]); |
| 283 ASSERT_EQ(0u, result2.size()); |
| 284 |
| 285 ASSERT_EQ(2u, mock_resolver_->requests().size()); |
| 286 interfaces::HostResolverRequestInfo& request1 = |
| 287 *mock_resolver_->requests()[0]; |
| 288 EXPECT_EQ("example.com", request1.host.To<std::string>()); |
| 289 EXPECT_EQ(12345, request1.port); |
| 290 EXPECT_EQ(interfaces::ADDRESS_FAMILY_IPV4, request1.address_family); |
| 291 EXPECT_TRUE(request1.is_my_ip_address); |
| 292 interfaces::HostResolverRequestInfo& request2 = |
| 293 *mock_resolver_->requests()[1]; |
| 294 EXPECT_EQ("example.org", request2.host.To<std::string>()); |
| 295 EXPECT_EQ(80, request2.port); |
| 296 EXPECT_EQ(interfaces::ADDRESS_FAMILY_IPV6, request2.address_family); |
| 297 EXPECT_FALSE(request2.is_my_ip_address); |
| 298 } |
| 299 |
| 300 TEST_F(HostResolverMojoTest, Error) { |
| 301 mock_resolver_->AddAction( |
| 302 HostResolverAction::ReturnError(ERR_NAME_NOT_RESOLVED)); |
| 303 HostResolver::RequestInfo request_info( |
| 304 HostPortPair::FromString("example.com:8080")); |
| 305 request_info.set_address_family(ADDRESS_FAMILY_IPV4); |
| 306 AddressList result; |
| 307 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, Resolve(request_info, &result)); |
| 308 EXPECT_TRUE(result.empty()); |
| 309 |
| 310 ASSERT_EQ(1u, mock_resolver_->requests().size()); |
| 311 interfaces::HostResolverRequestInfo& request = *mock_resolver_->requests()[0]; |
| 312 EXPECT_EQ("example.com", request.host.To<std::string>()); |
| 313 EXPECT_EQ(8080, request.port); |
| 314 EXPECT_EQ(interfaces::ADDRESS_FAMILY_IPV4, request.address_family); |
| 315 EXPECT_FALSE(request.is_my_ip_address); |
| 316 } |
| 317 |
| 318 TEST_F(HostResolverMojoTest, MissingResult) { |
| 319 mock_resolver_->AddAction(HostResolverAction::ReturnError(OK)); |
| 320 HostResolver::RequestInfo request_info( |
| 321 HostPortPair::FromString("example.com:8080")); |
| 322 AddressList result; |
| 323 EXPECT_EQ(ERR_FAILED, Resolve(request_info, &result)); |
| 324 EXPECT_TRUE(result.empty()); |
| 325 |
| 326 ASSERT_EQ(1u, mock_resolver_->requests().size()); |
| 327 } |
| 328 |
| 329 TEST_F(HostResolverMojoTest, Cancel) { |
| 330 mock_resolver_->AddAction(HostResolverAction::RetainRequest()); |
| 331 HostResolver::RequestInfo request_info( |
| 332 HostPortPair::FromString("example.com:80")); |
| 333 request_info.set_address_family(ADDRESS_FAMILY_IPV6); |
| 334 AddressList result; |
| 335 HostResolver::RequestHandle request_handle = nullptr; |
| 336 resolver_->Resolve(request_info, DEFAULT_PRIORITY, &result, base::Bind(&Fail), |
| 337 &request_handle, BoundNetLog()); |
| 338 resolver_->CancelRequest(request_handle); |
| 339 WaitForConnectionError(ConnectionErrorSource::REQUEST); |
| 340 EXPECT_TRUE(result.empty()); |
| 341 |
| 342 ASSERT_EQ(1u, mock_resolver_->requests().size()); |
| 343 interfaces::HostResolverRequestInfo& request = *mock_resolver_->requests()[0]; |
| 344 EXPECT_EQ("example.com", request.host.To<std::string>()); |
| 345 EXPECT_EQ(80, request.port); |
| 346 EXPECT_EQ(interfaces::ADDRESS_FAMILY_IPV6, request.address_family); |
| 347 EXPECT_FALSE(request.is_my_ip_address); |
| 348 } |
| 349 |
| 350 TEST_F(HostResolverMojoTest, ImplDropsClientConnection) { |
| 351 mock_resolver_->AddAction(HostResolverAction::DropRequest()); |
| 352 HostResolver::RequestInfo request_info( |
| 353 HostPortPair::FromString("example.com:1")); |
| 354 AddressList result; |
| 355 EXPECT_EQ(ERR_FAILED, Resolve(request_info, &result)); |
| 356 EXPECT_TRUE(result.empty()); |
| 357 |
| 358 ASSERT_EQ(1u, mock_resolver_->requests().size()); |
| 359 interfaces::HostResolverRequestInfo& request = *mock_resolver_->requests()[0]; |
| 360 EXPECT_EQ("example.com", request.host.To<std::string>()); |
| 361 EXPECT_EQ(1, request.port); |
| 362 EXPECT_EQ(interfaces::ADDRESS_FAMILY_UNSPECIFIED, request.address_family); |
| 363 EXPECT_FALSE(request.is_my_ip_address); |
| 364 } |
| 365 |
| 366 TEST_F(HostResolverMojoTest, DestroyImpl) { |
| 367 mock_resolver_.reset(); |
| 368 WaitForConnectionError(ConnectionErrorSource::CLIENT); |
| 369 } |
| 370 |
| 371 TEST_F(HostResolverMojoTest, DestroyClient) { |
| 372 resolver_.reset(); |
| 373 WaitForConnectionError(ConnectionErrorSource::RESOLVER); |
| 374 } |
| 375 |
| 376 TEST_F(HostResolverMojoTest, ResolverFromCache) { |
| 377 HostResolver::RequestInfo request_info( |
| 378 HostPortPair::FromString("example.com:8080")); |
| 379 AddressList result; |
| 380 EXPECT_EQ(ERR_FAILED, |
| 381 resolver_->ResolveFromCache(request_info, &result, BoundNetLog())); |
| 382 EXPECT_TRUE(result.empty()); |
| 383 } |
| 384 |
| 385 } // namespace net |
OLD | NEW |