[Media Router] Design MediaRouter interface with stub implementation.

chrome/browser/media/router/media_router_impl.cc

Index: chrome/browser/media/router/media_router_impl.cc
diff --git a/chrome/browser/media/router/media_router_impl.cc b/chrome/browser/media/router/media_router_impl.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ea94541b3474a1cd5c2f7b3b882f1678c36c8b58
--- /dev/null
+++ b/chrome/browser/media/router/media_router_impl.cc
@@ -0,0 +1,114 @@
+// Copyright 2015 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/media_router_impl.h"
+
+#include <set>
+
+#include "base/bind.h"
+#include "base/logging.h"
+#include "base/stl_util.h"
+#include "chrome/browser/media/router/media_route.h"
+#include "chrome/browser/media/router/media_routes_observer.h"
+#include "chrome/browser/media/router/media_sink.h"
+#include "chrome/browser/media/router/media_sinks_observer.h"
+#include "chrome/browser/media/router/media_source.h"
+#include "chrome/browser/media/router/media_source_helper.h"
+
+namespace media_router {
+
+MediaRouterImpl::MediaRouterImpl() : mrpm_host_(nullptr) {}
+
+MediaRouterImpl::~MediaRouterImpl() {}
+
+void MediaRouterImpl::Initialize(MediaRouteProviderManagerHost* mrpm_host) {
+  DCHECK(!mrpm_host_);
+  DCHECK(mrpm_host);
+  mrpm_host_ = mrpm_host;
+}
+
+// TODO(imcheng): Implement NOTIMPLEMENTED() methods.
+bool MediaRouterImpl::RegisterMediaSinksObserver(
+    MediaSinksObserver* observer) {
+  NOTIMPLEMENTED();
+  // TODO(imcheng): Set registered_ bit on |observer| to true on success.
+  return false;
+}
+
+void MediaRouterImpl::UnregisterMediaSinksObserver(
+    MediaSinksObserver* observer) {
+  NOTIMPLEMENTED();
+  observer->registered_ = false;

[xhwang, 2015/04/02 17:13:02]

This doesn't look good. Why can't we return a bool so the caller of 
UnregisterMediaSinksObserver() can do this?

[imcheng, 2015/04/02 23:05:24]

The point of this is to make sure the caller is calling this function. If
UnregisterMediaSinksObserver is never called, there would be a dangling pointer
in MediaRouterImpl when the observer is destroyed.

[xhwang, 2015/04/06 20:51:30]

Having one class checking the internal state of another class seems bad.

Can a weak pointer solve the problem you are trying solve?

https://code.google.com/p/chromium/codesearch#chromium/src/base/memory/weak_p...

[imcheng, 2015/04/06 21:54:20]

No, we don't want to use a weak pointer here. Adding the weak ptr property to
the observers' base classes forces all implementations to have the weak ptr
property as well. Also using weak pointer here only shadows the problem we're
trying to detect and will require extra mechanism to clean up those WeakPtrs.

+}
+
+void MediaRouterImpl::PostMessage(
+    const MediaRouteId& route_id,
+    const std::string& message) {
+  NOTIMPLEMENTED();
+}
+
+void MediaRouterImpl::OnMessage(const MediaRouteId& route_id,
+                                const std::string& message) {
+  NOTIMPLEMENTED();
+}
+
+void MediaRouterImpl::OnSinksReceived(
+    const MediaSource& source,
+    const std::vector<MediaSink>& sinks) {
+  NOTIMPLEMENTED();
+}
+
+RouteRequestId MediaRouterImpl::StartRouteRequest(
+    const MediaSource& source,
+    const MediaSinkId& sink_id,
+    const MediaRouteResponseCallback& callback) {
+  NOTIMPLEMENTED();
+  return kInvalidRouteRequestId;
+}
+
+void MediaRouterImpl::CloseRoute(const MediaRouteId& route_id) {
+  NOTIMPLEMENTED();
+}
+
+void MediaRouterImpl::UnregisterMediaRouteResponseCallback(
+    const RouteRequestId& request_id) {
+  NOTIMPLEMENTED();
+}
+
+bool MediaRouterImpl::RegisterMediaRoutesObserver(
+    MediaRoutesObserver* observer) {
+  NOTIMPLEMENTED();
+  // TODO(imcheng): Set registered_ bit on |observer| to true on success.
+  return false;
+}
+
+void MediaRouterImpl::UnregisterMediaRoutesObserver(
+    MediaRoutesObserver* observer) {
+  NOTIMPLEMENTED();
+  observer->registered_ = false;
+}
+
+void MediaRouterImpl::OnRouteResponseReceived(
+    const RouteRequestId& request_id,
+    const MediaRoute& route) {
+  NOTIMPLEMENTED();
+}
+
+void MediaRouterImpl::OnRouteResponseError(const RouteRequestId& request_id,
+                                           const std::string& error_text) {
+  NOTIMPLEMENTED();
+}
+
+void MediaRouterImpl::OnRoutesUpdated(
+    const std::vector<MediaRoute>& routes,
+    const std::vector<MediaSink>& sinks) {
+  NOTIMPLEMENTED();
+}
+
+void MediaRouterImpl::OnHostDestroyed(MediaRouteProviderManagerHost* host) {
+  DCHECK(host == mrpm_host_);
+  mrpm_host_ = nullptr;
+}
+
+}  // namespace media_router