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

chrome/browser/media/router/presentation_service_delegate_impl_unittest.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 "base/memory/ptr_util.h"
 #include "base/test/mock_callback.h"
 #include "chrome/browser/media/router/media_source.h"
 #include "chrome/browser/media/router/media_source_helper.h"
@@ skipping 59 matching lines @@
                void(const content::PresentationError& error));
 };
 
 class MockOffscreenPresentationManager : public OffscreenPresentationManager {
  public:
   void RegisterOffscreenPresentationController(
       const std::string& presentation_id,
       const GURL& presentation_url,
       const RenderFrameHostId& render_frame_id,
       content::PresentationConnectionPtr controller,
-      content::PresentationConnectionRequest) override {
+      content::PresentationConnectionRequest,
+      const MediaRoute& route) override {
     RegisterOffscreenPresentationController(presentation_id, presentation_url,
-                                            render_frame_id);
+                                            render_frame_id, route);
   }
 
-  MOCK_METHOD3(RegisterOffscreenPresentationController,
+  MOCK_METHOD4(RegisterOffscreenPresentationController,
                void(const std::string& presentation_id,
                     const GURL& presentation_url,
-                    const RenderFrameHostId& render_frame_id));
+                    const RenderFrameHostId& render_frame_id,
+                    const MediaRoute& route));
   MOCK_METHOD2(UnregisterOffscreenPresentationController,
                void(const std::string& presentation_id,
                     const RenderFrameHostId& render_frame_id));
   MOCK_METHOD3(OnOffscreenPresentationReceiverCreated,
                void(const std::string& presentation_id,
                     const GURL& presentation_url,
                     const content::ReceiverConnectionAvailableCallback&
                         receiver_callback));
   MOCK_METHOD1(OnOffscreenPresentationReceiverTerminated,
                void(const std::string& presentation_id));
