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

chrome/browser/media/router/media_router.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_H_
 #define CHROME_BROWSER_MEDIA_ROUTER_MEDIA_ROUTER_H_
 
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "chrome/browser/media/router/issue.h"
 #include "chrome/browser/media/router/media_route.h"
 #include "chrome/browser/media/router/media_sink.h"
 #include "chrome/browser/media/router/media_source.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "content/public/browser/presentation_session_message.h"
 
 namespace media_router {
 
 class IssuesObserver;
 class MediaRoutesObserver;
 class MediaSinksObserver;
+class PresentationSessionMessagesObserver;
 
 // Type of callback used in |CreateRoute()|. Callback is invoked when the
 // route request either succeeded or failed.
-// The first argument is the route created. If the route request failed, this
+// |route|: The route created. If the route request failed, this
 // will be a nullptr.
-// The second argument is the error string, which will be nonempty if the route
-// request failed.
+// |presentation_id|: The presentation ID of the route created, or empty string

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

make it clear that this is MR generated unique ID.

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

Done.

+// if request failed.
+// |error|: nonempty if the route request failed.
 using MediaRouteResponseCallback =
-    base::Callback<void(const MediaRoute*, const std::string&)>;
+    base::Callback<void(const MediaRoute* route,
+                        const std::string& presentation_id,
+                        const std::string& error)>;
 
 // Used in cases where a tab ID is not applicable in CreateRoute/JoinRoute.
 const int kInvalidTabId = -1;
 
 // An interface for handling resources related to media routing.
 // Responsible for registering observers for receiving sink availability
 // updates, handling route requests/responses, and operating on routes (e.g.
 // posting messages or closing).
 class MediaRouter : public KeyedService {
  public:
@@ skipping 38 matching lines @@
   // Closes the media route specified by |route_id|.
   virtual void CloseRoute(const MediaRoute::Id& route_id) = 0;
 
   // Posts |message| to a MediaSink connected via MediaRoute with |route_id|.
   // TODO(imcheng): Support additional data types: Blob, ArrayBuffer,
   // ArrayBufferView.
   virtual void SendRouteMessage(const MediaRoute::Id& route_id,
                                 const std::string& message,
                                 const SendRouteMessageCallback& callback) = 0;
 
-  // Gets the next batch of messages from one of the routes in |route_ids|.
-  // |message_cb|: Invoked with a non-empty list of messages when there are
-  //      messages, an empty list when messaging channel had error.
-  //      It is not invoked until there are messages available or error.
-  virtual void ListenForRouteMessages(
-      const std::vector<MediaRoute::Id>& route_ids,
-      const PresentationSessionMessageCallback& message_cb) = 0;
-
   // Clears the issue with the id |issue_id|.
   virtual void ClearIssue(const Issue::Id& issue_id) = 0;
 
  private:
   friend class IssuesObserver;
   friend class MediaSinksObserver;
   friend class MediaRoutesObserver;
+  friend class PresentationSessionMessagesObserver;
 
-  // The following functions are called by IssuesObserver, MediaSinksObserver,
-  // and MediaRoutesObserver.
+  // The following functions are called by friend Observer classes above.
 
   // Registers |observer| with this MediaRouter. |observer| specifies a media
   // source and will receive updates with media sinks that are compatible with
   // that source. The initial update may happen synchronously.
   // NOTE: This class does not assume ownership of |observer|. Callers must
   // manage |observer| and make sure |UnregisterObserver()| is called
   // before the observer is destroyed.
   // It is invalid to register the same observer more than once and will result
   // in undefined behavior.
   // If the MRPM Host is not available, the registration request will fail
   // immediately.
   virtual void RegisterMediaSinksObserver(MediaSinksObserver* observer) = 0;
 
   // Removes a previously added MediaSinksObserver. |observer| will stop
   // receiving further updates.
   virtual void UnregisterMediaSinksObserver(MediaSinksObserver* observer) = 0;
 
   // Adds a MediaRoutesObserver to listen for updates on MediaRoutes.
   // The initial update may happen synchronously.
-  // MediaRouter does not own |observer|. |RemoveMediaRoutesObserver| should
+  // MediaRouter does not own |observer|. |UnregisterMediaRoutesObserver| should
   // be called before |observer| is destroyed.
   // It is invalid to register the same observer more than once and will result
   // in undefined behavior.
   virtual void RegisterMediaRoutesObserver(MediaRoutesObserver* observer) = 0;
 
   // Removes a previously added MediaRoutesObserver. |observer| will stop
   // receiving further updates.
   virtual void UnregisterMediaRoutesObserver(MediaRoutesObserver* observer) = 0;
 
   // Adds the IssuesObserver |observer|.
   // It is invalid to register the same observer more than once and will result
   // in undefined behavior.
   virtual void RegisterIssuesObserver(IssuesObserver* observer) = 0;
 
   // Removes the IssuesObserver |observer|.
   virtual void UnregisterIssuesObserver(IssuesObserver* observer) = 0;
+
+  // Registers |observer| with this MediaRouter. |observer| specifies a media
+  // route corresponding to a presentation and will receive messages from the
+  // MediaSink connected to the route. Note that MediaRouter does not own
+  // |observer|. |observer| should be unregistered before it is destroyed.
+  // Registering the same observer more than once will result in undefined
+  // behavior.
+  virtual void RegisterPresentationSessionMessagesObserver(
+      PresentationSessionMessagesObserver* observer) = 0;
+
+  // Unregisters a previously registered PresentationSessionMessagesObserver.
+  // |observer| will stop receiving further updates.
+  virtual void UnregisterPresentationSessionMessagesObserver(
+      PresentationSessionMessagesObserver* observer) = 0;
 };
 
 }  // namespace media_router
 
 #endif  // CHROME_BROWSER_MEDIA_ROUTER_MEDIA_ROUTER_H_