Add Media Router Mojo impl code.

chrome/browser/media/router/media_router_mojo_impl.h

Index: chrome/browser/media/router/media_router_mojo_impl.h
diff --git a/chrome/browser/media/router/media_router_mojo_impl.h b/chrome/browser/media/router/media_router_mojo_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..c2359e9268ea449deb27dfd14bf3558e802503b2
--- /dev/null
+++ b/chrome/browser/media/router/media_router_mojo_impl.h
@@ -0,0 +1,181 @@
+// 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.
+
+#ifndef CHROME_BROWSER_MEDIA_ROUTER_MEDIA_ROUTER_MOJO_IMPL_H_
+#define CHROME_BROWSER_MEDIA_ROUTER_MEDIA_ROUTER_MOJO_IMPL_H_
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "base/containers/hash_tables.h"
+#include "base/containers/scoped_ptr_hash_map.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+#include "base/message_loop/message_loop_proxy.h"
+#include "base/observer_list.h"
+#include "base/threading/thread_checker.h"
+#include "chrome/browser/media/router/issue.h"
+#include "chrome/browser/media/router/media_router.h"
+#include "chrome/browser/media/router/media_router.mojom.h"
+#include "components/keyed_service/core/keyed_service.h"
+
+namespace content {
+class BrowserContext;
+}  // namespace content
+
+namespace extensions {
+class EventPageTracker;
+}  // namespace extensions
+
+namespace media_router {
+
+class IssuesObserver;

[imcheng (use chromium acct), 2015/05/14 23:00:44]

these fwd declarations not needed?

[Kevin Marshall, 2015/05/14 23:04:57]

Done.

+class MediaRouterMojoTest;
+
+// Implementation of the Mojo-based service which bridges the Media Router
+// Provider Manager and the Media Router.
+class MediaRouterMojoImpl : public MediaRouter,
+                            public interfaces::MediaRouterObserver,
+                            public mojo::ErrorHandler,
+                            public KeyedService {
+ public:
+  ~MediaRouterMojoImpl() override;
+
+  // Binds the MediaRouterMojoImpl BrowserContext service to a Mojo request.
+  // Called by the Mojo module registry.
+  // |extension_id|: The ID of the component extension, used for querying
+  //     suspension state.
+  // |context|: The BrowserContext which owns the extension process.
+  // |request|: The Mojo connection request used for binding.
+  static void BindToRequest(
+      const std::string& extension_id,
+      content::BrowserContext* context,
+      mojo::InterfaceRequest<interfaces::MediaRouterObserver> request);
+
+  // mojo::ErrorHandler
+  void OnConnectionError() override;
+
+  // interfaces::MediaRouter implementation.
+  // Registers a Mojo MediaRouter proxy object from the extension.
+  void ProvideMediaRouter(
+      interfaces::MediaRouterPtr media_router_ptr,
+      const interfaces::MediaRouterObserver::ProvideMediaRouterCallback&
+          callback) override;
+  void OnMessage(const mojo::String& route_id,
+                 const mojo::String& message) override;
+  void OnIssue(interfaces::IssuePtr issue) override;
+  void OnSinksReceived(const mojo::String& media_source,
+                       mojo::Array<interfaces::MediaSinkPtr> sinks) override;
+  void OnRoutesUpdated(mojo::Array<interfaces::MediaRoutePtr> routes) override;
+
+  // MediaRouter implementation.
+  // For messages sent to the extension.
+  // Execution of the requests is delegated to the Do* methods, which can be
+  // enqueued for later use if the extension is temporarily suspended.
+  void CreateRoute(const MediaSourceId& source_id,
+                   const MediaSinkId& sink_id,
+                   const MediaRouteResponseCallback& callback) override;
+  void CloseRoute(const MediaRouteId& route_id) override;
+  void PostMessage(const MediaRouteId& route_id,
+                   const std::string& message) override;
+  void ClearIssue(const Issue::IssueId& issue_id) override;
+  // These methods send messages to the extension upon first registration
+  // and last unregistration.
+  bool RegisterMediaSinksObserver(MediaSinksObserver* observer) override;
+  void UnregisterMediaSinksObserver(MediaSinksObserver* observer) override;
+  bool RegisterMediaRoutesObserver(MediaRoutesObserver* observer) override;
+  void UnregisterMediaRoutesObserver(MediaRoutesObserver* observer) override;
+  void AddIssuesObserver(IssuesObserver* observer) override;
+  void RemoveIssuesObserver(IssuesObserver* observer) override;
+
+ private:
+  friend class MediaRouterMojoImplFactory;
+  friend class MediaRouterMojoTest;
+
+  FRIEND_TEST_ALL_PREFIXES(MediaRouterMojoExtensionTest,
+                           DeferredBindingAndSuspension);
+
+  // New instances should be constructed through
+  // MediaRouterMojoImplFactory::GetApiForBrowserContext.
+  MediaRouterMojoImpl();
+
+  // Used for testing.
+  MediaRouterMojoImpl(
+      const std::string& mojo_media_router_ext_id,
+      extensions::EventPageTracker* event_page_tracker_for_test);
+
+  // Binds |this| to a Mojo interface request, so that clients can acquire a
+  // handle to a MediaRouterMojoImpl instance via the Mojo service connector.
+  void Bind(mojo::InterfaceRequest<interfaces::MediaRouterObserver> request);
+
+  // Enqueues a closure for later execution by ExecutePendingRequests().
+  void EnqueueTask(const base::Closure& closure);
+
+  // Starts monitoring the suspend state of |extension_id|.
+  void MonitorExtension(const std::string& extension_id,
+                        content::BrowserContext* context);
+
+  // Runs a closure if the extension monitored by |extension_monitor_| is
+  // active, or defers it for later execution if the extension is suspended.
+  void RunOrDefer(const base::Closure& request_cb);
+
+  // Runs pending requests in |pending_requests_|.
+  inline void ExecutePendingRequests();
+
+  // These calls invoke methods in the MRPM via Mojo.
+  void DoCreateRoute(const MediaSourceId& source_id,
+                     const MediaSinkId& sink_id,
+                     const MediaRouteResponseCallback& callback);
+  void DoCloseRoute(const MediaRouteId& route_id);
+  void DoPostMessage(const MediaRouteId& route_id, const std::string& message);
+  void DoClearIssue(const Issue::IssueId& issue_id);
+  void DoStartObservingMediaSinks(const std::string& source_id);
+  void DoStopObservingMediaSinks(const std::string& source_id);
+  void DoStartObservingMediaRoutes();
+  void DoStopObservingMediaRoutes();
+  void DoStartObservingIssues();
+  void DoStopObservingIssues();
+
+  // Pending requests queued to be executed once MRPM becomes ready.
+  std::vector<base::Closure> pending_requests_;
+
+  // Multimap of sinks observer objects, keyed by media source ID.
+  base::ScopedPtrHashMap<MediaSourceId,
+                         scoped_ptr<ObserverList<MediaSinksObserver>>>
+      sinks_observers_;
+
+  // List of route observer objects.
+  ObserverList<MediaRoutesObserver> routes_observers_;
+
+  // Binds |this| to a Mojo MediaRouterObserver interface.
+  // The binding is released when binding_ is deleted.
+  scoped_ptr<mojo::Binding<interfaces::MediaRouterObserver>> binding_;
+
+  // Mojo proxy object for the Provider Manager.
+  interfaces::MediaRouterPtr mojo_media_router_;
+
+  // ID of the component extension. Used for managing its suspend/wake state
+  // via event_page_tracker_.
+  std::string mojo_media_router_extension_id_;
+
+  // Provides querying and waking functionality for the component extension's
+  // suspend state.
+  extensions::EventPageTracker* event_page_tracker_;
+
+  // GUID of this object's instance.
+  // Used by the component extension to determine if its persistent cache
+  // is stale.
+  std::string instance_id_;
+
+  base::ThreadChecker thread_checker_;
+
+  DISALLOW_COPY_AND_ASSIGN(MediaRouterMojoImpl);
+};
+
+}  // namespace media_router
+
+#endif  // CHROME_BROWSER_MEDIA_ROUTER_MEDIA_ROUTER_MOJO_IMPL_H_