+  MOCK_METHOD1(IsOffscreenPresentation,
+               bool(const std::string& presentation_id));
+  MOCK_METHOD1(GetRoute, MediaRoute*(const std::string& presentation_id));
 };
 
 std::unique_ptr<KeyedService> BuildMockOffscreenPresentationManager(
     content::BrowserContext* context) {
   return base::MakeUnique<MockOffscreenPresentationManager>();
 }
 
 class PresentationServiceDelegateImplTest
     : public ChromeRenderViewHostTestHarness {
  public:
   PresentationServiceDelegateImplTest()
       : delegate_impl_(nullptr),
         presentation_url1_(kPresentationUrl1),
         presentation_url2_(kPresentationUrl2),
         source1_(MediaSourceForPresentationUrl(presentation_url1_)),
         source2_(MediaSourceForPresentationUrl(presentation_url2_)),
         listener1_(presentation_url1_),
         listener2_(presentation_url2_) {}
 
   void SetUp() override {
     ChromeRenderViewHostTestHarness::SetUp();
     content::WebContents* wc = GetWebContents();
     ASSERT_TRUE(wc);
     PresentationServiceDelegateImpl::CreateForWebContents(wc);
     delegate_impl_ = PresentationServiceDelegateImpl::FromWebContents(wc);
     delegate_impl_->SetMediaRouterForTest(&router_);
     presentation_urls_.push_back(presentation_url1_);
     SetMainFrame();
+    SetMockOffscreenPresentationManager();
   }
 
   MOCK_METHOD1(OnDefaultPresentationStarted,
                void(const content::PresentationSessionInfo& session_info));
 
  protected:
   virtual content::WebContents* GetWebContents() { return web_contents(); }
 
+  MockOffscreenPresentationManager& GetMockOffscreenPresentationManager() {
+    return *mock_offscreen_manager_;
+  }
+
   void RunDefaultPresentationUrlCallbackTest(bool incognito) {
     auto callback = base::Bind(
         &PresentationServiceDelegateImplTest::OnDefaultPresentationStarted,
         base::Unretained(this));
     std::vector<std::string> urls({kPresentationUrl1});
     delegate_impl_->SetDefaultPresentationUrls(main_frame_process_id_,
                                                main_frame_routing_id_,
                                                presentation_urls_, callback);
 
     ASSERT_TRUE(delegate_impl_->HasDefaultPresentationRequest());
@@ skipping 27 matching lines @@
     delegate_impl_->OnRouteResponse(request, *result);
   }
 
   void SetMainFrame() {
     content::RenderFrameHost* main_frame = GetWebContents()->GetMainFrame();
     ASSERT_TRUE(main_frame);
     main_frame_process_id_ = main_frame->GetProcess()->GetID();
     main_frame_routing_id_ = main_frame->GetRoutingID();
   }
 
+  void SetMockOffscreenPresentationManager() {
+    OffscreenPresentationManagerFactory::GetInstanceForTest()
+        ->SetTestingFactory(profile(), &BuildMockOffscreenPresentationManager);
+    mock_offscreen_manager_ = static_cast<MockOffscreenPresentationManager*>(
+        OffscreenPresentationManagerFactory::GetOrCreateForBrowserContext(
+            profile()));
+  }
+
   PresentationServiceDelegateImpl* delegate_impl_;
   MockMediaRouter router_;
   const GURL presentation_url1_;
   const GURL presentation_url2_;
   std::vector<GURL> presentation_urls_;
+  MockOffscreenPresentationManager* mock_offscreen_manager_;
 
   // |source1_| and |source2_| correspond to |presentation_url1_| and
   // |presentation_url2_|, respectively.
   MediaSource source1_;
   MediaSource source2_;
 
   // |listener1_| and |listener2_| correspond to |presentation_url1_| and
   // |presentation_url2_|, respectively.
   MockScreenAvailabilityListener listener1_;
   MockScreenAvailabilityListener listener2_;
@@ skipping 211 matching lines @@
   content::WebContentsTester::For(GetWebContents())
       ->NavigateAndCommit(frame_url);
 
   // Set up a PresentationConnection so we can listen to it.
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   EXPECT_CALL(router_, JoinRoute(_, _, _, _, _, _, false))
       .WillOnce(SaveArg<4>(&route_response_callbacks));
 
   const std::string kPresentationId("pid");
   presentation_urls_.push_back(GURL(kPresentationUrl3));
+
+  auto& mock_offscreen_manager = GetMockOffscreenPresentationManager();
+  EXPECT_CALL(mock_offscreen_manager, IsOffscreenPresentation(kPresentationId))
+      .WillRepeatedly(Return(false));
+
   MockCreatePresentationConnnectionCallbacks mock_create_connection_callbacks;
   delegate_impl_->JoinSession(
       main_frame_process_id_, main_frame_routing_id_, presentation_urls_,
       kPresentationId,
       base::Bind(&MockCreatePresentationConnnectionCallbacks::
                      OnCreateConnectionSuccess,
                  base::Unretained(&mock_create_connection_callbacks)),
       base::Bind(
           &MockCreatePresentationConnnectionCallbacks::OnCreateConnectionError,
           base::Unretained(&mock_create_connection_callbacks)));
@@ skipping 50 matching lines @@
   manager.reset();
 }
 
 TEST_F(PresentationServiceDelegateImplTest, SinksObserverCantRegister) {
   EXPECT_CALL(router_, RegisterMediaSinksObserver(_)).WillOnce(Return(false));
   EXPECT_CALL(listener1_, OnScreenAvailabilityNotSupported());
   EXPECT_FALSE(delegate_impl_->AddScreenAvailabilityListener(
       main_frame_process_id_, main_frame_routing_id_, &listener1_));
 }
 
