chrome.mdns API

chrome/browser/extensions/api/mdns/mdns_service.cc

+// Copyright (c) 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/browser/extensions/api/mdns/mdns_service.h"
+
+#include "base/bind.h"
+#include "chrome/browser/local_discovery/service_discovery_host_client.h"
+#include "chrome/common/extensions/api/mdns.h"
+#include "chrome/common/local_discovery/service_discovery_client.h"
+#include "net/base/net_util.h"
+
+using local_discovery::ServiceDescription;
+using local_discovery::ServiceResolver;
+using local_discovery::ServiceWatcher;
+using local_discovery::ServiceDiscoveryHostClientFactory;
+
+namespace extensions {
+
+MDnsService::MDnsService(const std::string& service_type,
+                         MDnsService::Delegate *delegate)
+    : service_type_(service_type),
+      delegate_(delegate),
+      service_discovery_client_(ServiceDiscoveryHostClientFactory::GetClient()),
+      running_(false) {
+}
+
+MDnsService::~MDnsService() {}
+
+bool MDnsService::Start() {
+  if (running_) {
+    return true;
+  }
+  service_watcher_ = service_discovery_client_->CreateServiceWatcher(
+      service_type_,
+      base::Bind(&MDnsService::OnServiceUpdated,
+                 base::Unretained(this)));
+  service_watcher_->Start();
+  return (running_ = true);
+}
+
+void MDnsService::Stop() {
+  service_watcher_.reset(NULL);
+}
+
+void MDnsService::Discover(bool force_update) {
+  service_watcher_->DiscoverNewServices(force_update);
+}
+
+void MDnsService::OnServiceUpdated(
+    ServiceWatcher::UpdateType update,
+    const std::string& service_name) {
+  bool added = (update == ServiceWatcher::UPDATE_ADDED);
+  // TODO: This used to not compile because of the switch. Needs a fix.
+  std::pair<ServiceResolverMap::iterator, bool> insert_result;
+  switch (update) {
+  case ServiceWatcher::UPDATE_ADDED:
+  case ServiceWatcher::UPDATE_CHANGED:
+    insert_result =
+      resolvers_.insert(make_pair(service_name,
+                                  linked_ptr<ServiceResolver>(NULL)));
+
+    // If there is already a resolver working on this service, don't add one.
+    if (insert_result.second) {
+      scoped_ptr<ServiceResolver> resolver =
+          service_discovery_client_->CreateServiceResolver(
+          service_name, base::Bind(
+              &MDnsService::OnResolveComplete,
+              base::Unretained(this),
+              added));
+      insert_result.first->second.reset(resolver.release());
+      insert_result.first->second->StartResolving();
+    }
+    break;
+  case ServiceWatcher::UPDATE_REMOVED:
+    delegate_->ServiceRemoved(service_name);
+    break;
+  default:
+    LOG(FATAL) << "Unknown ServiceWatcher::UpdateType " << update;
+  }
+}
+
+void MDnsService::OnResolveComplete(
+    bool added,
+    ServiceResolver::RequestStatus status,
+    const ServiceDescription& service_description) {
+  if (status != ServiceResolver::STATUS_SUCCESS) {
+    resolvers_.erase(service_description.service_name);
+    // TODO(noamsml): Add retry logic.
+    return;
+  }
+
+  std::string service_name = service_description.service_name;
+  resolvers_.erase(service_name);
+  api::mdns::MDnsService service;
+  service.service_name = service_name;
+  service.service_host_port = service_description.address.ToString();
+  service.ip_address = net::IPAddressToString(service_description.ip_address);
+  service.service_data = service_description.metadata;
+  if (added) {
+    delegate_->ServiceAdded(service_name, service);
+  } else {
+    delegate_->ServiceUpdated(service_name, service);
+  }
+}
+
+}  // namespace extensions