chrome/browser/local_discovery/service_discovery_client_mac.h

   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_CLIENT_MAC_H_
   6 #define CHROME_BROWSER_LOCAL_DISCOVERY_SERVICE_DISCOVERY_CLIENT_MAC_H_
   7
   8 #import <Foundation/Foundation.h>
   9 #include <string>
  10
  11 #include "base/mac/scoped_nsobject.h"
  12 #include "base/memory/weak_ptr.h"
  13 #include "base/single_thread_task_runner.h"
  14 #include "base/thread_task_runner_handle.h"
  15 #include "chrome/browser/local_discovery/service_discovery_shared_client.h"
  16 #include "content/public/browser/browser_thread.h"
  17
  18 namespace base {
  19 class Thread;
  20 }
  21
  22 namespace local_discovery {
  23
  24 template <class T>
  25 class ServiceDiscoveryThreadDeleter {
  26  public:
  27   inline void operator()(T* t) { t->DeleteSoon(); }
  28 };
  29
  30 // Implementation of ServiceDiscoveryClient that uses the Bonjour SDK.
  31 // https://developer.apple.com/library/mac/documentation/Networking/Conceptual/
  32 // NSNetServiceProgGuide/Articles/BrowsingForServices.html
  33 class ServiceDiscoveryClientMac : public ServiceDiscoverySharedClient {
  34  public:
  35   ServiceDiscoveryClientMac();
  36
  37  private:
  38   ~ServiceDiscoveryClientMac() override;
  39
  40   // ServiceDiscoveryClient implementation.
  41   scoped_ptr<ServiceWatcher> CreateServiceWatcher(
  42       const std::string& service_type,
  43       const ServiceWatcher::UpdatedCallback& callback) override;
  44   scoped_ptr<ServiceResolver> CreateServiceResolver(
  45       const std::string& service_name,
  46       const ServiceResolver::ResolveCompleteCallback& callback) override;
  47   scoped_ptr<LocalDomainResolver> CreateLocalDomainResolver(
  48       const std::string& domain,
  49       net::AddressFamily address_family,
  50       const LocalDomainResolver::IPAddressCallback& callback) override;
  51
  52   void StartThreadIfNotStarted();
  53
  54   scoped_ptr<base::Thread> service_discovery_thread_;
  55
  56   DISALLOW_COPY_AND_ASSIGN(ServiceDiscoveryClientMac);
  57 };
  58
  59 class ServiceWatcherImplMac : public ServiceWatcher {
  60  public:
  61   class NetServiceBrowserContainer {
  62    public:
  63     NetServiceBrowserContainer(
  64         const std::string& service_type,
  65         const ServiceWatcher::UpdatedCallback& callback,
  66         scoped_refptr<base::SingleThreadTaskRunner> service_discovery_runner);
  67     ~NetServiceBrowserContainer();
  68
  69     void Start();
  70     void DiscoverNewServices();
  71
  72     void OnServicesUpdate(ServiceWatcher::UpdateType update,
  73                           const std::string& service);
  74
  75     void DeleteSoon();
  76
  77    private:
  78     void StartOnDiscoveryThread();
  79     void DiscoverOnDiscoveryThread();
  80
  81     bool IsOnServiceDiscoveryThread() {
  82       return base::ThreadTaskRunnerHandle::Get() ==
  83              service_discovery_runner_.get();
  84     }
  85
  86     std::string service_type_;
  87     ServiceWatcher::UpdatedCallback callback_;
  88
  89     scoped_refptr<base::SingleThreadTaskRunner> callback_runner_;
  90     scoped_refptr<base::SingleThreadTaskRunner> service_discovery_runner_;
  91
  92     base::scoped_nsobject<id> delegate_;
  93     base::scoped_nsobject<NSNetServiceBrowser> browser_;
  94     base::WeakPtrFactory<NetServiceBrowserContainer> weak_factory_;
  95   };
  96
  97   ServiceWatcherImplMac(
  98       const std::string& service_type,
  99       const ServiceWatcher::UpdatedCallback& callback,
 100       scoped_refptr<base::SingleThreadTaskRunner> service_discovery_runner);
 101
 102   void OnServicesUpdate(ServiceWatcher::UpdateType update,
 103                         const std::string& service);
 104
 105  private:
 106   ~ServiceWatcherImplMac() override;
 107
 108   void Start() override;
 109   void DiscoverNewServices(bool force_update) override;
 110   void SetActivelyRefreshServices(bool actively_refresh_services) override;
 111   std::string GetServiceType() const override;
 112
 113   std::string service_type_;
 114   ServiceWatcher::UpdatedCallback callback_;
 115   bool started_;
 116
 117   scoped_ptr<NetServiceBrowserContainer,
 118              ServiceDiscoveryThreadDeleter<NetServiceBrowserContainer> >
 119       container_;
 120   base::WeakPtrFactory<ServiceWatcherImplMac> weak_factory_;
 121
 122   DISALLOW_COPY_AND_ASSIGN(ServiceWatcherImplMac);
 123 };
 124
 125 class ServiceResolverImplMac : public ServiceResolver {
 126  public:
 127   class NetServiceContainer {
 128    public:
 129     NetServiceContainer(
 130         const std::string& service_name,
 131         const ServiceResolver::ResolveCompleteCallback& callback,
 132         scoped_refptr<base::SingleThreadTaskRunner> service_discovery_runner);
 133
 134     virtual ~NetServiceContainer();
 135
 136     void StartResolving();
 137
 138     void OnResolveUpdate(RequestStatus);
 139
 140     void SetServiceForTesting(base::scoped_nsobject<NSNetService> service);
 141
 142     void DeleteSoon();
 143
 144    private:
 145     void StartResolvingOnDiscoveryThread();
 146
 147     bool IsOnServiceDiscoveryThread() {
 148       return base::ThreadTaskRunnerHandle::Get() ==
 149              service_discovery_runner_.get();
 150     }
 151
 152     const std::string service_name_;
 153     ServiceResolver::ResolveCompleteCallback callback_;
 154
 155     scoped_refptr<base::SingleThreadTaskRunner> callback_runner_;
 156     scoped_refptr<base::SingleThreadTaskRunner> service_discovery_runner_;
 157
 158     base::scoped_nsobject<id> delegate_;
 159     base::scoped_nsobject<NSNetService> service_;
 160     ServiceDescription service_description_;
 161     base::WeakPtrFactory<NetServiceContainer> weak_factory_;
 162   };
 163
 164   ServiceResolverImplMac(
 165       const std::string& service_name,
 166       const ServiceResolver::ResolveCompleteCallback& callback,
 167       scoped_refptr<base::SingleThreadTaskRunner> service_discovery_runner);
 168
 169   // Testing methods.
 170   NetServiceContainer* GetContainerForTesting();
 171
 172  private:
 173   ~ServiceResolverImplMac() override;
 174
 175   void StartResolving() override;
 176   std::string GetName() const override;
 177
 178   void OnResolveComplete(RequestStatus status,
 179                          const ServiceDescription& description);
 180
 181   const std::string service_name_;
 182   ServiceResolver::ResolveCompleteCallback callback_;
 183   bool has_resolved_;
 184
 185   scoped_ptr<NetServiceContainer,
 186              ServiceDiscoveryThreadDeleter<NetServiceContainer> > container_;
 187   base::WeakPtrFactory<ServiceResolverImplMac> weak_factory_;
 188
 189   DISALLOW_COPY_AND_ASSIGN(ServiceResolverImplMac);
 190 };
 191
 192 }  // namespace local_discovery
 193
 194 #endif  // CHROME_BROWSER_LOCAL_DISCOVERY_SERVICE_DISCOVERY_CLIENT_MAC_H_