+TEST_F(PresentationServiceDelegateImplTest,
+       TestCloseConnectionForOffscreenPresentation) {
+  std::string presentation_id = "presentation_id";
+  GURL presentation_url = GURL("http://www.example.com/presentation.html");
+  content::PresentationSessionInfo session_info(presentation_url,
+                                                presentation_id);
+  RenderFrameHostId rfh_id(main_frame_process_id_, main_frame_routing_id_);
+  MediaRoute media_route("route_id",
+                         MediaSourceForPresentationUrl(presentation_url),
+                         "mediaSinkId", "", true, "", true);
+  media_route.set_offscreen_presentation(true);
+
+  auto& mock_offscreen_manager = GetMockOffscreenPresentationManager();
+  EXPECT_CALL(mock_offscreen_manager, IsOffscreenPresentation(presentation_id))
+      .WillRepeatedly(Return(true));
+
+  base::MockCallback<content::PresentationSessionStartedCallback> success_cb;
+  EXPECT_CALL(success_cb, Run(_));
+
+  delegate_impl_->OnStartSessionSucceeded(
+      main_frame_process_id_, main_frame_routing_id_, success_cb.Get(),
+      session_info, media_route);
+
+  EXPECT_CALL(mock_offscreen_manager, UnregisterOffscreenPresentationController(
+                                          presentation_id, rfh_id))
+      .Times(1);
+  EXPECT_CALL(router_, DetachRoute(_)).Times(0);
+
+  delegate_impl_->CloseConnection(main_frame_process_id_,
+                                  main_frame_routing_id_, presentation_id);
+  delegate_impl_->CloseConnection(main_frame_process_id_,
+                                  main_frame_routing_id_, presentation_id);
+}
+
+TEST_F(PresentationServiceDelegateImplTest,
+       TestJoinSessionForOffscreenPresentation) {
+  std::string presentation_id = "presentation_id";
+  GURL presentation_url = GURL("http://www.example.com/presentation.html");
+  MediaRoute media_route("route_id",
+                         MediaSourceForPresentationUrl(presentation_url),
+                         "mediaSinkId", "", true, "", true);
+  media_route.set_offscreen_presentation(true);
+
+  auto& mock_offscreen_manager = GetMockOffscreenPresentationManager();
+  EXPECT_CALL(mock_offscreen_manager, IsOffscreenPresentation(presentation_id))
+      .WillRepeatedly(Return(true));
+  EXPECT_CALL(mock_offscreen_manager, GetRoute(presentation_id))
+      .WillRepeatedly(Return(&media_route));
+
+  std::vector<GURL> urls = {presentation_url};
+  base::MockCallback<content::PresentationSessionStartedCallback> success_cb;
+  base::MockCallback<content::PresentationSessionErrorCallback> error_cb;
+  EXPECT_CALL(success_cb, Run(_));
+  EXPECT_CALL(mock_offscreen_manager,
+              UnregisterOffscreenPresentationController(
+                  presentation_id, RenderFrameHostId(main_frame_process_id_,
+                                                     main_frame_routing_id_)));
+
+  delegate_impl_->JoinSession(main_frame_process_id_, main_frame_routing_id_,
+                              urls, presentation_id, success_cb.Get(),
+                              error_cb.Get());
+  delegate_impl_->Reset(main_frame_process_id_, main_frame_routing_id_);
+}
+
 TEST_F(PresentationServiceDelegateImplTest, ConnectToPresentation) {
   content::RenderFrameHost* main_frame = GetWebContents()->GetMainFrame();
   ASSERT_TRUE(main_frame);
   int render_process_id = main_frame->GetProcess()->GetID();
   int render_frame_id = main_frame->GetRoutingID();
   std::string presentation_id = "presentation_id";
   GURL presentation_url = GURL("http://www.example.com/presentation.html");
   content::PresentationSessionInfo session_info(presentation_url,
                                                 presentation_id);
-
-  base::MockCallback<
-      base::Callback<void(const content::PresentationSessionInfo&)>>
-      mock_callback;
-  EXPECT_CALL(mock_callback, Run(_));
   MediaRoute media_route(
       "route_id", MediaSourceForPresentationUrl(session_info.presentation_url),
       "mediaSinkId", "", true, "", true);
   media_route.set_offscreen_presentation(true);
+
+  base::MockCallback<content::PresentationSessionStartedCallback> success_cb;
+  EXPECT_CALL(success_cb, Run(_));
+
   delegate_impl_->OnStartSessionSucceeded(render_process_id, render_frame_id,
-                                          mock_callback.Get(), session_info,
+                                          success_cb.Get(), session_info,
                                           media_route);
 
-  OffscreenPresentationManagerFactory::GetInstanceForTest()->SetTestingFactory(
-      profile(), &BuildMockOffscreenPresentationManager);
-  MockOffscreenPresentationManager* mock_offscreen_manager =
-      static_cast<MockOffscreenPresentationManager*>(
-          OffscreenPresentationManagerFactory::GetOrCreateForBrowserContext(
-              profile()));
-  EXPECT_CALL(*mock_offscreen_manager,
+  auto& mock_offscreen_manager = GetMockOffscreenPresentationManager();
+  EXPECT_CALL(mock_offscreen_manager,
               RegisterOffscreenPresentationController(
                   presentation_id, presentation_url,
-                  RenderFrameHostId(render_process_id, render_frame_id)));
+                  RenderFrameHostId(render_process_id, render_frame_id),
+                  Equals(media_route)));
 
   content::PresentationConnectionPtr connection_ptr;
   content::PresentationConnectionRequest connection_request;
   delegate_impl_->ConnectToPresentation(render_process_id, render_frame_id,
                                         session_info, std::move(connection_ptr),
                                         std::move(connection_request));
 
