[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 138 matching lines @@
   void RemoveConnection(const std::string& presentation_id,
                         const MediaRoute::Id& route_id);
 
   const MediaRoute::Id GetRouteId(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<
@@ skipping 77 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)) {
+    if (pid_route.second.is_offscreen_presentation()) {
+      auto* offscreen_presentation_manager =
+          OffscreenPresentationManagerFactory::GetOrCreateForWebContents(
+              web_contents_);
       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 =
+  if (pid_route_it->second.is_offscreen_presentation()) {
+    auto* offscreen_presentation_manager =
         OffscreenPresentationManagerFactory::GetOrCreateForWebContents(
             web_contents_);
     offscreen_presentation_manager->RegisterOffscreenPresentationController(
         session.presentation_id, session.presentation_url,
         render_frame_host_id_, std::move(controller_connection_ptr),
-        std::move(receiver_connection_request));
+        std::move(receiver_connection_request), pid_route_it->second);
   } 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),
         std::move(controller_connection_ptr));
 
     browser_connection_proxies_.insert(
@@ skipping 151 matching lines @@
   presentation_frame->ConnectToPresentation(
       session, std::move(controller_connection_ptr),
       std::move(receiver_connection_request));
 }
 
 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();
+             ? it->second->GetRouteId(presentation_id)
+             : MediaRoute::Id();
 }
 
 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);
+
+    if (!route) {
+      LOG(WARNING) << "No route found for [presentation_id]: "
+                   << presentation_id;
+      return;
+    }
+
+    if (!base::ContainsValue(presentation_urls, route->media_source().url())) {
+      DVLOG(2) << "Presentation URLs do not match URL of current presentation:"
+               << route->media_source().url();
+      return;
+    }
+
+    auto result = RouteRequestResult::FromSuccess(*route, presentation_id);
+    OnJoinRouteResponse(render_process_id, render_frame_id,
+                        presentation_urls[0], presentation_id, success_cb,
+                        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()) {
     DVLOG(1) << "No active route for: " << presentation_id;
     return;
   }
 
-  router_->DetachRoute(route_id);
+  auto* offscreen_presentation_manager =
+      OffscreenPresentationManagerFactory::GetOrCreateForWebContents(
+          web_contents_);
+
+  if (offscreen_presentation_manager->IsOffscreenPresentation(
+          presentation_id)) {
+    offscreen_presentation_manager->UnregisterOffscreenPresentationController(
+        presentation_id, rfh_id);
+  } else {
+    router_->DetachRoute(route_id);
+  }
   frame_manager_->RemoveConnection(rfh_id, presentation_id, 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) {
@@ skipping 128 matching lines @@
   const base::ListValue* origins =
       Profile::FromBrowserContext(web_contents_->GetBrowserContext())
           ->GetPrefs()
           ->GetList(prefs::kMediaRouterTabMirroringSources);
   return origins &&
          origins->Find(base::Value(origin.Serialize())) != origins->end();
 }
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace media_router