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

chrome/browser/media/router/offscreen_presentation_manager.cc

 // Copyright 2016 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/offscreen_presentation_manager.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "content/public/browser/render_frame_host.h"
@@ skipping 21 matching lines @@
              .first;
   }
   return it->second.get();
 }
 
 void OffscreenPresentationManager::RegisterOffscreenPresentationController(
     const std::string& presentation_id,
     const GURL& presentation_url,
     const RenderFrameHostId& render_frame_host_id,
     content::PresentationConnectionPtr controller_connection_ptr,
-    content::PresentationConnectionRequest receiver_connection_request) {
+    content::PresentationConnectionRequest receiver_connection_request,
+    const MediaRoute& route) {
   DVLOG(2) << __FUNCTION__ << " [presentation_id]: " << presentation_id
            << ", [render_frame_host_id]: " << render_frame_host_id.second;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   auto* presentation =
       GetOrCreateOffscreenPresentation(presentation_id, presentation_url);
-  presentation->RegisterController(render_frame_host_id,
-                                   std::move(controller_connection_ptr),
-                                   std::move(receiver_connection_request));
+  presentation->RegisterController(
+      render_frame_host_id, std::move(controller_connection_ptr),
+      std::move(receiver_connection_request), route);
 }
 
 void OffscreenPresentationManager::UnregisterOffscreenPresentationController(
     const std::string& presentation_id,
     const RenderFrameHostId& render_frame_host_id) {
   DVLOG(2) << __FUNCTION__ << " [presentation_id]: " << presentation_id
            << ", [render_frame_host_id]: " << render_frame_host_id.second;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   auto it = offscreen_presentations_.find(presentation_id);
@@ skipping 21 matching lines @@
 }
 
 void OffscreenPresentationManager::OnOffscreenPresentationReceiverTerminated(
     const std::string& presentation_id) {
   DVLOG(2) << __FUNCTION__ << " [presentation_id]: " << presentation_id;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   offscreen_presentations_.erase(presentation_id);
 }
 
+bool OffscreenPresentationManager::IsOffscreenPresentation(
+    const std::string& presentation_id) {
+  return base::ContainsKey(offscreen_presentations_, presentation_id);
+}
+
+const MediaRoute* OffscreenPresentationManager::GetRoute(
+    const std::string& presentation_id) {
+  auto it = offscreen_presentations_.find(presentation_id);
+  return (it != offscreen_presentations_.end() &&
+          it->second->route_.has_value())
+             ? &(it->second->route_.value())
+             : nullptr;
+}
+
 // OffscreenPresentation implementation.
 OffscreenPresentationManager::OffscreenPresentation::OffscreenPresentation(
     const std::string& presentation_id,
     const GURL& presentation_url)
     : presentation_id_(presentation_id), presentation_url_(presentation_url) {}
 
 OffscreenPresentationManager::OffscreenPresentation::~OffscreenPresentation() {}
 
 void OffscreenPresentationManager::OffscreenPresentation::RegisterController(
     const RenderFrameHostId& render_frame_host_id,
     content::PresentationConnectionPtr controller_connection_ptr,
-    content::PresentationConnectionRequest receiver_connection_request) {
+    content::PresentationConnectionRequest receiver_connection_request,
+    const MediaRoute& route) {
   if (!receiver_callback_.is_null()) {
     receiver_callback_.Run(
         content::PresentationSessionInfo(presentation_url_, presentation_id_),
         std::move(controller_connection_ptr),
         std::move(receiver_connection_request));
   } else {
     pending_controllers_.insert(std::make_pair(
         render_frame_host_id, base::MakeUnique<ControllerConnection>(
                                   std::move(controller_connection_ptr),
                                   std::move(receiver_connection_request))));
   }
+
+  route_ = route;
 }
 
 void OffscreenPresentationManager::OffscreenPresentation::UnregisterController(
     const RenderFrameHostId& render_frame_host_id) {
   pending_controllers_.erase(render_frame_host_id);
 }
 
 void OffscreenPresentationManager::OffscreenPresentation::RegisterReceiver(
     const content::ReceiverConnectionAvailableCallback& receiver_callback) {
   DCHECK(receiver_callback_.is_null());
@@ skipping 16 matching lines @@
     ControllerConnection(
         content::PresentationConnectionPtr controller_connection_ptr,
         content::PresentationConnectionRequest receiver_connection_request)
     : controller_connection_ptr(std::move(controller_connection_ptr)),
       receiver_connection_request(std::move(receiver_connection_request)) {}
 
 OffscreenPresentationManager::OffscreenPresentation::ControllerConnection::
     ~ControllerConnection() {}
 
 }  // namespace media_router