[Presentation API] (browser side) Implement reconnect() for 1-UA mode

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>
@@ skipping 137 matching lines @@
       const content::PresentationConnectionStateChangedCallback&
           state_changed_cb);
   void ListenForSessionMessages(
       const content::PresentationSessionInfo& session,
       const content::PresentationConnectionMessageCallback& message_cb);
 
   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 MediaRoute* GetRoute(const std::string& presentation_id) const;
 
   void OnPresentationSessionStarted(
       const content::PresentationSessionInfo& session,
       const MediaRoute& route);
   void OnPresentationServiceDelegateDestroyed() const;
 
-  bool IsOffscreenPresentation(const std::string& presentation_id) const;
   void ConnectToPresentation(
       const content::PresentationSessionInfo& session,
       content::PresentationConnectionPtr controller_connection_ptr,
       content::PresentationConnectionRequest receiver_connection_request);
 
  private:
   MediaSource GetMediaSourceFromListener(
       content::PresentationScreenAvailabilityListener* listener) const;
   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::unordered_map<MediaRoute::Id,
                      std::unique_ptr<BrowserPresentationConnectionProxy>>
       browser_connection_proxies_;
 
   RenderFrameHostId render_frame_host_id_;
 
   // References to the owning WebContents, and the corresponding MediaRouter.
   content::WebContents* web_contents_;
   MediaRouter* router_;
