[Presentation API] (5th) (1-UA) integrate controller and receiver side for 1-UA messaging

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 <unordered_map>
 #include <utility>
 #include <vector>
 
 #include "base/containers/small_map.h"
 #include "base/guid.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
+#include "chrome/browser/media/router/browser_presentation_connection_proxy.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/offscreen_presentation_manager.h"
 #include "chrome/browser/media/router/offscreen_presentation_manager_factory.h"
 #include "chrome/browser/media/router/presentation_media_sinks_observer.h"
@@ skipping 113 matching lines @@
 
   void Reset();
   void RemoveConnection(const std::string& presentation_id,
                         const MediaRoute::Id& route_id);
 
   const MediaRoute::Id GetRouteId(const std::string& presentation_id) const;
   const std::vector<MediaRoute::Id> GetRouteIds() const;
 
   void OnPresentationSessionStarted(
       const content::PresentationSessionInfo& session,
-      const MediaRoute::Id& route_id);
+      const MediaRoute& route);
+
+  bool IsOffscreenPresentation(const std::string& presentation_id);
+  void OnBrowserConnectionAvailable(
+      const content::PresentationSessionInfo& session,
+      content::PresentationConnectionPtr controller);
 
  private:
   MediaSource GetMediaSourceFromListener(
       content::PresentationScreenAvailabilityListener* listener) const;
-  base::SmallMap<std::map<std::string, MediaRoute::Id>>
-      presentation_id_to_route_id_;
+  base::SmallMap<std::map<std::string, MediaRoute>> presentation_id_to_route_;
   base::SmallMap<
       std::map<std::string, std::unique_ptr<PresentationMediaSinksObserver>>>
       url_to_sinks_observer_;
   std::unordered_map<
       MediaRoute::Id,
       std::unique_ptr<PresentationConnectionStateSubscription>>
       connection_state_subscriptions_;
   std::unordered_map<
       MediaRoute::Id,
       std::unique_ptr<PresentationSessionMessagesObserver>>
       session_messages_observers_;
+  std::set<std::unique_ptr<BrowserPresentationConnectionProxy>>
+      browser_connection_proxies_;
 
   RenderFrameHostId render_frame_host_id_;
 
   // References to the owning WebContents, and the corresponding MediaRouter.
-  const content::WebContents* web_contents_;
+  content::WebContents* web_contents_;
   MediaRouter* router_;
 };
 
 PresentationFrame::PresentationFrame(
     const RenderFrameHostId& render_frame_host_id,
     content::WebContents* web_contents,
     MediaRouter* router)
     : render_frame_host_id_(render_frame_host_id),
       web_contents_(web_contents),
       router_(router) {
   DCHECK(web_contents_);
   DCHECK(router_);
 }
 
 PresentationFrame::~PresentationFrame() {
 }
 
 void PresentationFrame::OnPresentationSessionStarted(
     const content::PresentationSessionInfo& session,
-    const MediaRoute::Id& route_id) {
-  presentation_id_to_route_id_[session.presentation_id] = route_id;
+    const MediaRoute& route) {
+  presentation_id_to_route_.insert(
+      std::make_pair(session.presentation_id, route));
 }
 
 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 : "";
