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

chrome/browser/media/router/presentation_service_delegate_impl.cc

 // 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.
 
 #include "chrome/browser/media/router/presentation_service_delegate_impl.h"
 
 #include <string>
 
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/containers/small_map.h"
 #include "base/guid.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/media/router/create_presentation_connection_request.h"
 #include "chrome/browser/media/router/media_route.h"
 #include "chrome/browser/media/router/media_router.h"
 #include "chrome/browser/media/router/media_router_dialog_controller.h"
 #include "chrome/browser/media/router/media_router_factory.h"
 #include "chrome/browser/media/router/media_sink.h"
 #include "chrome/browser/media/router/media_source_helper.h"
 #include "chrome/browser/media/router/presentation_media_sinks_observer.h"
 #include "chrome/browser/media/router/presentation_session_messages_observer.h"
-#include "chrome/browser/media/router/presentation_session_state_observer.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "content/public/browser/presentation_screen_availability_listener.h"
 #include "content/public/browser/presentation_session.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(
     media_router::PresentationServiceDelegateImpl);
 
 using content::RenderFrameHost;
@@ skipping 34 matching lines @@
   ~PresentationFrame();
 
   // Mirror corresponding APIs in PresentationServiceDelegateImpl.
   bool SetScreenAvailabilityListener(
       content::PresentationScreenAvailabilityListener* listener);
   bool RemoveScreenAvailabilityListener(
       content::PresentationScreenAvailabilityListener* listener);
   bool HasScreenAvailabilityListenerForTest(
       const MediaSource::Id& source_id) const;
   std::string GetDefaultPresentationId() const;
-  void ListenForSessionStateChange(
-      const content::SessionStateChangedCallback& state_changed_cb);
+  void ListenForConnectionStateChange(
+      const content::PresentationSessionInfo& connection,
+      const content::PresentationConnectionStateChangedCallback&
+          state_changed_cb);
   void ListenForSessionMessages(
       const content::PresentationSessionInfo& session,
       const content::PresentationSessionMessageCallback& message_cb);
 
   void Reset();
 
   const MediaRoute::Id GetRouteId(const std::string& presentation_id) const;
   const std::vector<MediaRoute::Id> GetRouteIds() const;
-  void OnPresentationSessionClosed(const std::string& presentation_id);
 
   void OnPresentationSessionStarted(
       const content::PresentationSessionInfo& session,
       const MediaRoute::Id& route_id);
   void OnPresentationServiceDelegateDestroyed() const;
 
   void set_delegate_observer(DelegateObserver* observer) {
     delegate_observer_ = observer;
   }
 
  private:
   MediaSource GetMediaSourceFromListener(
       content::PresentationScreenAvailabilityListener* listener) const;
-  MediaRouteIdToPresentationSessionMapping route_id_to_presentation_;
   base::SmallMap<std::map<std::string, MediaRoute::Id>>
       presentation_id_to_route_id_;
   scoped_ptr<PresentationMediaSinksObserver> sinks_observer_;
-  scoped_ptr<PresentationSessionStateObserver> session_state_observer_;
+  std::vector<scoped_ptr<PresentationConnectionStateSubscription>>
+      connection_state_subscriptions_;
   ScopedVector<PresentationSessionMessagesObserver> session_messages_observers_;
 
   // References to the owning WebContents, and the corresponding MediaRouter.
   const content::WebContents* web_contents_;
   MediaRouter* router_;
 
   DelegateObserver* delegate_observer_;
 };
 
 PresentationFrame::PresentationFrame(content::WebContents* web_contents,
@@ skipping 10 matching lines @@
 
 void PresentationFrame::OnPresentationServiceDelegateDestroyed() const {
   if (delegate_observer_)
     delegate_observer_->OnDelegateDestroyed();
 }
 
 void PresentationFrame::OnPresentationSessionStarted(
     const content::PresentationSessionInfo& session,
     const MediaRoute::Id& route_id) {
   presentation_id_to_route_id_[session.presentation_id] = route_id;
-  route_id_to_presentation_.Add(route_id, session);
-  if (session_state_observer_)
-    session_state_observer_->OnPresentationSessionConnected(route_id);
-}
-
-void PresentationFrame::OnPresentationSessionClosed(
-    const std::string& presentation_id) {
-  auto it = presentation_id_to_route_id_.find(presentation_id);
-  if (it != presentation_id_to_route_id_.end()) {
-    route_id_to_presentation_.Remove(it->second);
-    presentation_id_to_route_id_.erase(it);
-  }
-  // TODO(imcheng): Notify |session_state_observer_|?
 }
 
 const MediaRoute::Id PresentationFrame::GetRouteId(
     const std::string& presentation_id) const {
   auto it = presentation_id_to_route_id_.find(presentation_id);
   return it != presentation_id_to_route_id_.end() ? it->second : "";
 }
 
 const std::vector<MediaRoute::Id> PresentationFrame::GetRouteIds() const {
   std::vector<MediaRoute::Id> route_ids;
@@ skipping 28 matching lines @@
   }
   return false;
 }
 
 bool PresentationFrame::HasScreenAvailabilityListenerForTest(
     const MediaSource::Id& source_id) const {
   return sinks_observer_ && sinks_observer_->source().id() == source_id;
 }
 
 void PresentationFrame::Reset() {
-  route_id_to_presentation_.Clear();
-
   for (const auto& pid_route_id : presentation_id_to_route_id_)
     router_->OnPresentationSessionDetached(pid_route_id.second);
 
   presentation_id_to_route_id_.clear();
   sinks_observer_.reset();
-  if (session_state_observer_)
-    session_state_observer_->Reset();
-
+  connection_state_subscriptions_.clear();
   session_messages_observers_.clear();
 }
 
