[Presentation API] Change ListenForSessionMessages API to client-style.

chrome/browser/media/router/media_router_mojo_impl.h

 // 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>
@@ skipping 54 matching lines @@
   void JoinRoute(
       const MediaSource::Id& source_id,
       const std::string& presentation_id,
       const GURL& origin,
       int tab_id,
       const std::vector<MediaRouteResponseCallback>& callbacks) override;
   void CloseRoute(const MediaRoute::Id& route_id) override;
   void SendRouteMessage(const MediaRoute::Id& route_id,
                         const std::string& message,
                         const SendRouteMessageCallback& callback) override;
-  void ListenForRouteMessages(
-      const std::vector<MediaRoute::Id>& route_ids,
-      const PresentationSessionMessageCallback& message_cb) override;
   void ClearIssue(const Issue::Id& issue_id) override;
-  void RegisterMediaSinksObserver(MediaSinksObserver* observer) override;
-  void UnregisterMediaSinksObserver(MediaSinksObserver* observer) override;
-  void RegisterMediaRoutesObserver(MediaRoutesObserver* observer) override;
-  void UnregisterMediaRoutesObserver(MediaRoutesObserver* observer) override;
-  void RegisterIssuesObserver(IssuesObserver* observer) override;
-  void UnregisterIssuesObserver(IssuesObserver* observer) override;
 
   const std::string& media_route_provider_extension_id() const {
     return media_route_provider_extension_id_;
   }
 
   void set_instance_id_for_test(const std::string& instance_id) {
     instance_id_ = instance_id;
   }
 
  private:
   friend class MediaRouterFactory;
   friend class MediaRouterMojoTest;
 
+  FRIEND_TEST_ALL_PREFIXES(MediaRouterMojoImplTest,
+                           RegisterAndUnregisterMediaSinksObserver);
+  FRIEND_TEST_ALL_PREFIXES(MediaRouterMojoImplTest,
+                           RegisterAndUnregisterMediaRoutesObserver);
   FRIEND_TEST_ALL_PREFIXES(MediaRouterMojoExtensionTest,
                            DeferredBindingAndSuspension);
 
   // Standard constructor, used by
   // MediaRouterMojoImplFactory::GetApiForBrowserContext.
   explicit MediaRouterMojoImpl(
       extensions::EventPageTracker* event_page_tracker);
 
   // Binds |this| to a Mojo interface request, so that clients can acquire a
   // handle to a MediaRouterMojoImpl instance via the Mojo service connector.
   // Stores the |extension_id| of the component extension.
   void BindToMojoRequest(
       mojo::InterfaceRequest<interfaces::MediaRouter> request,
       const std::string& extension_id);
 
   // Enqueues a closure for later execution by ExecutePendingRequests().
   void EnqueueTask(const base::Closure& closure);
 
   // 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);
 
   // Dispatches the Mojo requests queued in |pending_requests_|.
   void ExecutePendingRequests();
 
+  // MediaRouter implementation.
+  void RegisterMediaSinksObserver(MediaSinksObserver* observer) override;
+  void UnregisterMediaSinksObserver(MediaSinksObserver* observer) override;
+  void RegisterMediaRoutesObserver(MediaRoutesObserver* observer) override;
+  void UnregisterMediaRoutesObserver(MediaRoutesObserver* observer) override;
+  void RegisterIssuesObserver(IssuesObserver* observer) override;
+  void UnregisterIssuesObserver(IssuesObserver* observer) override;
+  void RegisterPresentationSessionMessagesObserver(
+      PresentationSessionMessagesObserver* observer) override;
+  void UnregisterPresentationSessionMessagesObserver(
+      PresentationSessionMessagesObserver* observer) override;
+
   // These calls invoke methods in the component extension via Mojo.
   void DoCreateRoute(const MediaSource::Id& source_id,
                      const MediaSink::Id& sink_id,
                      const std::string& origin,
                      int tab_id,
                      const std::vector<MediaRouteResponseCallback>& callbacks);
   void DoJoinRoute(const MediaSource::Id& source_id,
                    const std::string& presentation_id,
                    const std::string& origin,
                    int tab_id,
                    const std::vector<MediaRouteResponseCallback>& callbacks);
   void DoCloseRoute(const MediaRoute::Id& route_id);
   void DoSendSessionMessage(const MediaRoute::Id& route_id,
                             const std::string& message,
                             const SendRouteMessageCallback& callback);