+  auto it = presentation_id_to_route_.find(presentation_id);
+  return it != presentation_id_to_route_.end() ? it->second.media_route_id()
+                                               : "";
 }
 
 const std::vector<MediaRoute::Id> PresentationFrame::GetRouteIds() const {
   std::vector<MediaRoute::Id> route_ids;
-  for (const auto& e : presentation_id_to_route_id_)
-    route_ids.push_back(e.second);
+  for (const auto& e : presentation_id_to_route_)
+    route_ids.push_back(e.second.media_route_id());
   return route_ids;
 }
 
 bool PresentationFrame::SetScreenAvailabilityListener(
     content::PresentationScreenAvailabilityListener* listener) {
   MediaSource source(GetMediaSourceFromListener(listener));
   auto& sinks_observer = url_to_sinks_observer_[source.id()];
   if (sinks_observer && sinks_observer->listener() == listener)
     return false;
 
@@ skipping 21 matching lines @@
   }
   return false;
 }
 
 bool PresentationFrame::HasScreenAvailabilityListenerForTest(
     const MediaSource::Id& source_id) const {
   return url_to_sinks_observer_.find(source_id) != url_to_sinks_observer_.end();
 }
 
 void PresentationFrame::Reset() {
-  for (const auto& pid_route_id : presentation_id_to_route_id_)
-    router_->DetachRoute(pid_route_id.second);
+  auto offscreen_presentation_manager = OffscreenPresentationManagerFactory::
+      GetOrCreateForControllerBrowserContext(web_contents_);
 
-  presentation_id_to_route_id_.clear();
+  for (const auto& pid_route : presentation_id_to_route_) {
+    offscreen_presentation_manager->UnregisterOffscreenPresentationController(
+        pid_route.first, render_frame_host_id_);
+    router_->DetachRoute(pid_route.second.media_route_id());
+  }
+
+  presentation_id_to_route_.clear();
   url_to_sinks_observer_.clear();
   connection_state_subscriptions_.clear();
   session_messages_observers_.clear();
 }
 
 void PresentationFrame::RemoveConnection(const std::string& presentation_id,
                                          const MediaRoute::Id& route_id) {
   // Remove the presentation id mapping so a later call to Reset is a no-op.
-  presentation_id_to_route_id_.erase(presentation_id);
+  presentation_id_to_route_.erase(presentation_id);
 
   // We no longer need to observe route messages.
   session_messages_observers_.erase(route_id);
 
   // We keep the PresentationConnectionStateChangedCallback registered with MR
   // so the MRP can tell us when terminate() completed.
 }
 
 void PresentationFrame::ListenForConnectionStateChange(
     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()) {
+  auto it = presentation_id_to_route_.find(connection.presentation_id);
+  if (it == presentation_id_to_route_.end()) {
     DLOG(ERROR) << __func__ << "route id not found for presentation: "
                 << connection.presentation_id;
     return;
   }
 
-  const MediaRoute::Id& route_id = it->second;
+  const MediaRoute::Id& route_id = it->second.media_route_id();
   if (connection_state_subscriptions_.find(route_id) !=
       connection_state_subscriptions_.end()) {
     DLOG(ERROR) << __func__
                 << "Already listening connection state change for route: "
                 << route_id;
     return;
   }
 
   connection_state_subscriptions_.insert(std::make_pair(
       route_id, router_->AddPresentationConnectionStateChangedCallback(
-                    it->second, state_changed_cb)));
+                    route_id, 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()) {
+  auto it = presentation_id_to_route_.find(session.presentation_id);
+  if (it == presentation_id_to_route_.end()) {
     DVLOG(2) << "ListenForSessionMessages: no route for "
              << session.presentation_id;
     return;
   }
 
-  const MediaRoute::Id& route_id = it->second;
+  if (it->second.is_offscreen_presentation()) {
+    DVLOG(2) << "ListenForSessionMessages: do not listen for offscreen "
+             << "presentation [id]: " << session.presentation_id;
+    return;
+  }
+
+  const MediaRoute::Id& route_id = it->second.media_route_id();
   if (session_messages_observers_.find(route_id) !=
       session_messages_observers_.end()) {
     DLOG(ERROR) << __func__
                 << "Already listening for session messages for route: "
                 << route_id;
     return;
   }
 
   session_messages_observers_.insert(std::make_pair(

[imcheng, 2016/11/29 00:33:22]

It looks like we should be able to invoke one of the connections in
browser_connection_proxies_ instead of this :)

[zhaobin, 2017/01/13 00:05:49]

Yes, we can do a lot of refactoring after introducing BrowserConnectionProxy.
Will do code cleanup and refactoring later in seperate patches.

       route_id, base::MakeUnique<PresentationSessionMessagesObserver>(
-          router_, it->second, message_cb)));
+                    router_, route_id, message_cb)));
 }
 
 MediaSource PresentationFrame::GetMediaSourceFromListener(
     content::PresentationScreenAvailabilityListener* listener) const {
   // If the default presentation URL is empty then fall back to tab mirroring.
   return listener->GetAvailabilityUrl().is_empty()
              ? MediaSourceForTab(SessionTabHelper::IdForTab(web_contents_))
              : MediaSourceForPresentationUrl(listener->GetAvailabilityUrl());
 }
 
