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/mojo_host_resolver_impl.h" | |
6 | |
7 #include "base/basictypes.h" | |
8 #include "base/bind.h" | |
9 #include "base/message_loop/message_loop.h" | |
10 #include "base/stl_util.h" | |
11 #include "net/base/address_list.h" | |
12 #include "net/base/net_errors.h" | |
13 #include "net/dns/host_resolver.h" | |
14 #include "net/dns/type_converters.h" | |
15 | |
16 namespace net { | |
17 | |
18 // Handles host resolution for a single request and sends a response when done. | |
19 // Also detects connection errors for HostResolverRequestClient and cancels the | |
20 // outstanding resolve request. Owned by MojoHostResolverImpl. | |
21 class MojoHostResolverImpl::Job : public mojo::ErrorHandler { | |
22 public: | |
23 Job(base::WeakPtr<MojoHostResolverImpl> resolver_service, | |
24 net::HostResolver* resolver, | |
25 const net::HostResolver::RequestInfo& request_info, | |
26 interfaces::HostResolverRequestClientPtr client); | |
27 ~Job() override; | |
28 | |
29 private: | |
30 // Completion callback for the HostResolver::Resolve request. | |
31 void OnResolveDone(int result); | |
32 | |
33 // Overridden from mojo::ErrorHandler: | |
34 void OnConnectionError() override; | |
35 | |
36 base::WeakPtr<MojoHostResolverImpl> resolver_service_; | |
37 net::HostResolver* resolver_; | |
38 net::HostResolver::RequestInfo request_info_; | |
39 interfaces::HostResolverRequestClientPtr client_; | |
40 net::HostResolver::RequestHandle handle_; | |
41 AddressList result_; | |
42 base::ThreadChecker thread_checker_; | |
43 }; | |
44 | |
45 MojoHostResolverImpl::MojoHostResolverImpl(net::HostResolver* resolver) | |
46 : resolver_(resolver), weak_factory_(this) { | |
47 } | |
48 | |
49 MojoHostResolverImpl::~MojoHostResolverImpl() { | |
50 DCHECK(thread_checker_.CalledOnValidThread()); | |
51 STLDeleteElements(&pending_jobs_); | |
52 } | |
53 | |
54 void MojoHostResolverImpl::Resolve( | |
55 interfaces::HostResolverRequestInfoPtr request_info, | |
56 interfaces::HostResolverRequestClientPtr client) { | |
57 DCHECK(thread_checker_.CalledOnValidThread()); | |
58 Job* job = new Job(weak_factory_.GetWeakPtr(), resolver_, | |
59 request_info->To<net::HostResolver::RequestInfo>(), | |
60 client.Pass()); | |
61 pending_jobs_.insert(job); | |
62 } | |
63 | |
64 void MojoHostResolverImpl::DeleteJob(Job* job) { | |
65 DCHECK(thread_checker_.CalledOnValidThread()); | |
66 if (ContainsKey(pending_jobs_, job)) { | |
67 size_t num_erased = pending_jobs_.erase(job); | |
Sam McNally
2015/02/06 07:12:32
Please use the iterator erase overload. Doing two
Anand Mistry (off Chromium)
2015/02/08 23:09:21
I've gone back to having a Start() method. I reali
| |
68 DCHECK(num_erased); | |
69 delete job; | |
70 } | |
71 } | |
72 | |
73 MojoHostResolverImpl::Job::Job( | |
74 base::WeakPtr<MojoHostResolverImpl> resolver_service, | |
75 net::HostResolver* resolver, | |
76 const net::HostResolver::RequestInfo& request_info, | |
77 interfaces::HostResolverRequestClientPtr client) | |
78 : resolver_service_(resolver_service), | |
79 resolver_(resolver), | |
80 request_info_(request_info), | |
81 client_(client.Pass()), | |
82 handle_(nullptr) { | |
83 client_.set_error_handler(this); | |
84 | |
85 DVLOG(1) << "Resolve " << request_info_.host_port_pair().ToString(); | |
86 BoundNetLog net_log; | |
87 int result = | |
88 resolver_->Resolve(request_info_, DEFAULT_PRIORITY, &result_, | |
89 base::Bind(&MojoHostResolverImpl::Job::OnResolveDone, | |
90 base::Unretained(this)), | |
91 &handle_, net_log); | |
92 | |
93 if (result != ERR_IO_PENDING) | |
94 OnResolveDone(result); | |
95 } | |
96 | |
97 MojoHostResolverImpl::Job::~Job() { | |
98 DCHECK(thread_checker_.CalledOnValidThread()); | |
99 if (handle_) | |
100 resolver_->CancelRequest(handle_); | |
101 } | |
102 | |
103 void MojoHostResolverImpl::Job::OnResolveDone(int result) { | |
104 DCHECK(thread_checker_.CalledOnValidThread()); | |
105 handle_ = nullptr; | |
106 DVLOG(1) << "Resolved " << request_info_.host_port_pair().ToString() | |
107 << " with error " << result << " and " << result_.size() | |
108 << " results!"; | |
109 for (const auto& address : result_) { | |
110 VLOG(1) << address.ToString(); | |
111 } | |
112 if (result) | |
113 client_->ReportResult(result, nullptr); | |
114 else | |
115 client_->ReportResult(0, interfaces::AddressList::From(result_)); | |
116 | |
117 // We could have been called inline with the constructor, so delay | |
118 // destruction. | |
119 base::MessageLoopProxy::current()->PostTask( | |
120 FROM_HERE, | |
121 base::Bind(&MojoHostResolverImpl::DeleteJob, resolver_service_, this)); | |
122 } | |
123 | |
124 void MojoHostResolverImpl::Job::OnConnectionError() { | |
125 DCHECK(thread_checker_.CalledOnValidThread()); | |
126 // |resolver_service_| should always outlive us. | |
127 DCHECK(resolver_service_); | |
128 DVLOG(1) << "Connection error on request for " | |
129 << request_info_.host_port_pair().ToString(); | |
130 resolver_service_->DeleteJob(this); | |
131 } | |
132 | |
133 } // namespace net | |
OLD | NEW |