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

chrome/browser/media/router/offscreen_presentation_manager_unittest.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 <vector>
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "chrome/browser/media/router/offscreen_presentation_manager.h"
 #include "chrome/browser/media/router/test_helper.h"
@@ skipping 21 matching lines @@
   }
 
   MOCK_METHOD2(OnReceiverConnectionAvailableRaw,
                void(const content::PresentationSessionInfo&,
                     blink::mojom::PresentationConnection*));
 };
 
 class OffscreenPresentationManagerTest : public ::testing::Test {
  public:
   OffscreenPresentationManagerTest()
-      : render_frame_host_id_(1, 1), presentation_url_(kPresentationUrl) {}
+      : render_frame_host_id_(1, 1),
+        presentation_url_(kPresentationUrl),
+        route_("route_1",
+               MediaSource("source_1"),
+               "sink_1",
+               "",
+               false,
+               "",
+               false) {}
 
   OffscreenPresentationManager* manager() { return &manager_; }
 
   void VerifyPresentationsSize(size_t expected) {
     EXPECT_EQ(expected, manager_.offscreen_presentations_.size());
   }
 
   void VerifyControllerSize(size_t expected,
                             const std::string& presentationId) {
     EXPECT_TRUE(
         base::ContainsKey(manager_.offscreen_presentations_, presentationId));
     EXPECT_EQ(expected, manager_.offscreen_presentations_[presentationId]
                             ->pending_controllers_.size());
   }
 
   void RegisterController(const std::string& presentation_id,
                           content::PresentationConnectionPtr controller) {
     content::PresentationConnectionRequest receiver_conn_request;
     manager()->RegisterOffscreenPresentationController(
         presentation_id, presentation_url_, render_frame_host_id_,
-        std::move(controller), std::move(receiver_conn_request));
+        std::move(controller), std::move(receiver_conn_request), route_);
   }
 
   void RegisterController(const RenderFrameHostId& render_frame_id,
                           content::PresentationConnectionPtr controller) {
     content::PresentationConnectionRequest receiver_conn_request;
     manager()->RegisterOffscreenPresentationController(
         kPresentationId, presentation_url_, render_frame_id,
-        std::move(controller), std::move(receiver_conn_request));
+        std::move(controller), std::move(receiver_conn_request), route_);
   }
 
   void RegisterController(content::PresentationConnectionPtr controller) {
     content::PresentationConnectionRequest receiver_conn_request;
     manager()->RegisterOffscreenPresentationController(
         kPresentationId, presentation_url_, render_frame_host_id_,
-        std::move(controller), std::move(receiver_conn_request));
+        std::move(controller), std::move(receiver_conn_request), route_);
   }
 
   void RegisterReceiver(
       MockReceiverConnectionAvailableCallback& receiver_callback) {
     RegisterReceiver(kPresentationId, receiver_callback);
   }
 
   void RegisterReceiver(
       const std::string& presentation_id,
       MockReceiverConnectionAvailableCallback& receiver_callback) {
@@ skipping 15 matching lines @@
   }
 
   void UnregisterReceiver() {
     manager()->OnOffscreenPresentationReceiverTerminated(kPresentationId);
   }
 
  private:
   const RenderFrameHostId render_frame_host_id_;
   GURL presentation_url_;
   OffscreenPresentationManager manager_;
+  MediaRoute route_;
 };
 
 TEST_F(OffscreenPresentationManagerTest, RegisterUnregisterController) {
   content::PresentationConnectionPtr controller;
   RegisterController(std::move(controller));
   VerifyPresentationsSize(1);
   UnregisterController();
   VerifyPresentationsSize(0);
 }
 
@@ skipping 167 matching lines @@
   EXPECT_CALL(receiver_callback2, OnReceiverConnectionAvailableRaw(_, _))
       .Times(1);
   RegisterReceiver(kPresentationId2, receiver_callback2);
 
   VerifyPresentationsSize(2);
 
   UnregisterReceiver();
   VerifyPresentationsSize(1);
 }
 
+TEST_F(OffscreenPresentationManagerTest, TestIsOffscreenPresentation) {
+  EXPECT_FALSE(manager()->IsOffscreenPresentation(kPresentationId));
+  content::PresentationConnectionPtr controller1;
+  RegisterController(kPresentationId, std::move(controller1));
+  EXPECT_TRUE(manager()->IsOffscreenPresentation(kPresentationId));
+}
+
+TEST_F(OffscreenPresentationManagerTest, TestRegisterAndGetRoute) {
+  MediaSource source("source_1");
+  MediaRoute route("route_1", source, "sink_1", "", false, "", false);
+
+  EXPECT_FALSE(manager()->GetRoute(kPresentationId));
+  content::PresentationConnectionPtr controller;
+  RegisterController(std::move(controller));
+
+  auto* actual_route = manager()->GetRoute(kPresentationId);
+  EXPECT_TRUE(actual_route);
+  EXPECT_TRUE(route.Equals(*actual_route));
+}
+
 }  // namespace media_router