+bool PresentationFrame::IsOffscreenPresentation(
+    const std::string& presentation_id) {
+  DCHECK(base::ContainsKey(presentation_id_to_route_, presentation_id));
+  auto it = presentation_id_to_route_.find(presentation_id);
+  return it->second.is_offscreen_presentation();
+}
+
+void PresentationFrame::OnBrowserConnectionAvailable(
+    const content::PresentationSessionInfo& session,
+    content::PresentationConnectionPtr controller) {
+  DCHECK(controller);
+  DCHECK(base::ContainsKey(presentation_id_to_route_, session.presentation_id));
+  auto it = presentation_id_to_route_.find(session.presentation_id);
+
+  std::unique_ptr<BrowserPresentationConnectionProxy> proxy =
+      base::MakeUnique<BrowserPresentationConnectionProxy>(session, router_,
+                                                           &it->second);
+  controller->SetTargetConnection(proxy->Bind());
+  proxy->SetTargetConnection(std::move(controller));
+
+  browser_connection_proxies_.insert(std::move(proxy));
+}
+
 // Used by PresentationServiceDelegateImpl to manage PresentationFrames.
 class PresentationFrameManager {
  public:
   PresentationFrameManager(content::WebContents* web_contents,
                            MediaRouter* router);
   ~PresentationFrameManager();
 
   // Mirror corresponding APIs in PresentationServiceDelegateImpl.
   bool SetScreenAvailabilityListener(
       const RenderFrameHostId& render_frame_host_id,
@@ skipping 32 matching lines @@
                         const MediaRoute::Id& route_id,
                         const std::string& presentation_id);
   bool HasScreenAvailabilityListenerForTest(
       const RenderFrameHostId& render_frame_host_id,
       const MediaSource::Id& source_id) const;
   void SetMediaRouterForTest(MediaRouter* router);
 
   void OnPresentationSessionStarted(
       const RenderFrameHostId& render_frame_host_id,
       const content::PresentationSessionInfo& session,
-      const MediaRoute::Id& route_id);
+      const MediaRoute& route);
   void OnDefaultPresentationSessionStarted(
       const PresentationRequest& request,
       const content::PresentationSessionInfo& session,
-      const MediaRoute::Id& route_id);
+      const MediaRoute& route);
+
+  bool IsOffscreenPresentation(const RenderFrameHostId& render_frame_host_id,
+                               const std::string& presentation_id);
+  void OnBrowserConnectionAvailable(
+      const RenderFrameHostId& render_frame_host_id,
+      const content::PresentationSessionInfo& session,
+      content::PresentationConnectionPtr controller);
 
   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();
   }
 
@@ skipping 43 matching lines @@
     : router_(router), web_contents_(web_contents) {
   DCHECK(web_contents_);
   DCHECK(router_);
 }
 
 PresentationFrameManager::~PresentationFrameManager() {}
 
 void PresentationFrameManager::OnPresentationSessionStarted(
     const RenderFrameHostId& render_frame_host_id,
     const content::PresentationSessionInfo& session,
-    const MediaRoute::Id& route_id) {
+    const MediaRoute& route) {
   auto* presentation_frame = GetOrAddPresentationFrame(render_frame_host_id);
-  presentation_frame->OnPresentationSessionStarted(session, route_id);
+  presentation_frame->OnPresentationSessionStarted(session, route);
 }
 
 void PresentationFrameManager::OnDefaultPresentationSessionStarted(
     const PresentationRequest& request,
     const content::PresentationSessionInfo& session,
-    const MediaRoute::Id& route_id) {
+    const MediaRoute& route) {
   const auto it = presentation_frames_.find(request.render_frame_host_id());
   if (it != presentation_frames_.end())
-    it->second->OnPresentationSessionStarted(session, route_id);
+    it->second->OnPresentationSessionStarted(session, route);
 
   if (default_presentation_request_ &&
       default_presentation_request_->Equals(request)) {
     default_presentation_started_callback_.Run(session);
   }
 }
 
