[Media Router] Add DialMediaSinkService and DeviceDescriptionService

chrome/browser/media/router/discovery/dial/dial_media_sink_service.cc

+// 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/discovery/dial/dial_media_sink_service.h"
+
+#include "chrome/browser/media/router/discovery/dial/dial_device_data.h"
+#include "chrome/browser/media/router/discovery/dial/dial_media_sink_cache_service.h"
+#include "chrome/browser/profiles/profile.h"
+#include "content/public/browser/browser_thread.h"
+
+using content::BrowserThread;
+
+namespace {
+// The maximum time a response is expected after a M-SEARCH request.

[mark a. foltz, 2017/04/12 00:17:18]

Can you say a bit about why this particular value was chosen?

[zhaobin, 2017/04/18 06:58:27]

It is picked at random and needs to be revised. (I will close MR dialog if it
keeps spinning for more than 3 seconds...)

+const int kDialResponseTimeoutSecs = 5;
+}
+
+namespace media_router {
+
+DialMediaSinkService::DialMediaSinkService(
+    const OnSinksDiscoveredCallback& callback,
+    content::BrowserContext* browser_context)
+    : MediaSinkService(callback),
+      network_disconnected_(false),
+      browser_context_(browser_context) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  auto* profile = Profile::FromBrowserContext(browser_context_);
+  request_context_ = profile->GetRequestContext();
+
+  DCHECK(request_context_);
+}
+
+DialMediaSinkService::~DialMediaSinkService() {}
+
+void DialMediaSinkService::Start() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  dial_registry()->RegisterObserver(this);
+  dial_registry()->DiscoverNow();
+}
+
+void DialMediaSinkService::Stop() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  dial_registry()->UnregisterObserver(this);
+}
+
+void DialMediaSinkService::AddSinkQuery(MediaSinksObserver* observer) {
+  NOTIMPLEMENTED();

[mark a. foltz, 2017/04/12 00:17:18]

Does this need a TODO to go back and implement this?

[zhaobin, 2017/04/18 06:58:27]

Done.

+}
+
+void DialMediaSinkService::RemoveSinkQuery(MediaSinksObserver* observer) {
+  NOTIMPLEMENTED();

[mark a. foltz, 2017/04/12 00:17:18]

Ditto

[zhaobin, 2017/04/18 06:58:27]

Done.

+}
+
+DialRegistry* DialMediaSinkService::dial_registry() {

[mark a. foltz, 2017/04/12 00:17:18]

I'm not sure this method adds much.  Is it overridden in unit tests?

[zhaobin, 2017/04/18 06:58:27]

Yes, for unit tests.

+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  return DialRegistry::GetInstance();
+}
+
+DeviceDescriptionService* DialMediaSinkService::description_service() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (!description_service_.get()) {
+    description_service_.reset(new DeviceDescriptionService(
+        base::Bind(&DialMediaSinkCacheService::MayAddOrUpdateSink,
+                   base::Unretained(cache_service())),
+        base::Bind(&DialMediaSinkService::OnDeviceDescriptionError,
+                   base::Unretained(this))));
+  }
+  return description_service_.get();
+}
+
+DialMediaSinkCacheService* DialMediaSinkService::cache_service() {

[mark a. foltz, 2017/04/12 00:17:18]

If this is creating the cache service on demand, it should be named
GetCacheService() and document that it does so, since it isn't a simple getter.

[zhaobin, 2017/04/18 06:58:27]

Done.

+  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";
+
+  network_disconnected_ = false;

[imcheng, 2017/04/12 19:33:51]

This field doesn't seem to be used.

[zhaobin, 2017/04/18 06:58:27]

Code removed.

+
+  // Add a finish timer.
+  base::TimeDelta finish_delay =
+      base::TimeDelta::FromSeconds(kDialResponseTimeoutSecs);
+  finish_timer_.Start(FROM_HERE, finish_delay, this,
+                      &DialMediaSinkService::FetchCompleted);
+
+  description_service()->GetDeviceDescriptions(devices, request_context_);

[mark a. foltz, 2017/04/12 00:17:18]

What happens to device descriptions fetched after finish_timer_ fires?

[zhaobin, 2017/04/18 06:58:27]

They go into CacheService, and will be returned in next FetchCompleted() if they
are still alive by then.

Start the timer again for such descriptions...

+}
+
+void DialMediaSinkService::OnDialError(DialRegistry::DialErrorCode type) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DVLOG(2) << "OnDialError [DialErrorCode]: " << static_cast<int>(type);
+
+  if (type == DialRegistry::DIAL_NETWORK_DISCONNECTED)
+    network_disconnected_ = true;
+}
+
+void DialMediaSinkService::OnDeviceDescriptionError(
+    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());
+
+  finish_timer_.Stop();
+
+  auto sinks = cache_service()->GetAliveSinks();
+  if (!IsDifferent(sinks, mrp_sinks_)) {

[mark a. foltz, 2017/04/12 00:17:18]

Can this just be !(sinks == mrp_sinks_), if we enforce that |sinks| is sorted in
a deterministic order by unique_id?

[zhaobin, 2017/04/18 06:58:27]

Done.

+    DVLOG(2) << "No update to sink list.";
+    return;
+  }
+
+  DVLOG(2) << "Send sinks to media router, [size]: " << sinks.size();
+  sink_discovery_callback_.Run(sinks);
+  mrp_sinks_ = sinks;
+}
+
+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);
+      continue;
+    }
+
+    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