Remove unused code

This code is not used for a while after it was
decided that secure sandbox with network access
is not possible on Windows.

BUG=349645

Review URL: https://codereview.chromium.org/1568573002

Cr-Commit-Position: refs/heads/master@{#368002}

5 files changed, 0 insertions, 640 deletions

diff --git a/chrome/utility/BUILD.gn b/chrome/utility/BUILD.gn
index edef316..22435b7 100644
--- a/chrome/utility/BUILD.gn
+++ b/chrome/utility/BUILD.gn
@@ -118,13 +118,6 @@ static_library("utility") {
     ]
   }
 
-  if (!enable_mdns) {
-    sources -= [
-      "local_discovery/service_discovery_message_handler.cc",
-      "local_discovery/service_discovery_message_handler.h",
-    ]
-  }
-
   if (safe_browsing_mode == 1) {
     sources +=
         rebase_path(gypi_values.chrome_utility_safe_browsing_sources, ".", "..")
diff --git a/chrome/utility/chrome_content_utility_client.cc b/chrome/utility/chrome_content_utility_client.cc
index c594732..b3cc696 100644
--- a/chrome/utility/chrome_content_utility_client.cc
+++ b/chrome/utility/chrome_content_utility_client.cc
@@ -56,10 +56,6 @@
 #include "chrome/utility/printing_handler.h"
 #endif
 
-#if defined(ENABLE_MDNS)
-#include "chrome/utility/local_discovery/service_discovery_message_handler.h"
-#endif
-
 #if defined(OS_MACOSX) && defined(FULL_SAFE_BROWSING)
 #include "chrome/utility/safe_browsing/mac/dmg_analyzer.h"
 #endif
@@ -133,13 +129,6 @@ ChromeContentUtilityClient::ChromeContentUtilityClient()
   handlers_.push_back(new printing::PrintingHandler());
 #endif
 
-#if defined(ENABLE_MDNS)
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kUtilityProcessEnableMDns)) {
-    handlers_.push_back(new local_discovery::ServiceDiscoveryMessageHandler());
-  }
-#endif
-
 #if defined(OS_WIN)
   handlers_.push_back(new ShellHandler());
   handlers_.push_back(new FontCacheHandler());
@@ -225,13 +214,6 @@ void ChromeContentUtilityClient::PreSandboxStartup() {
 #if defined(ENABLE_EXTENSIONS)
   extensions::ExtensionsHandler::PreSandboxStartup();
 #endif
-
-#if defined(ENABLE_MDNS)
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kUtilityProcessEnableMDns)) {
-    local_discovery::ServiceDiscoveryMessageHandler::PreSandboxStartup();
-  }
-#endif  // ENABLE_MDNS
 }
 
 // static