-  EXPECT_CALL(*mock_offscreen_manager,
+  EXPECT_CALL(mock_offscreen_manager,
               UnregisterOffscreenPresentationController(
                   presentation_id,
                   RenderFrameHostId(render_process_id, render_frame_id)));
-  EXPECT_CALL(router_, DetachRoute("route_id"));
+  EXPECT_CALL(router_, DetachRoute("route_id")).Times(0);
   delegate_impl_->Reset(render_process_id, render_frame_id);
 }
 
 #if !defined(OS_ANDROID)
 TEST_F(PresentationServiceDelegateImplTest, AutoJoinRequest) {
   GURL frame_url(kFrameUrl);
   std::string origin(url::Origin(frame_url).Serialize());
   content::WebContentsTester::For(GetWebContents())
       ->NavigateAndCommit(frame_url);
 
   MockCreatePresentationConnnectionCallbacks mock_create_connection_callbacks;
   const std::string kPresentationId("auto-join");
   ASSERT_TRUE(IsAutoJoinPresentationId(kPresentationId));
 
   // Set the user preference for |origin| to prefer tab mirroring.
   {
     ListPrefUpdate update(profile()->GetPrefs(),
                           prefs::kMediaRouterTabMirroringSources);
     update->AppendIfNotPresent(base::MakeUnique<base::Value>(origin));
   }
 
+  auto& mock_offscreen_manager = GetMockOffscreenPresentationManager();
+  EXPECT_CALL(mock_offscreen_manager, IsOffscreenPresentation(kPresentationId))
+      .WillRepeatedly(Return(false));
+
   // Auto-join requests should be rejected.
   EXPECT_CALL(mock_create_connection_callbacks, OnCreateConnectionError(_));
   EXPECT_CALL(router_, JoinRoute(_, kPresentationId, _, _, _, _, _)).Times(0);
   delegate_impl_->JoinSession(
       main_frame_process_id_, main_frame_routing_id_, presentation_urls_,
       kPresentationId,
       base::Bind(&MockCreatePresentationConnnectionCallbacks::
                      OnCreateConnectionSuccess,
                  base::Unretained(&mock_create_connection_callbacks)),
       base::Bind(
@@ skipping 30 matching lines @@
   const std::string kPresentationId("auto-join");
   ASSERT_TRUE(IsAutoJoinPresentationId(kPresentationId));
 
   // Set the user preference for |origin| to prefer tab mirroring.
   {
     ListPrefUpdate update(profile()->GetOffTheRecordProfile()->GetPrefs(),
                           prefs::kMediaRouterTabMirroringSources);
     update->AppendIfNotPresent(base::MakeUnique<base::Value>(origin));
   }
 
+  auto& mock_offscreen_manager = GetMockOffscreenPresentationManager();
+  EXPECT_CALL(mock_offscreen_manager, IsOffscreenPresentation(kPresentationId))
+      .WillRepeatedly(Return(false));
+
   // Setting the pref in incognito shouldn't set it for the non-incognito
   // profile.
   const base::ListValue* non_incognito_origins =
       profile()->GetPrefs()->GetList(prefs::kMediaRouterTabMirroringSources);
   EXPECT_EQ(non_incognito_origins->Find(base::Value(origin)),
             non_incognito_origins->end());
 
   // Auto-join requests should be rejected.
   EXPECT_CALL(mock_create_connection_callbacks, OnCreateConnectionError(_));
   EXPECT_CALL(router_, JoinRoute(_, kPresentationId, _, _, _, _, _)).Times(0);
@@ skipping 22 matching lines @@
       base::Bind(&MockCreatePresentationConnnectionCallbacks::
                      OnCreateConnectionSuccess,
                  base::Unretained(&mock_create_connection_callbacks)),
       base::Bind(
           &MockCreatePresentationConnnectionCallbacks::OnCreateConnectionError,
           base::Unretained(&mock_create_connection_callbacks)));
 }
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace media_router