blob: 84ab680717c6d2046fffe0f8584fefbd76ef336e (
plain)
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
|
// 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_EXTENSIONS_API_MDNS_DNS_SD_REGISTRY_H_
#define CHROME_BROWSER_EXTENSIONS_API_MDNS_DNS_SD_REGISTRY_H_
#include <map>
#include <string>
#include <utility>
#include <vector>
#include "base/memory/linked_ptr.h"
#include "base/memory/scoped_ptr.h"
#include "base/observer_list.h"
#include "chrome/browser/extensions/api/mdns/dns_sd_delegate.h"
namespace local_discovery {
class ServiceDiscoverySharedClient;
class ServiceDiscoveryClient;
}
namespace extensions {
class DnsSdDeviceLister;
class ServiceTypeData;
// Registry class for keeping track of discovered network services over DNS-SD.
class DnsSdRegistry : public DnsSdDelegate {
public:
typedef std::vector<DnsSdService> DnsSdServiceList;
class DnsSdObserver {
public:
virtual void OnDnsSdEvent(const std::string& service_type,
const DnsSdServiceList& services) = 0;
protected:
virtual ~DnsSdObserver() {}
};
DnsSdRegistry();
explicit DnsSdRegistry(local_discovery::ServiceDiscoverySharedClient* client);
virtual ~DnsSdRegistry();
// Publishes the current device list for |service_type| to event listeners
// whose event filter matches the service type.
virtual void Publish(const std::string& service_type);
// Immediately issues a multicast DNS query for all service types of the
// calling extension.
virtual void ForceDiscovery();
// Observer registration for parties interested in discovery events.
virtual void AddObserver(DnsSdObserver* observer);
virtual void RemoveObserver(DnsSdObserver* observer);
// DNS-SD-related discovery functionality.
virtual void RegisterDnsSdListener(const std::string& service_type);
virtual void UnregisterDnsSdListener(const std::string& service_type);
protected:
// Data class for managing all the resources and information related to a
// particular service type.
class ServiceTypeData {
public:
explicit ServiceTypeData(scoped_ptr<DnsSdDeviceLister> lister);
virtual ~ServiceTypeData();
// Notify the data class of listeners so that it can be reference counted.
void ListenerAdded();
// Returns true if the last listener was removed.
bool ListenerRemoved();
int GetListenerCount();
// Immediately issues a multicast DNS query for the service type owned by
// |this|.
void ForceDiscovery();
// Methods for adding, updating or removing services for this service type.
bool UpdateService(bool added, const DnsSdService& service);
bool RemoveService(const std::string& service_name);
// Called when the discovery service was restarted.
// Clear the local cache and initiate rediscovery.
bool ClearServices();
const DnsSdRegistry::DnsSdServiceList& GetServiceList();
private:
int ref_count;
scoped_ptr<DnsSdDeviceLister> lister_;
DnsSdRegistry::DnsSdServiceList service_list_;
DISALLOW_COPY_AND_ASSIGN(ServiceTypeData);
};
// Maps service types to associated data such as listers and service lists.
typedef std::map<std::string, linked_ptr<ServiceTypeData> >
DnsSdServiceTypeDataMap;
virtual DnsSdDeviceLister* CreateDnsSdDeviceLister(
DnsSdDelegate* delegate,
const std::string& service_type,
local_discovery::ServiceDiscoverySharedClient* discovery_client);
// DnsSdDelegate implementation:
void ServiceChanged(const std::string& service_type,
bool added,
const DnsSdService& service) override;
void ServiceRemoved(const std::string& service_type,
const std::string& service_name) override;
void ServicesFlushed(const std::string& service_type) override;
DnsSdServiceTypeDataMap service_data_map_;
private:
void DispatchApiEvent(const std::string& service_type);
bool IsRegistered(const std::string& service_type);
scoped_refptr<local_discovery::ServiceDiscoverySharedClient>
service_discovery_client_;
base::ObserverList<DnsSdObserver> observers_;
DISALLOW_COPY_AND_ASSIGN(DnsSdRegistry);
};
} // namespace extensions
#endif // CHROME_BROWSER_EXTENSIONS_API_MDNS_DNS_SD_REGISTRY_H_
|