diff --git a/chrome/utility/local_discovery/OWNERS b/chrome/utility/local_discovery/OWNERS
deleted file mode 100644
index a0508fc..0000000
--- a/chrome/utility/local_discovery/OWNERS
+++ /dev/null
@@ -1,3 +0,0 @@
-gene@chromium.org
-noamsml@chromium.org
-vitalybuka@chromium.org
diff --git a/chrome/utility/local_discovery/service_discovery_message_handler.cc b/chrome/utility/local_discovery/service_discovery_message_handler.cc
deleted file mode 100644
index 9a9aac7..0000000
--- a/chrome/utility/local_discovery/service_discovery_message_handler.cc
+++ /dev/null
@@ -1,489 +0,0 @@
-// 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.
-
-#include "chrome/utility/local_discovery/service_discovery_message_handler.h"
-
-#include <stddef.h>
-
-#include <algorithm>
-#include <vector>
-
-#include "base/lazy_instance.h"
-#include "base/location.h"
-#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/single_thread_task_runner.h"
-#include "build/build_config.h"
-#include "chrome/common/local_discovery/local_discovery_messages.h"
-#include "chrome/common/local_discovery/service_discovery_client_impl.h"
-#include "content/public/utility/utility_thread.h"
-#include "net/base/net_util.h"
-#include "net/socket/socket_descriptor.h"
-#include "net/udp/datagram_server_socket.h"
-
-namespace local_discovery {
-
-namespace {
-
-void ClosePlatformSocket(net::SocketDescriptor socket);
-
-// Sets socket factory used by |net::CreatePlatformSocket|. Implemetation
-// keeps single socket that will be returned to the first call to
-// |net::CreatePlatformSocket| during object lifetime.
-class ScopedSocketFactory : public net::PlatformSocketFactory {
- public:
-  explicit ScopedSocketFactory(net::SocketDescriptor socket) : socket_(socket) {
-    net::PlatformSocketFactory::SetInstance(this);
-  }
-
-  ~ScopedSocketFactory() override {
-    net::PlatformSocketFactory::SetInstance(NULL);
-    ClosePlatformSocket(socket_);
-    socket_ = net::kInvalidSocket;
-  }
-
-  net::SocketDescriptor CreateSocket(int family,
-                                     int type,
-                                     int protocol) override {
-    DCHECK_EQ(type, SOCK_DGRAM);
-    DCHECK(family == AF_INET || family == AF_INET6);
-    net::SocketDescriptor result = net::kInvalidSocket;
-    std::swap(result, socket_);
-    return result;
-  }
-
- private:
-  net::SocketDescriptor socket_;
-  DISALLOW_COPY_AND_ASSIGN(ScopedSocketFactory);
-};
-
-struct SocketInfo {
-  SocketInfo(net::SocketDescriptor socket,
-             net::AddressFamily address_family,
-             uint32_t interface_index)
-      : socket(socket),
-        address_family(address_family),
-        interface_index(interface_index) {}
-  net::SocketDescriptor socket;
-  net::AddressFamily address_family;
-  uint32_t interface_index;
-};
-
-// Returns list of sockets preallocated before.
-class PreCreatedMDnsSocketFactory : public net::MDnsSocketFactory {
- public:
-  PreCreatedMDnsSocketFactory() {}
-  ~PreCreatedMDnsSocketFactory() override {
-    // Not empty if process exits too fast, before starting mDns code. If
-    // happened, destructors may crash accessing destroyed global objects.
-    // TODO This sounds memory leak, check and do better if possible
-    for (scoped_ptr<net::DatagramServerSocket>& it : sockets_)
-      base::IgnoreResult(it.release());
-    sockets_.clear();
-  }
-
-  // net::MDnsSocketFactory implementation:
-  void CreateSockets(
-      std::vector<scoped_ptr<net::DatagramServerSocket>>* sockets) override {
-    sockets->swap(sockets_);
-    Reset();
-  }
-
-  void AddSocket(const SocketInfo& socket_info) {
-    // Takes ownership of socket_info.socket;
-    ScopedSocketFactory platform_factory(socket_info.socket);
-    scoped_ptr<net::DatagramServerSocket> socket(
-        net::CreateAndBindMDnsSocket(socket_info.address_family,
-                                     socket_info.interface_index));
-    if (socket) {
-      socket->DetachFromThread();
-      sockets_.push_back(std::move(socket));
-    }
-  }
-
-  void Reset() {
-    sockets_.clear();
-  }
-
- private:
-  std::vector<scoped_ptr<net::DatagramServerSocket>> sockets_;
-
-  DISALLOW_COPY_AND_ASSIGN(PreCreatedMDnsSocketFactory);
-};
-
-base::LazyInstance<PreCreatedMDnsSocketFactory>
-    g_local_discovery_socket_factory = LAZY_INSTANCE_INITIALIZER;
-
-#if defined(OS_WIN)
-
-void ClosePlatformSocket(net::SocketDescriptor socket) {
-  ::closesocket(socket);
-}
-
-void StaticInitializeSocketFactory() {
-  net::InterfaceIndexFamilyList interfaces(net::GetMDnsInterfacesToBind());
-  for (size_t i = 0; i < interfaces.size(); ++i) {
-    DCHECK(interfaces[i].second == net::ADDRESS_FAMILY_IPV4 ||
-           interfaces[i].second == net::ADDRESS_FAMILY_IPV6);
-    net::SocketDescriptor descriptor =
-        net::CreatePlatformSocket(
-            net::ConvertAddressFamily(interfaces[i].second), SOCK_DGRAM,
-                                      IPPROTO_UDP);
-    g_local_discovery_socket_factory.Get().AddSocket(
-        SocketInfo(descriptor, interfaces[i].second, interfaces[i].first));
-  }
-}
-
-#else  // OS_WIN
-
-void ClosePlatformSocket(net::SocketDescriptor socket) {
-  ::close(socket);
-}
-
-void StaticInitializeSocketFactory() {
-}
-
-#endif  // OS_WIN
-
-void SendHostMessageOnUtilityThread(IPC::Message* msg) {
-  content::UtilityThread::Get()->Send(msg);
-}
-
-std::string WatcherUpdateToString(ServiceWatcher::UpdateType update) {
-  switch (update) {
-    case ServiceWatcher::UPDATE_ADDED:
-      return "UPDATE_ADDED";
-    case ServiceWatcher::UPDATE_CHANGED:
-      return "UPDATE_CHANGED";
-    case ServiceWatcher::UPDATE_REMOVED:
-      return "UPDATE_REMOVED";
-    case ServiceWatcher::UPDATE_INVALIDATED:
-      return "UPDATE_INVALIDATED";
-  }
-  return "Unknown Update";
-}
-
-std::string ResolverStatusToString(ServiceResolver::RequestStatus status) {
-  switch (status) {
-    case ServiceResolver::STATUS_SUCCESS:
-      return "STATUS_SUCESS";
-    case ServiceResolver::STATUS_REQUEST_TIMEOUT:
-      return "STATUS_REQUEST_TIMEOUT";
-    case ServiceResolver::STATUS_KNOWN_NONEXISTENT:
-      return "STATUS_KNOWN_NONEXISTENT";
-  }
-  return "Unknown Status";
-}
-
-}  // namespace
-
-ServiceDiscoveryMessageHandler::ServiceDiscoveryMessageHandler() {
-}
-
-ServiceDiscoveryMessageHandler::~ServiceDiscoveryMessageHandler() {
-  DCHECK(!discovery_thread_);
-}
-
-void ServiceDiscoveryMessageHandler::PreSandboxStartup() {
-  StaticInitializeSocketFactory();
-}
-
-void ServiceDiscoveryMessageHandler::InitializeMdns() {
-  if (service_discovery_client_ || mdns_client_)
-    return;
-
-  mdns_client_ = net::MDnsClient::CreateDefault();
-  bool result =
-      mdns_client_->StartListening(g_local_discovery_socket_factory.Pointer());
-  // Close unused sockets.
-  g_local_discovery_socket_factory.Get().Reset();
-  if (!result) {
-    VLOG(1) << "Failed to start MDnsClient";
-    Send(new LocalDiscoveryHostMsg_Error());
-    return;
-  }
-
-  service_discovery_client_.reset(
-      new local_discovery::ServiceDiscoveryClientImpl(mdns_client_.get()));
-}
-
-bool ServiceDiscoveryMessageHandler::InitializeThread() {
-  if (discovery_task_runner_.get())
-    return true;
-  if (discovery_thread_)
-    return false;
-  utility_task_runner_ = base::MessageLoop::current()->task_runner();
-  discovery_thread_.reset(new base::Thread("ServiceDiscoveryThread"));
-  base::Thread::Options thread_options(base::MessageLoop::TYPE_IO, 0);
-  if (discovery_thread_->StartWithOptions(thread_options)) {
-    discovery_task_runner_ = discovery_thread_->task_runner();
-    discovery_task_runner_->PostTask(FROM_HERE,
-        base::Bind(&ServiceDiscoveryMessageHandler::InitializeMdns,
-                    base::Unretained(this)));
-  }
-  return discovery_task_runner_.get() != NULL;
-}
-
-bool ServiceDiscoveryMessageHandler::OnMessageReceived(
-    const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(ServiceDiscoveryMessageHandler, message)
-#if defined(OS_POSIX)
-    IPC_MESSAGE_HANDLER(LocalDiscoveryMsg_SetSockets, OnSetSockets)
-#endif  // OS_POSIX
-    IPC_MESSAGE_HANDLER(LocalDiscoveryMsg_StartWatcher, OnStartWatcher)
-    IPC_MESSAGE_HANDLER(LocalDiscoveryMsg_DiscoverServices, OnDiscoverServices)
-    IPC_MESSAGE_HANDLER(LocalDiscoveryMsg_SetActivelyRefreshServices,
-                        OnSetActivelyRefreshServices)
-    IPC_MESSAGE_HANDLER(LocalDiscoveryMsg_DestroyWatcher, OnDestroyWatcher)
-    IPC_MESSAGE_HANDLER(LocalDiscoveryMsg_ResolveService, OnResolveService)
-    IPC_MESSAGE_HANDLER(LocalDiscoveryMsg_DestroyResolver, OnDestroyResolver)
-    IPC_MESSAGE_HANDLER(LocalDiscoveryMsg_ResolveLocalDomain,
-                        OnResolveLocalDomain)
-    IPC_MESSAGE_HANDLER(LocalDiscoveryMsg_DestroyLocalDomainResolver,
-                        OnDestroyLocalDomainResolver)
-    IPC_MESSAGE_HANDLER(LocalDiscoveryMsg_ShutdownLocalDiscovery,
-                        ShutdownLocalDiscovery)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
-}
-
-void ServiceDiscoveryMessageHandler::PostTask(
-    const tracked_objects::Location& from_here,
-    const base::Closure& task) {
-  if (!InitializeThread())
-    return;
-  discovery_task_runner_->PostTask(from_here, task);
-}
-
-#if defined(OS_POSIX)
-void ServiceDiscoveryMessageHandler::OnSetSockets(
-    const std::vector<LocalDiscoveryMsg_SocketInfo>& sockets) {
-  for (size_t i = 0; i < sockets.size(); ++i) {
-    g_local_discovery_socket_factory.Get().AddSocket(
-        SocketInfo(sockets[i].descriptor.fd, sockets[i].address_family,
-                   sockets[i].interface_index));
-  }
-}
-#endif  // OS_POSIX
-
-void ServiceDiscoveryMessageHandler::OnStartWatcher(
-    uint64_t id,
-    const std::string& service_type) {
-  PostTask(FROM_HERE,
-           base::Bind(&ServiceDiscoveryMessageHandler::StartWatcher,
-                      base::Unretained(this), id, service_type));
-}
-
-void ServiceDiscoveryMessageHandler::OnDiscoverServices(uint64_t id,
-                                                        bool force_update) {
-  PostTask(FROM_HERE,
-           base::Bind(&ServiceDiscoveryMessageHandler::DiscoverServices,
-                      base::Unretained(this), id, force_update));
-}
-
-void ServiceDiscoveryMessageHandler::OnSetActivelyRefreshServices(
-    uint64_t id,
-    bool actively_refresh_services) {
-  PostTask(FROM_HERE,
-           base::Bind(
-               &ServiceDiscoveryMessageHandler::SetActivelyRefreshServices,
-               base::Unretained(this), id, actively_refresh_services));
-}
-
-void ServiceDiscoveryMessageHandler::OnDestroyWatcher(uint64_t id) {
-  PostTask(FROM_HERE,
-           base::Bind(&ServiceDiscoveryMessageHandler::DestroyWatcher,
-                      base::Unretained(this), id));
-}
-
-void ServiceDiscoveryMessageHandler::OnResolveService(
-    uint64_t id,
-    const std::string& service_name) {
-  PostTask(FROM_HERE,
-           base::Bind(&ServiceDiscoveryMessageHandler::ResolveService,
-                      base::Unretained(this), id, service_name));
-}
-
-void ServiceDiscoveryMessageHandler::OnDestroyResolver(uint64_t id) {
-  PostTask(FROM_HERE,
-           base::Bind(&ServiceDiscoveryMessageHandler::DestroyResolver,
-                      base::Unretained(this), id));
-}
-
-void ServiceDiscoveryMessageHandler::OnResolveLocalDomain(
-    uint64_t id,
-    const std::string& domain,
-    net::AddressFamily address_family) {
-    PostTask(FROM_HERE,
-           base::Bind(&ServiceDiscoveryMessageHandler::ResolveLocalDomain,
-                      base::Unretained(this), id, domain, address_family));
-}
-
-void ServiceDiscoveryMessageHandler::OnDestroyLocalDomainResolver(uint64_t id) {
-  PostTask(FROM_HERE,
-           base::Bind(
-               &ServiceDiscoveryMessageHandler::DestroyLocalDomainResolver,
-               base::Unretained(this), id));
-}
-
-void ServiceDiscoveryMessageHandler::StartWatcher(
-    uint64_t id,
-    const std::string& service_type) {
-  VLOG(1) << "StartWatcher, id=" << id << ", type=" << service_type;
-  if (!service_discovery_client_)
-    return;
-  DCHECK(!ContainsKey(service_watchers_, id));
-  scoped_ptr<ServiceWatcher> watcher(
-      service_discovery_client_->CreateServiceWatcher(
-          service_type,
-          base::Bind(&ServiceDiscoveryMessageHandler::OnServiceUpdated,
-                     base::Unretained(this), id)));
-  watcher->Start();
-  service_watchers_[id].reset(watcher.release());
-}
-
-void ServiceDiscoveryMessageHandler::DiscoverServices(uint64_t id,
-                                                      bool force_update) {
-  VLOG(1) << "DiscoverServices, id=" << id;
-  if (!service_discovery_client_)
-    return;
-  DCHECK(ContainsKey(service_watchers_, id));
-  service_watchers_[id]->DiscoverNewServices(force_update);
-}
-
-void ServiceDiscoveryMessageHandler::SetActivelyRefreshServices(
-    uint64_t id,
-    bool actively_refresh_services) {
-  VLOG(1) << "ActivelyRefreshServices, id=" << id;
-  if (!service_discovery_client_)
-    return;
-  DCHECK(ContainsKey(service_watchers_, id));
-  service_watchers_[id]->SetActivelyRefreshServices(actively_refresh_services);
-}
-
-void ServiceDiscoveryMessageHandler::DestroyWatcher(uint64_t id) {
-  VLOG(1) << "DestoryWatcher, id=" << id;
-  if (!service_discovery_client_)
-    return;
-  service_watchers_.erase(id);
-}
-
-void ServiceDiscoveryMessageHandler::ResolveService(
-    uint64_t id,
-    const std::string& service_name) {
-  VLOG(1) << "ResolveService, id=" << id << ", name=" << service_name;
-  if (!service_discovery_client_)
-    return;
-  DCHECK(!ContainsKey(service_resolvers_, id));
-  scoped_ptr<ServiceResolver> resolver(
-      service_discovery_client_->CreateServiceResolver(
-          service_name,
-          base::Bind(&ServiceDiscoveryMessageHandler::OnServiceResolved,
-                     base::Unretained(this), id)));
-  resolver->StartResolving();
-  service_resolvers_[id].reset(resolver.release());
-}
-
-void ServiceDiscoveryMessageHandler::DestroyResolver(uint64_t id) {
-  VLOG(1) << "DestroyResolver, id=" << id;
-  if (!service_discovery_client_)
-    return;
-  service_resolvers_.erase(id);
-}
-
-void ServiceDiscoveryMessageHandler::ResolveLocalDomain(
-    uint64_t id,
-    const std::string& domain,
-    net::AddressFamily address_family) {
-  VLOG(1) << "ResolveLocalDomain, id=" << id << ", domain=" << domain;
-  if (!service_discovery_client_)
-    return;
-  DCHECK(!ContainsKey(local_domain_resolvers_, id));
-  scoped_ptr<LocalDomainResolver> resolver(
-      service_discovery_client_->CreateLocalDomainResolver(
-          domain, address_family,
-          base::Bind(&ServiceDiscoveryMessageHandler::OnLocalDomainResolved,
-                     base::Unretained(this), id)));
-  resolver->Start();
-  local_domain_resolvers_[id].reset(resolver.release());
-}
-
-void ServiceDiscoveryMessageHandler::DestroyLocalDomainResolver(uint64_t id) {
-  VLOG(1) << "DestroyLocalDomainResolver, id=" << id;
-  if (!service_discovery_client_)
-    return;
-  local_domain_resolvers_.erase(id);
-}
-
-void ServiceDiscoveryMessageHandler::ShutdownLocalDiscovery() {
-  if (!discovery_task_runner_.get())
-    return;
-
-  discovery_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&ServiceDiscoveryMessageHandler::ShutdownOnIOThread,
-                 base::Unretained(this)));
-
-  // This will wait for message loop to drain, so ShutdownOnIOThread will
-  // definitely be called.
-  discovery_thread_.reset();
-}
-
-void ServiceDiscoveryMessageHandler::ShutdownOnIOThread() {
-  VLOG(1) << "ShutdownLocalDiscovery";
-  service_watchers_.clear();
-  service_resolvers_.clear();
-  local_domain_resolvers_.clear();
-  service_discovery_client_.reset();
-  mdns_client_.reset();
-}
-
-void ServiceDiscoveryMessageHandler::OnServiceUpdated(
-    uint64_t id,
-    ServiceWatcher::UpdateType update,
-    const std::string& name) {
-  VLOG(1) << "OnServiceUpdated, id=" << id
-          << ", status=" << WatcherUpdateToString(update) << ", name=" << name;
-  DCHECK(service_discovery_client_);
-
-  Send(new LocalDiscoveryHostMsg_WatcherCallback(id, update, name));
-}
-
-void ServiceDiscoveryMessageHandler::OnServiceResolved(
-    uint64_t id,
-    ServiceResolver::RequestStatus status,
-    const ServiceDescription& description) {
-  VLOG(1) << "OnServiceResolved, id=" << id
-          << ", status=" << ResolverStatusToString(status)
-          << ", name=" << description.service_name;
-
-  DCHECK(service_discovery_client_);
-  Send(new LocalDiscoveryHostMsg_ResolverCallback(id, status, description));
-}
-
-void ServiceDiscoveryMessageHandler::OnLocalDomainResolved(
-    uint64_t id,
-    bool success,
-    const net::IPAddressNumber& address_ipv4,
-    const net::IPAddressNumber& address_ipv6) {
-  VLOG(1) << "OnLocalDomainResolved, id=" << id
-          << ", IPv4=" << (address_ipv4.empty() ? "" :
-                           net::IPAddressToString(address_ipv4))
-          << ", IPv6=" << (address_ipv6.empty() ? "" :
-                           net::IPAddressToString(address_ipv6));
-
-  DCHECK(service_discovery_client_);
-  Send(new LocalDiscoveryHostMsg_LocalDomainResolverCallback(
-          id, success, address_ipv4, address_ipv6));
-}
-
-void ServiceDiscoveryMessageHandler::Send(IPC::Message* msg) {
-  utility_task_runner_->PostTask(FROM_HERE,
-                                 base::Bind(&SendHostMessageOnUtilityThread,
-                                            msg));
-}
-
-}  // namespace local_discovery
diff --git a/chrome/utility/local_discovery/service_discovery_message_handler.h b/chrome/utility/local_discovery/service_discovery_message_handler.h
deleted file mode 100644
index ce0435d..0000000
--- a/chrome/utility/local_discovery/service_discovery_message_handler.h
+++ /dev/null
@@ -1,123 +0,0 @@
-// 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_UTILITY_LOCAL_DISCOVERY_SERVICE_DISCOVERY_MESSAGE_HANDLER_H_
-#define CHROME_UTILITY_LOCAL_DISCOVERY_SERVICE_DISCOVERY_MESSAGE_HANDLER_H_
-
-#include <stdint.h>
-
-#include <map>
-#include <string>
-
-#include "base/memory/linked_ptr.h"
-#include "build/build_config.h"
-#include "chrome/common/local_discovery/service_discovery_client.h"
-#include "chrome/utility/utility_message_handler.h"
-
-struct LocalDiscoveryMsg_SocketInfo;
-
-namespace net {
-class MDnsClient;
-}
-
-namespace base {
-struct FileDescriptor;
-class TaskRunner;
-class Thread;
-}
-
-namespace tracked_objects {
-class Location;
-}
-
-namespace local_discovery {
-
-class ServiceDiscoveryClient;
-
-// Handles messages related to local discovery inside utility process.
-class ServiceDiscoveryMessageHandler : public UtilityMessageHandler {
- public:
-  ServiceDiscoveryMessageHandler();
-  ~ServiceDiscoveryMessageHandler() override;
-
-  // UtilityMessageHandler implementation.
-  bool OnMessageReceived(const IPC::Message& message) override;
-
-  static void PreSandboxStartup();
-
- private:
-  typedef std::map<uint64_t, linked_ptr<ServiceWatcher>> ServiceWatchers;
-  typedef std::map<uint64_t, linked_ptr<ServiceResolver>> ServiceResolvers;
-  typedef std::map<uint64_t, linked_ptr<LocalDomainResolver>>
-      LocalDomainResolvers;
-
-  // Lazy initializes ServiceDiscoveryClient.
-  bool InitializeThread();
-  void PostTask(const tracked_objects::Location& from_here,
-                const base::Closure& task);
-
-  // IPC message handlers.
-#if defined(OS_POSIX)
-  void OnSetSockets(const std::vector<LocalDiscoveryMsg_SocketInfo>& sockets);
-#endif  // OS_POSIX
-  void OnStartWatcher(uint64_t id, const std::string& service_type);
-  void OnDiscoverServices(uint64_t id, bool force_update);
-  void OnSetActivelyRefreshServices(uint64_t id,
-                                    bool actively_refresh_services);
-  void OnDestroyWatcher(uint64_t id);
-  void OnResolveService(uint64_t id, const std::string& service_name);
-  void OnDestroyResolver(uint64_t id);
-  void OnResolveLocalDomain(uint64_t id,
-                            const std::string& domain,
-                            net::AddressFamily address_family);
-  void OnDestroyLocalDomainResolver(uint64_t id);
-
-  void InitializeMdns();
-  void StartWatcher(uint64_t id, const std::string& service_type);
-  void DiscoverServices(uint64_t id, bool force_update);
-  void SetActivelyRefreshServices(uint64_t id, bool actively_refresh_services);
-  void DestroyWatcher(uint64_t id);
-  void ResolveService(uint64_t id, const std::string& service_name);
-  void DestroyResolver(uint64_t id);
-  void ResolveLocalDomain(uint64_t id,
-                          const std::string& domain,
-                          net::AddressFamily address_family);
-  void DestroyLocalDomainResolver(uint64_t id);
-
-  void ShutdownLocalDiscovery();
-  void ShutdownOnIOThread();
-
-  // Is called by ServiceWatcher as callback.
-  void OnServiceUpdated(uint64_t id,
-                        ServiceWatcher::UpdateType update,
-                        const std::string& name);
-
-  // Is called by ServiceResolver as callback.
-  void OnServiceResolved(uint64_t id,
-                         ServiceResolver::RequestStatus status,
-                         const ServiceDescription& description);
-
-  // Is called by LocalDomainResolver as callback.
-  void OnLocalDomainResolved(uint64_t id,
-                             bool success,
-                             const net::IPAddressNumber& address_ipv4,
-                             const net::IPAddressNumber& address_ipv6);
-
-  void Send(IPC::Message* msg);
-
-  ServiceWatchers service_watchers_;
-  ServiceResolvers service_resolvers_;
-  LocalDomainResolvers local_domain_resolvers_;
-
-  scoped_ptr<net::MDnsClient> mdns_client_;
-  scoped_ptr<ServiceDiscoveryClient> service_discovery_client_;
-
-  scoped_refptr<base::TaskRunner> utility_task_runner_;
-  scoped_refptr<base::TaskRunner> discovery_task_runner_;
-  scoped_ptr<base::Thread> discovery_thread_;
-};
-
-}  // namespace local_discovery
-
-#endif  // CHROME_UTILITY_LOCAL_DISCOVERY_SERVICE_DISCOVERY_MESSAGE_HANDLER_H_