1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
|
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_LOCAL_DISCOVERY_SERVICE_DISCOVERY_CLIENT_IMPL_H_
#define CHROME_BROWSER_LOCAL_DISCOVERY_SERVICE_DISCOVERY_CLIENT_IMPL_H_
#include <map>
#include <string>
#include <vector>
#include "base/callback.h"
#include "base/cancelable_callback.h"
#include "base/memory/linked_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/message_loop.h"
#include "chrome/browser/local_discovery/service_discovery_client.h"
#include "net/dns/mdns_client.h"
namespace local_discovery {
class ServiceDiscoveryClientImpl : public ServiceDiscoveryClient {
public:
// |mdns_client| must outlive the Service Discovery Client.
explicit ServiceDiscoveryClientImpl(net::MDnsClient* mdns_client);
virtual ~ServiceDiscoveryClientImpl();
// ServiceDiscoveryClient implementation:
virtual scoped_ptr<ServiceWatcher> CreateServiceWatcher(
const std::string& service_type,
ServiceWatcher::Delegate* delegate) OVERRIDE;
virtual scoped_ptr<ServiceResolver> CreateServiceResolver(
const std::string& service_name,
const ServiceResolver::ResolveCompleteCallback& callback) OVERRIDE;
private:
net::MDnsClient* mdns_client_;
DISALLOW_COPY_AND_ASSIGN(ServiceDiscoveryClientImpl);
};
class ServiceWatcherImpl : public ServiceWatcher,
public net::MDnsListener::Delegate,
public base::SupportsWeakPtr<ServiceWatcherImpl> {
public:
ServiceWatcherImpl(const std::string& service_type,
ServiceWatcher::Delegate* delegate,
net::MDnsClient* mdns_client);
// Listening will automatically stop when the destructor is called.
virtual ~ServiceWatcherImpl();
// ServiceWatcher implementation:
virtual bool Start() OVERRIDE;
virtual void GetAvailableServices(
std::vector<std::string>* services) const OVERRIDE;
virtual void DiscoverNewServices(bool force_update) OVERRIDE;
virtual std::string GetServiceType() const OVERRIDE;
virtual void ReadCachedServices() OVERRIDE;
virtual void OnRecordUpdate(net::MDnsListener::UpdateType update,
const net::RecordParsed* record) OVERRIDE;
virtual void OnNsecRecord(const std::string& name, unsigned rrtype) OVERRIDE;
virtual void OnCachePurged() OVERRIDE;
virtual void OnTransactionResponse(
scoped_ptr<net::MDnsTransaction>* transaction,
net::MDnsTransaction::Result result,
const net::RecordParsed* record);
private:
struct ServiceListeners {
ServiceListeners(const std::string& service_name,
ServiceWatcherImpl* watcher,
net::MDnsClient* mdns_client);
~ServiceListeners();
bool Start();
void set_update_pending(bool update_pending) {
update_pending_ = update_pending;
}
bool update_pending() { return update_pending_; }
private:
scoped_ptr<net::MDnsListener> srv_listener_;
scoped_ptr<net::MDnsListener> txt_listener_;
bool update_pending_;
};
typedef std::map<std::string, linked_ptr<ServiceListeners> >
ServiceListenersMap;
void AddService(const std::string& service);
void RemoveService(const std::string& service);
bool CreateTransaction(bool active, bool alert_existing_services,
bool force_refresh,
scoped_ptr<net::MDnsTransaction>* transaction);
void DeferUpdate(ServiceWatcher::UpdateType update_type,
const std::string& service_name);
void DeliverDeferredUpdate(ServiceWatcher::UpdateType update_type,
const std::string& service_name);
std::string service_type_;
ServiceListenersMap services_;
scoped_ptr<net::MDnsTransaction> transaction_network_;
scoped_ptr<net::MDnsTransaction> transaction_cache_;
scoped_ptr<net::MDnsListener> listener_;
ServiceWatcher::Delegate* delegate_;
bool started_;
net::MDnsClient* mdns_client_;
DISALLOW_COPY_AND_ASSIGN(ServiceWatcherImpl);
};
class ServiceResolverImpl
: public ServiceResolver,
public base::SupportsWeakPtr<ServiceResolverImpl> {
public:
ServiceResolverImpl(const std::string& service_name,
const ServiceResolver::ResolveCompleteCallback& callback,
net::MDnsClient* mdns_client);
virtual ~ServiceResolverImpl();
// ServiceResolver implementation:
virtual bool StartResolving() OVERRIDE;
virtual bool IsResolving() const OVERRIDE;
virtual bool HasResolved() const OVERRIDE;
virtual std::string GetName() const OVERRIDE;
virtual const ServiceDescription& GetServiceDescription() const OVERRIDE;
private:
// Respond to transaction finishing for SRV records.
void SrvRecordTransactionResponse(net::MDnsTransaction::Result status,
const net::RecordParsed* record);
// Respond to transaction finishing for TXT records.
void TxtRecordTransactionResponse(net::MDnsTransaction::Result status,
const net::RecordParsed* record);
// Respond to transaction finishing for A records.
void ARecordTransactionResponse(net::MDnsTransaction::Result status,
const net::RecordParsed* record);
void AlertCallbackIfReady();
void ServiceNotFound(RequestStatus status);
// Convert a TXT record to a vector of strings (metadata).
const std::vector<std::string>& RecordToMetadata(
const net::RecordParsed* record) const;
// Convert an SRV record to a host and port pair.
net::HostPortPair RecordToAddress(
const net::RecordParsed* record) const;
// Convert an A record to an IP address.
const net::IPAddressNumber& RecordToIPAddress(
const net::RecordParsed* record) const;
// Convert an MDns status to a service discovery status.
RequestStatus MDnsStatusToRequestStatus(
net::MDnsTransaction::Result status) const;
bool CreateTxtTransaction();
bool CreateSrvTransaction();
void CreateATransaction();
std::string service_name_;
ResolveCompleteCallback callback_;
bool is_resolving_;
bool has_resolved_;
bool metadata_resolved_;
bool address_resolved_;
scoped_ptr<net::MDnsTransaction> txt_transaction_;
scoped_ptr<net::MDnsTransaction> srv_transaction_;
scoped_ptr<net::MDnsTransaction> a_transaction_;
scoped_ptr<ServiceDescription> service_staging_;
scoped_ptr<ServiceDescription> service_final_;
net::MDnsClient* mdns_client_;
DISALLOW_COPY_AND_ASSIGN(ServiceResolverImpl);
};
} // namespace local_discovery
#endif // CHROME_BROWSER_LOCAL_DISCOVERY_SERVICE_DISCOVERY_CLIENT_IMPL_H_
|
