Upstreaming review for Media Router Mojo interface.

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..8b418ff15ae24ea983a85816069c081bf8378716
--- /dev/null
+++ b/chrome/browser/media/router/media_router_mojo_impl.h
@@ -0,0 +1,167 @@
+// Copyright 2014 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/macros.h"
+#include "base/memory/linked_ptr.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;
+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();
+
+  ~MediaRouterMojoImpl() override;
+
+  // Binds the MediaRouterMojoImpl BrowserContext service to a Mojo request.
+  // |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.
+  // For incoming messages from the extension.
+  void ProvideMediaRouter(
+      interfaces::MediaRouterPtr mrpm,
+      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;
+  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 MediaRouterMojoTest;
+
+  // Used for testing.
+  MediaRouterMojoImpl(
+      const std::string& mrpm_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_|.
+  void ExecutePendingRequests();
+
+  // Pending requests queued to be executed once MRPM becomes ready.
+  std::vector<base::Closure> pending_requests_;
+
+  // 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();
+
+  std::map<std::string, linked_ptr<ObserverList<MediaSinksObserver>>>
+      sinks_observers_;
+
+  ObserverList<MediaRoutesObserver> routes_observers_;
+
+  // RAII binding of |this| to an MediaRouterMojo interface request.
+  // The binding is removed when binding_ is cleared or |this| is deleted.
+  scoped_ptr<mojo::Binding<interfaces::MediaRouterObserver>> binding_;
+
+  interfaces::MediaRouterPtr mrpm_;
+
+  // ID of the MRPM extension. Used for managing its suspend/wake state
+  // via event_page_tracker_.
+  std::string mrpm_extension_id_;
+
+  // Provides querying and waking functionality for an extension's suspend
+  // state.
+  extensions::EventPageTracker* event_page_tracker_;
+
+  base::ThreadChecker thread_checker_;
+
+  // GUID of this object's instance.
+  // Used by the MRPM to determine if the localStorage state is stale.
+  std::string instance_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(MediaRouterMojoImpl);
+};
+
+}  // namespace media_router
+
+#endif  // CHROME_BROWSER_MEDIA_ROUTER_MEDIA_ROUTER_MOJO_IMPL_H_