-  void DoListenForRouteMessages(
-      const std::vector<MediaRoute::Id>& route_ids,
-      const PresentationSessionMessageCallback& message_cb);
+  void DoListenForRouteMessages(const MediaRoute::Id& route_id);
   void DoClearIssue(const Issue::Id& issue_id);
   void DoStartObservingMediaSinks(const MediaSource::Id& source_id);
   void DoStopObservingMediaSinks(const MediaSource::Id& source_id);
   void DoStartObservingMediaRoutes();
   void DoStopObservingMediaRoutes();
   void DoStartObservingIssues();
   void DoStopObservingIssues();
 
   // Invoked when the next batch of messages arrives.
+  // |route_id|: ID of route of the messages.
   // |messages|: A list of messages received.
-  // |message_cb|: The callback to invoke to pass on the messages received.
-  void OnRouteMessageReceived(
-      const PresentationSessionMessageCallback& message_cb,
+  void OnRouteMessagesReceived(
+      const MediaRoute::Id& route_id,
       mojo::Array<interfaces::RouteMessagePtr> messages);
 
   // Error handler callback for |binding_| and |media_route_provider_|.
   void OnConnectionError();
 
   // interfaces::MediaRouter implementation.
   void RegisterMediaRouteProvider(
       interfaces::MediaRouteProviderPtr media_route_provider_ptr,
       const interfaces::MediaRouter::RegisterMediaRouteProviderCallback&
           callback) 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;
 
   // Pending requests queued to be executed once component extension
   // becomes ready.
   std::vector<base::Closure> pending_requests_;
 
   base::ScopedPtrHashMap<MediaSource::Id,
                          scoped_ptr<base::ObserverList<MediaSinksObserver>>>
       sinks_observers_;
 
   base::ObserverList<MediaRoutesObserver> routes_observers_;
 
+  base::ScopedPtrHashMap<
+      MediaRoute::Id,
+      scoped_ptr<base::ObserverList<PresentationSessionMessagesObserver>>>
+      messages_observers_;
+  // IDs of MediaRoutes being listened for messages. Note that this is
+  // different from |message_observers_| because we might be waiting for
+  // |OnRouteMessagesReceived()| to be invoked after all observers for that

[haibinlu, 2015/07/30 23:59:11]

if all observers for the route message have been removed, we should stop listen
for messages of this route. Without observers, sending messages from extension
to MR is bad. Shall we add a StopListenForMessage method too? 

[imcheng, 2015/08/03 18:56:33]

Currently we stop listening when we see there are no more observers when
messages from the extension arrive. It would be ideal to introduce a
StopListenForMessage so it would work better in the corner cases. Shall we do
this in a future patch after the extension side of StopListenForMessage is
implemented?

+  // route have been removed.
+  base::hash_set<MediaRoute::Id> listening_messages_for_routes_;
+
   // Binds |this| to a Mojo connection stub for interfaces::MediaRouter.
   scoped_ptr<mojo::Binding<interfaces::MediaRouter>> binding_;
 
   // Mojo proxy object for the Media Route Provider Manager.
   // Set to null initially, and later set to the Provider Manager proxy object
   // passed in via |RegisterMediaRouteProvider()|.
   // This is set to null again when the component extension is suspended
   // if or a Mojo channel error occured.
   interfaces::MediaRouteProviderPtr media_route_provider_;
 
@@ skipping 12 matching lines @@
   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_