+bool PresentationFrameManager::IsOffscreenPresentation(
+    const RenderFrameHostId& render_frame_host_id,
+    const std::string& presentation_id) {
+  const auto it = presentation_frames_.find(render_frame_host_id);
+  if (it != presentation_frames_.end())
+    return it->second->IsOffscreenPresentation(presentation_id);
+  return false;
+}
+
+void PresentationFrameManager::OnBrowserConnectionAvailable(
+    const RenderFrameHostId& render_frame_host_id,
+    const content::PresentationSessionInfo& session,
+    content::PresentationConnectionPtr controller) {
+  const auto it = presentation_frames_.find(render_frame_host_id);
+  if (it != presentation_frames_.end())
+    return it->second->OnBrowserConnectionAvailable(session,
+                                                    std::move(controller));
+}
+
 const MediaRoute::Id PresentationFrameManager::GetRouteId(
     const RenderFrameHostId& render_frame_host_id,
     const std::string& presentation_id) const {
   const auto it = presentation_frames_.find(render_frame_host_id);
   return it != presentation_frames_.end()
       ? it->second->GetRouteId(presentation_id) : MediaRoute::Id();
 }
 
 const std::vector<MediaRoute::Id> PresentationFrameManager::GetRouteIds(
     const RenderFrameHostId& render_frame_host_id) const {
@@ skipping 239 matching lines @@
     DVLOG(1) << "OnJoinRouteResponse: "
              << "route_id: " << result.route()->media_route_id()
              << ", presentation URL: " << presentation_url
              << ", presentation ID: " << presentation_id;
     DCHECK_EQ(presentation_id, result.presentation_id());
     content::PresentationSessionInfo session(
         presentation_url, result.presentation_id(),
         result.route()->is_offscreen_presentation());
     frame_manager_->OnPresentationSessionStarted(
         RenderFrameHostId(render_process_id, render_frame_id), session,
-        result.route()->media_route_id());
+        *result.route());
     success_cb.Run(session);
   }
 }
 
 void PresentationServiceDelegateImpl::OnStartSessionSucceeded(
     int render_process_id,
     int render_frame_id,
     const content::PresentationSessionStartedCallback& success_cb,
     const content::PresentationSessionInfo& new_session,
     const MediaRoute& route) {
   const MediaRoute::Id& route_id = route.media_route_id();
   DVLOG(1) << "OnStartSessionSucceeded: "
            << "route_id: " << route_id
            << ", presentation URL: " << new_session.presentation_url
            << ", presentation ID: " << new_session.presentation_id
            << ", is_offscreen_presentation: " << new_session.is_offscreen;
   frame_manager_->OnPresentationSessionStarted(
       RenderFrameHostId(render_process_id, render_frame_id), new_session,
-      route_id);
+      route);
   success_cb.Run(new_session);
 }
 
 void PresentationServiceDelegateImpl::StartSession(
     int render_process_id,
     int render_frame_id,
     const std::vector<GURL>& presentation_urls,
     const content::PresentationSessionStartedCallback& success_cb,
     const content::PresentationSessionErrorCallback& error_cb) {
   if (presentation_urls.empty()) {
@@ skipping 130 matching lines @@
     int render_process_id,
     int render_frame_id,
     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::ConnectToOffscreenPresentation(
+void PresentationServiceDelegateImpl::ConnectToPresentation(
     int render_process_id,
     int render_frame_id,
     const content::PresentationSessionInfo& session,
     content::PresentationConnectionPtr connection) {
   RenderFrameHostId render_frame_host_id(render_process_id, render_frame_id);
-  auto* const offscreen_presentation_manager =
-      OffscreenPresentationManagerFactory::
-          GetOrCreateForControllerBrowserContext(web_contents_);
-  offscreen_presentation_manager->RegisterOffscreenPresentationController(
-      session.presentation_id, session.presentation_url, render_frame_host_id,
-      std::move(connection));
+
+  if (frame_manager_->IsOffscreenPresentation(render_frame_host_id,
+                                              session.presentation_id)) {
+    auto* const offscreen_presentation_manager =
+        OffscreenPresentationManagerFactory::
+            GetOrCreateForControllerBrowserContext(web_contents_);
+    offscreen_presentation_manager->RegisterOffscreenPresentationController(
+        session.presentation_id, session.presentation_url, render_frame_host_id,
+        std::move(connection));
+  } else {
+    frame_manager_->OnBrowserConnectionAvailable(render_frame_host_id, session,
+                                                 std::move(connection));
+  }
 }
 
 void PresentationServiceDelegateImpl::OnRouteResponse(
     const PresentationRequest& presentation_request,
     const RouteRequestResult& result) {
   if (!result.route())
     return;
 
   content::PresentationSessionInfo session_info(
       presentation_request.presentation_url(), result.presentation_id(),
       result.route()->is_offscreen_presentation());
   frame_manager_->OnDefaultPresentationSessionStarted(
-      presentation_request, session_info, result.route()->media_route_id());
+      presentation_request, session_info, *result.route());
 }
 
 void PresentationServiceDelegateImpl::AddDefaultPresentationRequestObserver(
     DefaultPresentationRequestObserver* observer) {
   frame_manager_->AddDefaultPresentationRequestObserver(observer);
 }
 
 void PresentationServiceDelegateImpl::RemoveDefaultPresentationRequestObserver(
     DefaultPresentationRequestObserver* observer) {
   frame_manager_->RemoveDefaultPresentationRequestObserver(observer);
@@ skipping 23 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