[Media Router] Connection state change listening redesign part 2.

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 "base/callback_list.h"
 #include "base/memory/scoped_vector.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_service_delegate.h"
 #include "content/public/browser/presentation_session_message.h"
 
 namespace content {
 class WebContents;
 }
 
 namespace media_router {
 
 class IssuesObserver;
 class LocalMediaRoutesObserver;
@@ skipping 13 matching lines @@
 // |error|: Empty string.
 // On failure:
 // |route|: nullptr
 // |presentation_id|: Empty string.
 // |error|: Non-empty string describing the error.
 using MediaRouteResponseCallback =
     base::Callback<void(const MediaRoute* route,
                         const std::string& presentation_id,
                         const std::string& error)>;
 
+// Subscription object returned by calling
+// |AddPresentationConnectionStateChangedCallback|. See the method comments for
+// details.
+using PresentationConnectionStateSubscription = base::CallbackList<void(
+    content::PresentationConnectionState)>::Subscription;
+
 // 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:
   using PresentationSessionMessageCallback = base::Callback<void(
       scoped_ptr<ScopedVector<content::PresentationSessionMessage>>)>;
   using SendRouteMessageCallback = base::Callback<void(bool sent)>;
 
@@ skipping 54 matching lines @@
 
   // Indicates that a presentation session has detached from the underlying
   // MediaRoute |route_id| (due to navigation, garbage collection, etc.)
   virtual void OnPresentationSessionDetached(
       const MediaRoute::Id& route_id) = 0;
 
   // Returns whether or not there is currently an active local displayable
   // route.
   virtual bool HasLocalDisplayRoute() const = 0;
 
+  // Adds |callback| to listen for state changes for presentation connected to
+  // |route_id|. The returned Subscription object is owned by the caller.
+  // |callback| will be invoked whenever there are state changes, until the
+  // caller destroys the Subscription object.
+  virtual scoped_ptr<PresentationConnectionStateSubscription>
+  AddPresentationConnectionStateChangedCallback(
+      const MediaRoute::Id& route_id,
+      const content::PresentationConnectionStateChangedCallback& callback) = 0;
+
  private:
   friend class IssuesObserver;
   friend class LocalMediaRoutesObserver;
   friend class MediaSinksObserver;
   friend class MediaRoutesObserver;
   friend class PresentationConnectionStateObserver;
   friend class PresentationSessionMessagesObserver;
 
   // The following functions are called by friend Observer classes above.
 
@@ skipping 50 matching lines @@
       PresentationSessionMessagesObserver* observer) = 0;
 
   // Adds the LocalMediaRoutesObserver |observer| to listen for newly created
   // MediaRoutes.
   virtual void RegisterLocalMediaRoutesObserver(
       LocalMediaRoutesObserver* observer) = 0;
 
   // Removes the LocalMediaRoutesObserver |observer|.
   virtual void UnregisterLocalMediaRoutesObserver(
       LocalMediaRoutesObserver* observer) = 0;
-
-  // Registers/unregisters a PresentationConnectionStateObserver to receive
-  // updates on state changes for a PresentationConnection. MediaRouter does
-  // not own |observer|. When |observer| is about to be destroyed, it must be
-  // unregistered from MediaRouter.
-  virtual void RegisterPresentationConnectionStateObserver(
-      PresentationConnectionStateObserver* observer) = 0;
-  virtual void UnregisterPresentationConnectionStateObserver(
-      PresentationConnectionStateObserver* observer) = 0;
 };
 
 }  // namespace media_router
 
 #endif  // CHROME_BROWSER_MEDIA_ROUTER_MEDIA_ROUTER_H_