+  OffscreenPresentationManager* offscreen_presentation_manager_;
 };
 
 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) {
+      router_(router),
+      offscreen_presentation_manager_(
+          OffscreenPresentationManagerFactory::GetOrCreateForWebContents(
+              web_contents_)) {
   DCHECK(web_contents_);
   DCHECK(router_);
 }
 
 PresentationFrame::~PresentationFrame() {
 }
 
 void PresentationFrame::OnPresentationSessionStarted(
     const content::PresentationSessionInfo& session,
     const MediaRoute& route) {
   presentation_id_to_route_.insert(
       std::make_pair(session.presentation_id, route));
+
+  if (route.is_offscreen_presentation() &&
+      !offscreen_presentation_manager_->GetRoute(session.presentation_id)) {
+    offscreen_presentation_manager_->RegisterOffscreenPresentationRoute(
+        session.presentation_id, session.presentation_url, route);
+  }
 }
 
-const MediaRoute::Id PresentationFrame::GetRouteId(
+const MediaRoute* PresentationFrame::GetRoute(
     const std::string& presentation_id) const {
   auto it = presentation_id_to_route_.find(presentation_id);
-  return it != presentation_id_to_route_.end() ? it->second.media_route_id()
-                                               : "";
+  return it != presentation_id_to_route_.end() ? &it->second : nullptr;
 }
 
 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;
 
   sinks_observer.reset(new PresentationMediaSinksObserver(
@@ skipping 20 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() {
-  auto* offscreen_presentation_manager =
-      OffscreenPresentationManagerFactory::GetOrCreateForWebContents(
-          web_contents_);
-
   for (const auto& pid_route : presentation_id_to_route_) {
-    if (IsOffscreenPresentation(pid_route.first)) {
-      offscreen_presentation_manager->UnregisterOffscreenPresentationController(
-          pid_route.first, render_frame_host_id_);
+    if (pid_route.second.is_offscreen_presentation()) {
+      offscreen_presentation_manager_
+          ->UnregisterOffscreenPresentationController(pid_route.first,
+                                                      render_frame_host_id_);
+    } else {
+      router_->DetachRoute(pid_route.second.media_route_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();
   browser_connection_proxies_.clear();
 }
 
 void PresentationFrame::RemoveConnection(const std::string& presentation_id,
@@ skipping 65 matching lines @@
 }
 
 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) const {
-  const auto it = presentation_id_to_route_.find(presentation_id);
-  if (it == presentation_id_to_route_.end()) {
-    DLOG(WARNING) << "No route for [presentation_id]: " << presentation_id;
-    return false;
-  }
-
-  return it->second.is_offscreen_presentation();
-}
-
 void PresentationFrame::ConnectToPresentation(
     const content::PresentationSessionInfo& session,
     content::PresentationConnectionPtr controller_connection_ptr,
     content::PresentationConnectionRequest receiver_connection_request) {
   const auto pid_route_it =
       presentation_id_to_route_.find(session.presentation_id);
 
   if (pid_route_it == presentation_id_to_route_.end()) {
     DLOG(WARNING) << "No route for [presentation_id]: "
                   << session.presentation_id;
     return;
   }
 
-  if (IsOffscreenPresentation(session.presentation_id)) {
-    auto* const offscreen_presentation_manager =
-        OffscreenPresentationManagerFactory::GetOrCreateForWebContents(
-            web_contents_);
-    offscreen_presentation_manager->RegisterOffscreenPresentationController(
+  if (pid_route_it->second.is_offscreen_presentation()) {
+    offscreen_presentation_manager_->RegisterOffscreenPresentationController(
         session.presentation_id, session.presentation_url,
         render_frame_host_id_, std::move(controller_connection_ptr),
         std::move(receiver_connection_request));
   } else {
     DVLOG(2)
         << "Creating BrowserPresentationConnectionProxy for [presentation_id]: "
         << session.presentation_id;
     MediaRoute::Id route_id = pid_route_it->second.media_route_id();
     auto* proxy = new BrowserPresentationConnectionProxy(
         router_, route_id, std::move(receiver_connection_request),
@@ skipping 61 matching lines @@
       const PresentationRequest& request,
       const content::PresentationSessionInfo& session,
       const MediaRoute& route);
 
   void ConnectToPresentation(
       const RenderFrameHostId& render_frame_host_id,
       const content::PresentationSessionInfo& session,
       content::PresentationConnectionPtr controller_connection_ptr,
       content::PresentationConnectionRequest receiver_connection_request);
 
-  const MediaRoute::Id GetRouteId(const RenderFrameHostId& render_frame_host_id,
-                                  const std::string& presentation_id) const;
+  const MediaRoute* GetRoute(const RenderFrameHostId& render_frame_host_id,
+                             const std::string& presentation_id) const;
 
   const PresentationRequest* default_presentation_request() const {
     return default_presentation_request_.get();
   }
 
  private:
   PresentationFrame* GetOrAddPresentationFrame(
       const RenderFrameHostId& render_frame_host_id);
 
   // Sets the default presentation request for the owning WebContents and
@@ skipping 66 matching lines @@
     const RenderFrameHostId& render_frame_host_id,
     const content::PresentationSessionInfo& session,
     content::PresentationConnectionPtr controller_connection_ptr,
     content::PresentationConnectionRequest receiver_connection_request) {
   auto* presentation_frame = GetOrAddPresentationFrame(render_frame_host_id);
   presentation_frame->ConnectToPresentation(
       session, std::move(controller_connection_ptr),
       std::move(receiver_connection_request));
 }
 
-const MediaRoute::Id PresentationFrameManager::GetRouteId(
+const MediaRoute* PresentationFrameManager::GetRoute(
     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();
+             ? it->second->GetRoute(presentation_id)
+             : nullptr;
 }
 
 bool PresentationFrameManager::SetScreenAvailabilityListener(
     const RenderFrameHostId& render_frame_host_id,
     content::PresentationScreenAvailabilityListener* listener) {
   DCHECK(listener);
   auto* presentation_frame = GetOrAddPresentationFrame(render_frame_host_id);
   return presentation_frame->SetScreenAvailabilityListener(listener);
 }
 
@@ skipping 311 matching lines @@
 #if !defined(OS_ANDROID)
   if (IsAutoJoinPresentationId(presentation_id) &&
       ShouldCancelAutoJoinForOrigin(origin)) {
     error_cb.Run(content::PresentationError(
         content::PRESENTATION_ERROR_SESSION_REQUEST_CANCELLED,
         "Auto-join request cancelled by user preferences."));
     return;
   }
 #endif  // !defined(OS_ANDROID)
 
-  // TODO(crbug.com/627655): Handle multiple URLs.
-  const GURL& presentation_url = presentation_urls[0];
-  bool incognito = web_contents_->GetBrowserContext()->IsOffTheRecord();
-  std::vector<MediaRouteResponseCallback> route_response_callbacks;
-  route_response_callbacks.push_back(
-      base::Bind(&PresentationServiceDelegateImpl::OnJoinRouteResponse,
-                 weak_factory_.GetWeakPtr(), render_process_id, render_frame_id,
-                 presentation_url, presentation_id, success_cb, error_cb));
-  router_->JoinRoute(MediaSourceForPresentationUrl(presentation_url).id(),
-                     presentation_id, origin, web_contents_,
-                     route_response_callbacks, base::TimeDelta(), incognito);
+  auto* offscreen_presentation_manager =
+      OffscreenPresentationManagerFactory::GetOrCreateForWebContents(
+          web_contents_);
+  // Check offscreen presentation across frames.
+  if (offscreen_presentation_manager->IsOffscreenPresentation(
+          presentation_id)) {
+    auto* route = offscreen_presentation_manager->GetRoute(presentation_id);
+    DCHECK(route);
+    auto result = RouteRequestResult::FromSuccess(*route, presentation_id);
+    OnJoinRouteResponse(render_process_id, render_frame_id,
+                        presentation_urls[0], presentation_id, success_cb,

[mark a. foltz, 2017/03/01 06:26:32]

Connection requires matching both presentation ID and presentation URL.

So, you should check that the URL from the route's MediaSource matches one of
the presentation URLs passed in, and pass the matching URL to
OnJoinRouteResponse.

[zhaobin, 2017/03/15 18:18:57]

Done.

+                        error_cb, *result);
+  } else {
+    // TODO(crbug.com/627655): Handle multiple URLs.
+    const GURL& presentation_url = presentation_urls[0];
+    bool incognito = web_contents_->GetBrowserContext()->IsOffTheRecord();
+    std::vector<MediaRouteResponseCallback> route_response_callbacks;
+    route_response_callbacks.push_back(base::Bind(
+        &PresentationServiceDelegateImpl::OnJoinRouteResponse,
+        weak_factory_.GetWeakPtr(), render_process_id, render_frame_id,
+        presentation_url, presentation_id, success_cb, error_cb));
+    router_->JoinRoute(MediaSourceForPresentationUrl(presentation_url).id(),
+                       presentation_id, origin, web_contents_,
+                       route_response_callbacks, base::TimeDelta(), incognito);
+  }
 }
 
 void PresentationServiceDelegateImpl::CloseConnection(
     int render_process_id,
     int render_frame_id,
     const std::string& presentation_id) {
   const RenderFrameHostId rfh_id(render_process_id, render_frame_id);
-  const MediaRoute::Id& route_id =
-      frame_manager_->GetRouteId(rfh_id, presentation_id);
-  if (route_id.empty()) {
+  auto* route = frame_manager_->GetRoute(rfh_id, presentation_id);
+  if (!route) {
     DVLOG(1) << "No active route for: " << presentation_id;
     return;
   }
 
-  router_->DetachRoute(route_id);
-  frame_manager_->RemoveConnection(rfh_id, presentation_id, route_id);
+  if (route->is_offscreen_presentation()) {
+    auto* offscreen_presentation_manager =
+        OffscreenPresentationManagerFactory::GetOrCreateForWebContents(
+            web_contents_);
+    offscreen_presentation_manager->UnregisterOffscreenPresentationController(

[imcheng, 2017/02/24 01:37:46]

Do we currently change state on close() for 1-UA or is that a TODO?

[zhaobin, 2017/02/24 02:35:34]

Have a different patch for change state on close():
https://codereview.chromium.org/2714693002/

+        presentation_id, rfh_id);
+  } else {
+    router_->DetachRoute(route->media_route_id());
+  }
+  frame_manager_->RemoveConnection(rfh_id, presentation_id,
+                                   route->media_route_id());
   // TODO(mfoltz): close() should always succeed so there is no need to keep the
   // state_changed_cb around - remove it and fire the ChangeEvent on the
   // PresentationConnection in Blink.
 }
 
 void PresentationServiceDelegateImpl::Terminate(
     int render_process_id,
     int render_frame_id,
     const std::string& presentation_id) {
   const RenderFrameHostId rfh_id(render_process_id, render_frame_id);
-  const MediaRoute::Id& route_id =
-      frame_manager_->GetRouteId(rfh_id, presentation_id);
-  if (route_id.empty()) {
+  auto* route = frame_manager_->GetRoute(rfh_id, presentation_id);
+  if (!route) {
     DVLOG(1) << "No active route for: " << presentation_id;
     return;
   }
-  router_->TerminateRoute(route_id);
-  frame_manager_->RemoveConnection(rfh_id, presentation_id, route_id);
+  router_->TerminateRoute(route->media_route_id());
+  frame_manager_->RemoveConnection(rfh_id, presentation_id,
+                                   route->media_route_id());
 }
 
 void PresentationServiceDelegateImpl::ListenForConnectionMessages(
     int render_process_id,
     int render_frame_id,
     const content::PresentationSessionInfo& session,
     const content::PresentationConnectionMessageCallback& message_cb) {
   frame_manager_->ListenForSessionMessages(
       RenderFrameHostId(render_process_id, render_frame_id), session,
       message_cb);
 }
 
 void PresentationServiceDelegateImpl::SendMessage(
     int render_process_id,
     int render_frame_id,
     const content::PresentationSessionInfo& session,
     std::unique_ptr<content::PresentationConnectionMessage> message,
     const SendMessageCallback& send_message_cb) {
-  const MediaRoute::Id& route_id = frame_manager_->GetRouteId(
+  auto* route = frame_manager_->GetRoute(
       RenderFrameHostId(render_process_id, render_frame_id),
       session.presentation_id);
-  if (route_id.empty()) {
+  if (!route) {
     DVLOG(1) << "No active route for  " << session.presentation_id;
     send_message_cb.Run(false);
     return;
   }
 
   if (message->is_binary()) {
-    router_->SendRouteBinaryMessage(route_id, std::move(message->data),
-                                    send_message_cb);
+    router_->SendRouteBinaryMessage(route->media_route_id(),
+                                    std::move(message->data), send_message_cb);
   } else {
-    router_->SendRouteMessage(route_id, message->message, send_message_cb);
+    router_->SendRouteMessage(route->media_route_id(), message->message,
+                              send_message_cb);
   }
 }
 
 void PresentationServiceDelegateImpl::ListenForConnectionStateChange(
     int render_process_id,
     int render_frame_id,
     const content::PresentationSessionInfo& connection,
     const content::PresentationConnectionStateChangedCallback&
         state_changed_cb) {
   frame_manager_->ListenForConnectionStateChange(
@@ skipping 74 matching lines @@
   const base::ListValue* origins =
       Profile::FromBrowserContext(web_contents_->GetBrowserContext())
           ->GetPrefs()
           ->GetList(prefs::kMediaRouterTabMirroringSources);
   return origins &&
          origins->Find(base::StringValue(origin.Serialize())) != origins->end();
 }
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace media_router