-void PresentationFrame::ListenForSessionStateChange(
-    const content::SessionStateChangedCallback& state_changed_cb) {
-  CHECK(!session_state_observer_.get());
-  session_state_observer_.reset(new PresentationSessionStateObserver(
-      state_changed_cb, &route_id_to_presentation_, router_));
+void PresentationFrame::ListenForConnectionStateChange(

[mark a. foltz, 2015/11/18 00:39:38]

Can this be called more than once per |connection|?
Should the callback be appended to the existing subscription or replace the
existing callback?

[imcheng, 2015/11/19 23:39:53]

Yes. Although it should only be called once by PresentationServiceImpl. See
below commen tas well.

+    const content::PresentationSessionInfo& connection,
+    const content::PresentationConnectionStateChangedCallback&
+        state_changed_cb) {
+  auto it = presentation_id_to_route_id_.find(connection.presentation_id);
+  if (it == presentation_id_to_route_id_.end()) {
+    DLOG(ERROR) << __FUNCTION__ << "route id not found for presentation: "
+                << connection.presentation_id;
+    return;
+  }
+
+  connection_state_subscriptions_.push_back(

[mark a. foltz, 2015/11/18 00:39:38]

It seems like we only want to add at most one Subscription per route_id per
frame.
How would that be enforced?

[imcheng, 2015/11/19 23:39:53]

We could do that, by keeping a map from route id to the Subscription object.

+      router_->AddPresentationConnectionStateChangedCallback(it->second,
+                                                             state_changed_cb));
 }
 
 void PresentationFrame::ListenForSessionMessages(
     const content::PresentationSessionInfo& session,
     const content::PresentationSessionMessageCallback& message_cb) {
   auto it = presentation_id_to_route_id_.find(session.presentation_id);
   if (it == presentation_id_to_route_id_.end()) {
     DVLOG(2) << "ListenForSessionMessages: no route for "
              << session.presentation_id;
     return;
@@ skipping 19 matching lines @@
                            MediaRouter* router);
   ~PresentationFrameManager();
 
   // Mirror corresponding APIs in PresentationServiceDelegateImpl.
   bool SetScreenAvailabilityListener(
       const RenderFrameHostId& render_frame_host_id,
       content::PresentationScreenAvailabilityListener* listener);
   bool RemoveScreenAvailabilityListener(
       const RenderFrameHostId& render_frame_host_id,
       content::PresentationScreenAvailabilityListener* listener);
-  void ListenForSessionStateChange(
+  void ListenForConnectionStateChange(
       const RenderFrameHostId& render_frame_host_id,
-      const content::SessionStateChangedCallback& state_changed_cb);
+      const content::PresentationSessionInfo& connection,
+      const content::PresentationConnectionStateChangedCallback&
+          state_changed_cb);
   void ListenForSessionMessages(
       const RenderFrameHostId& render_frame_host_id,
       const content::PresentationSessionInfo& session,
       const content::PresentationSessionMessageCallback& message_cb);
 
   // Sets or clears the default presentation request and callback for the given
   // frame. Also sets / clears the default presentation requests for the owning
   // tab WebContents.
   void SetDefaultPresentationUrl(
       const RenderFrameHostId& render_frame_host_id,
@@ skipping 16 matching lines @@
 
   void OnPresentationSessionStarted(
       const RenderFrameHostId& render_frame_host_id,
       const content::PresentationSessionInfo& session,
       const MediaRoute::Id& route_id);
   void OnDefaultPresentationSessionStarted(
       const PresentationRequest& request,
       const content::PresentationSessionInfo& session,
       const MediaRoute::Id& route_id);
 
-  void OnPresentationSessionClosed(
-      const RenderFrameHostId& render_frame_host_id,
-      const std::string& presentation_id);
   const MediaRoute::Id GetRouteId(const RenderFrameHostId& render_frame_host_id,
                                   const std::string& presentation_id) const;
   const std::vector<MediaRoute::Id> GetRouteIds(
       const RenderFrameHostId& render_frame_host_id) const;
 
   const PresentationRequest* default_presentation_request() const {
     return default_presentation_request_.get();
   }
 
  private:
@@ skipping 45 matching lines @@
 
 PresentationFrameManager::~PresentationFrameManager() {
   for (auto& frame : presentation_frames_)
     frame.second->OnPresentationServiceDelegateDestroyed();
 }
 
 void PresentationFrameManager::OnPresentationSessionStarted(
     const RenderFrameHostId& render_frame_host_id,
     const content::PresentationSessionInfo& session,
     const MediaRoute::Id& route_id) {
-  auto presentation_frame = presentation_frames_.get(render_frame_host_id);
-  if (presentation_frame)
-    presentation_frame->OnPresentationSessionStarted(session, route_id);
+  auto presentation_frame = GetOrAddPresentationFrame(render_frame_host_id);
+  presentation_frame->OnPresentationSessionStarted(session, route_id);
 }
 
 void PresentationFrameManager::OnDefaultPresentationSessionStarted(
     const PresentationRequest& request,
     const content::PresentationSessionInfo& session,
     const MediaRoute::Id& route_id) {
   auto presentation_frame =
       presentation_frames_.get(request.render_frame_host_id());
   if (presentation_frame)
     presentation_frame->OnPresentationSessionStarted(session, route_id);
 
   if (default_presentation_request_ &&
       default_presentation_request_->Equals(request)) {
     default_presentation_started_callback_.Run(session);
   }
 }
 
-void PresentationFrameManager::OnPresentationSessionClosed(
-    const RenderFrameHostId& render_frame_host_id,
-    const std::string& presentation_id) {
-  auto presentation_frame = presentation_frames_.get(render_frame_host_id);
-  if (presentation_frame)
-    presentation_frame->OnPresentationSessionClosed(presentation_id);
-}
-
 const MediaRoute::Id PresentationFrameManager::GetRouteId(
     const RenderFrameHostId& render_frame_host_id,
     const std::string& presentation_id) const {
   auto presentation_frame = presentation_frames_.get(render_frame_host_id);
   return presentation_frame ? presentation_frame->GetRouteId(presentation_id)
                             : "";
 }
 
 const std::vector<MediaRoute::Id> PresentationFrameManager::GetRouteIds(
     const RenderFrameHostId& render_frame_host_id) const {
@@ skipping 20 matching lines @@
 }
 
 bool PresentationFrameManager::HasScreenAvailabilityListenerForTest(
     const RenderFrameHostId& render_frame_host_id,
     const MediaSource::Id& source_id) const {
   auto presentation_frame = presentation_frames_.get(render_frame_host_id);
   return presentation_frame &&
          presentation_frame->HasScreenAvailabilityListenerForTest(source_id);
 }
 
-void PresentationFrameManager::ListenForSessionStateChange(
+void PresentationFrameManager::ListenForConnectionStateChange(
     const RenderFrameHostId& render_frame_host_id,
-    const content::SessionStateChangedCallback& state_changed_cb) {
-  PresentationFrame* presentation_frame =
-      GetOrAddPresentationFrame(render_frame_host_id);
-  presentation_frame->ListenForSessionStateChange(state_changed_cb);
+    const content::PresentationSessionInfo& connection,
+    const content::PresentationConnectionStateChangedCallback&
+        state_changed_cb) {
+  auto presentation_frame = presentation_frames_.get(render_frame_host_id);
+  if (presentation_frame) {
+    presentation_frame->ListenForConnectionStateChange(connection,
+                                                       state_changed_cb);
+  }
 }
 
 void PresentationFrameManager::ListenForSessionMessages(
     const RenderFrameHostId& render_frame_host_id,
     const content::PresentationSessionInfo& session,
     const content::PresentationSessionMessageCallback& message_cb) {
   PresentationFrame* presentation_frame =
       presentation_frames_.get(render_frame_host_id);
   if (!presentation_frame) {
     DVLOG(2) << "ListenForSessionMessages: PresentationFrame does not exist "
@@ skipping 313 matching lines @@
   }
 
   if (message->is_binary()) {
     router_->SendRouteBinaryMessage(route_id, message->data.Pass(),
                                     send_message_cb);
   } else {
     router_->SendRouteMessage(route_id, message->message, send_message_cb);
   }
 }
 
-void PresentationServiceDelegateImpl::ListenForSessionStateChange(
+void PresentationServiceDelegateImpl::ListenForConnectionStateChange(
     int render_process_id,
     int render_frame_id,
-    const content::SessionStateChangedCallback& state_changed_cb) {
-  frame_manager_->ListenForSessionStateChange(
-      RenderFrameHostId(render_process_id, render_frame_id), state_changed_cb);
+    const content::PresentationSessionInfo& connection,
+    const content::PresentationConnectionStateChangedCallback&
+        state_changed_cb) {
+  frame_manager_->ListenForConnectionStateChange(
+      RenderFrameHostId(render_process_id, render_frame_id), connection,
+      state_changed_cb);
 }
 
 void PresentationServiceDelegateImpl::OnRouteResponse(
     const PresentationRequest& presentation_request,
     const MediaRoute* route,
     const std::string& presentation_id,
     const std::string& error) {
   if (!route)
     return;
 
@@ skipping 37 matching lines @@
 bool PresentationServiceDelegateImpl::HasScreenAvailabilityListenerForTest(
     int render_process_id,
     int render_frame_id,
     const MediaSource::Id& source_id) const {
   RenderFrameHostId render_frame_host_id(render_process_id, render_frame_id);
   return frame_manager_->HasScreenAvailabilityListenerForTest(
       render_frame_host_id, source_id);
 }
 
 }  // namespace media_router