service_discovery_host_client.h revision 0529e5d033099cbfc42635f6f6183833b09dff6e 
1// Copyright 2013 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#ifndef CHROME_BROWSER_LOCAL_DISCOVERY_SERVICE_DISCOVERY_HOST_CLIENT_H_
6#define CHROME_BROWSER_LOCAL_DISCOVERY_SERVICE_DISCOVERY_HOST_CLIENT_H_
7
8#include <map>
9#include <string>
10#include <vector>
11
12#include "base/memory/ref_counted.h"
13#include "base/memory/scoped_vector.h"
14#include "base/memory/weak_ptr.h"
15#include "chrome/common/local_discovery/service_discovery_client.h"
16#include "content/public/browser/utility_process_host_client.h"
17
18struct LocalDiscoveryMsg_SocketInfo;
19
20namespace base {
21class TaskRunner;
22}
23
24namespace content {
25class UtilityProcessHost;
26}
27
28namespace local_discovery {
29
30#if defined(OS_POSIX)
31typedef std::vector<LocalDiscoveryMsg_SocketInfo> SocketInfoList;
32#endif  // OS_POSIX
33
34// Implementation of ServiceDiscoveryClient that delegates all functionality to
35// utility process.
36class ServiceDiscoveryHostClient
37    : public ServiceDiscoveryClient,
38      public content::UtilityProcessHostClient {
39 public:
40  ServiceDiscoveryHostClient();
41
42  // Starts utility process with ServiceDiscoveryClient.
43  void Start(const base::Closure& error_callback);
44
45  // Shutdowns utility process.
46  void Shutdown();
47
48  // ServiceDiscoveryClient implementation.
49  virtual scoped_ptr<ServiceWatcher> CreateServiceWatcher(
50      const std::string& service_type,
51      const ServiceWatcher::UpdatedCallback& callback) OVERRIDE;
52  virtual scoped_ptr<ServiceResolver> CreateServiceResolver(
53      const std::string& service_name,
54      const ServiceResolver::ResolveCompleteCallback& callback) OVERRIDE;
55  virtual scoped_ptr<LocalDomainResolver> CreateLocalDomainResolver(
56      const std::string& domain,
57      net::AddressFamily address_family,
58      const LocalDomainResolver::IPAddressCallback& callback) OVERRIDE;
59
60  // UtilityProcessHostClient implementation.
61  virtual void OnProcessCrashed(int exit_code) OVERRIDE;
62  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
63
64 protected:
65  virtual ~ServiceDiscoveryHostClient();
66
67 private:
68  class ServiceWatcherProxy;
69  class ServiceResolverProxy;
70  class LocalDomainResolverProxy;
71  friend class ServiceDiscoveryClientMdns;
72
73  typedef std::map<uint64, ServiceWatcher::UpdatedCallback> WatcherCallbacks;
74  typedef std::map<uint64, ServiceResolver::ResolveCompleteCallback>
75      ResolverCallbacks;
76  typedef std::map<uint64, LocalDomainResolver::IPAddressCallback>
77      DomainResolverCallbacks;
78
79  void StartOnIOThread();
80  void ShutdownOnIOThread();
81
82#if defined(OS_POSIX)
83  void OnSocketsReady(const SocketInfoList& interfaces);
84#endif  // OS_POSIX
85
86  void InvalidateWatchers();
87
88  void Send(IPC::Message* msg);
89  void SendOnIOThread(IPC::Message* msg);
90
91  uint64 RegisterWatcherCallback(
92      const ServiceWatcher::UpdatedCallback& callback);
93  uint64 RegisterResolverCallback(
94      const ServiceResolver::ResolveCompleteCallback& callback);
95  uint64 RegisterLocalDomainResolverCallback(
96      const LocalDomainResolver::IPAddressCallback& callback);
97
98  void UnregisterWatcherCallback(uint64 id);
99  void UnregisterResolverCallback(uint64 id);
100  void UnregisterLocalDomainResolverCallback(uint64 id);
101
102  // IPC Message handlers.
103  void OnError();
104  void OnWatcherCallback(uint64 id,
105                         ServiceWatcher::UpdateType update,
106                         const std::string& service_name);
107  void OnResolverCallback(uint64 id,
108                          ServiceResolver::RequestStatus status,
109                          const ServiceDescription& description);
110  void OnLocalDomainResolverCallback(uint64 id,
111                                     bool success,
112                                     const net::IPAddressNumber& address_ipv4,
113                                     const net::IPAddressNumber& address_ipv6);
114
115
116  // Runs watcher callback on owning thread.
117  void RunWatcherCallback(uint64 id,
118                          ServiceWatcher::UpdateType update,
119                          const std::string& service_name);
120  // Runs resolver callback on owning thread.
121  void RunResolverCallback(uint64 id,
122                           ServiceResolver::RequestStatus status,
123                           const ServiceDescription& description);
124  // Runs local domain resolver callback on owning thread.
125  void RunLocalDomainResolverCallback(uint64 id,
126                                      bool success,
127                                      const net::IPAddressNumber& address_ipv4,
128                                      const net::IPAddressNumber& address_ipv6);
129
130
131  base::WeakPtr<content::UtilityProcessHost> utility_host_;
132
133  // Incrementing counter to assign ID to watchers and resolvers.
134  uint64 current_id_;
135  base::Closure error_callback_;
136  WatcherCallbacks service_watcher_callbacks_;
137  ResolverCallbacks service_resolver_callbacks_;
138  DomainResolverCallbacks domain_resolver_callbacks_;
139  scoped_refptr<base::TaskRunner> callback_runner_;
140  scoped_refptr<base::TaskRunner> io_runner_;
141  ScopedVector<IPC::Message> delayed_messages_;
142
143  DISALLOW_COPY_AND_ASSIGN(ServiceDiscoveryHostClient);
144};
145
146}  // namespace local_discovery
147
148#endif  // CHROME_BROWSER_LOCAL_DISCOVERY_SERVICE_DISCOVERY_HOST_CLIENT_H_
149