[Media Router] Add DialMediaSinkService and DeviceDescriptionService

chrome/browser/media/router/dial_media_sink_service.cc

Index: chrome/browser/media/router/dial_media_sink_service.cc
diff --git a/chrome/browser/media/router/dial_media_sink_service.cc b/chrome/browser/media/router/dial_media_sink_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..7a249690e5f1ab4c0ed9b433a1b148f1612b3b8f
--- /dev/null
+++ b/chrome/browser/media/router/dial_media_sink_service.cc
@@ -0,0 +1,185 @@
+// Copyright 2017 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/media/router/dial_media_sink_service.h"
+
+#include "chrome/browser/extensions/api/dial/device_description_fetcher.h"
+#include "chrome/browser/extensions/api/dial/dial_api.h"
+#include "chrome/browser/extensions/api/dial/dial_api_factory.h"
+#include "chrome/browser/extensions/api/dial/dial_device_data.h"
+#include "chrome/browser/media/router/media_sinks_observer.h"
+#include "chrome/browser/media/router/mojo/media_router_mojo_impl.h"
+#include "chrome/browser/profiles/profile.h"
+#include "content/public/browser/browser_thread.h"
+
+using base::Time;
+using base::TimeDelta;
+using content::BrowserThread;
+
+namespace {
+// The maximum time a response is expected after a M-SEARCH request.
+const int kDialResponseTimeoutSecs = 2;
+}
+
+namespace media_router {
+
+DialMediaSinkService::DialMediaSinkService(
+    const OnSinksDiscoveredCallback& callback,
+    content::BrowserContext* browser_context)
+    : MediaSinkService(callback),
+      dial_registry_(nullptr),
+      browser_context_(browser_context),
+      network_disconnected_(false) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  auto* profile = Profile::FromBrowserContext(browser_context_);
+  dial_api_ =
+      extensions::DialAPIFactory::GetInstance()->GetForBrowserContext(profile);
+  request_context_ = profile->GetRequestContext();
+
+  DCHECK(request_context_);
+}
+
+DialMediaSinkService::~DialMediaSinkService() {
+  if (!dial_registry_)
+    return;
+
+  content::BrowserThread::PostTask(
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(&DialRegistry::UnregisterObserver,
+                 base::Unretained(dial_registry_), this));
+}
+
+void DialMediaSinkService::Start() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  dial_registry()->RegisterObserver(this);
+}
+
+void DialMediaSinkService::AddSinkQuery(MediaSinksObserver* observer) {
+  NOTIMPLEMENTED();
+}
+
+void DialMediaSinkService::RemoveSinkQuery(MediaSinksObserver* observer) {
+  NOTIMPLEMENTED();
+}
+
+DialMediaSinkService::DialRegistry* DialMediaSinkService::dial_registry() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(dial_api_);
+
+  dial_registry_ = dial_api_->dial_registry();
+  return dial_registry_;
+}
+
+DeviceDescriptionService* DialMediaSinkService::description_service() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (!description_service_.get()) {
+    description_service_.reset(new DeviceDescriptionService(this));
+  }
+  return description_service_.get();
+}
+
+DialMediaSinkCacheService* DialMediaSinkService::cache_service() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (!cache_service_.get()) {
+    cache_service_.reset(new DialMediaSinkCacheService());
+  }
+  return cache_service_.get();
+}
+
+void DialMediaSinkService::OnDialDeviceEvent(
+    const DialRegistry::DeviceList& devices) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DVLOG(2) << "DialMediaSinkService::OnDialDeviceEvent found " << devices.size()
+           << " devices";
+
+  std::set<std::string> device_labels;
+  for (const auto& device : devices)
+    device_labels.insert(device.label());
+
+  // Abort previous resolution. Always follow the latest device list.
+  for (const auto& pending_label : pending_device_labels_) {
+    if (device_labels.find(pending_label) == device_labels.end())
+      description_service()->MayStopDeviceDescriptionFetching(pending_label);
+  }
+
+  pending_device_labels_ = device_labels;
+
+  // Add a finish timer.
+  base::TimeDelta finish_delay =
+      TimeDelta::FromSeconds(kDialResponseTimeoutSecs) * devices.size();
+  finish_timer_.Start(FROM_HERE, finish_delay, this,
+                      &DialMediaSinkService::FetchCompleted);
+
+  for (const auto& device : devices) {
+    DialDeviceDescription description;
+    if (description_service()->GetDeviceDescription(device, request_context_,
+                                                    &description)) {
+      // Get device description from cache.
+      OnDeviceDescriptionAvailable(device.label(), description);
+    }
+  }
+}
+
+void DialMediaSinkService::OnDialError(DialRegistry::DialErrorCode type) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DVLOG(2) << "OnDialError [DialErrorCode]: " << static_cast<int>(type);
+}
+
+void DialMediaSinkService::OnDeviceDescriptionAvailable(
+    const std::string& device_id,
+    const DialDeviceDescription& description) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  cache_service()->AddOrUpdateSink(description);
+}
+
+void DialMediaSinkService::OnDeviceDescriptionFetchError(
+    const std::string& device_label,
+    const std::string& error_message) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DVLOG(2) << "OnDescriptionFetchesError [message]: " << error_message;
+}
+
+void DialMediaSinkService::FetchCompleted() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(!sink_discovery_callback_.is_null());
+
+  auto sinks = cache_service()->GetAliveSinks();
+  if (!IsDifferent(sinks, mrp_sinks_))
+    return;
+
+  sink_discovery_callback_.Run(sinks);
+  mrp_sinks_ = sinks;
+
+  cache_service()->PruneInactiveSinks(network_disconnected_,
+                                      description_service(), request_context_);
+  finish_timer_.Stop();
+}
+
+bool DialMediaSinkService::IsDifferent(
+    const std::vector<MediaSinkInternal> new_sinks,
+    const std::vector<MediaSinkInternal> old_sinks) {
+  std::map<std::string, const MediaSinkInternal*> old_sink_map;
+  for (auto& sink : old_sinks)
+    old_sink_map.insert(std::make_pair(sink.sink().id(), &sink));
+
+  std::vector<const MediaSinkInternal*> added;
+  std::vector<const MediaSinkInternal*> updated;
+
+  for (auto& sink : new_sinks) {
+    const auto& old_sink_it = old_sink_map.find(sink.sink().id());
+    // If |sink| does not exist in |old_sinks|.
+    if (old_sink_it == old_sink_map.end()) {
+      added.push_back(&sink);
+    } else {
+      if (sink != *(old_sink_it->second))
+        updated.push_back(&sink);
+
+      old_sink_map.erase(old_sink_it);
+    }
+  }
+
+  return !added.empty() || !old_sink_map.empty() || !updated.empty();
+}
+
+}  // namespace media_router