[Presentation API] Remove references to presentation sessions.

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"
 #include "chrome/browser/media/router/mock_media_router.h"
 #include "chrome/browser/media/router/mock_screen_availability_listener.h"
 #include "chrome/browser/media/router/offscreen_presentation_manager.h"
 #include "chrome/browser/media/router/offscreen_presentation_manager_factory.h"
 #include "chrome/browser/media/router/route_request_result.h"
 #include "chrome/browser/media/router/test_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "content/public/browser/presentation_screen_availability_listener.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
-#include "content/public/common/presentation_session.h"
+#include "content/public/common/presentation_info.h"
 #include "content/public/test/web_contents_tester.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "url/origin.h"
 
 using ::testing::_;
 using ::testing::Mock;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 
 namespace {
 
 const char kPresentationUrl1[] = "http://foo.fakeurl.com/";
 const char kPresentationUrl2[] = "http://bar.fakeurl.com/";
 const char kPresentationUrl3[] =
     "https://google.com/cast#__castAppId__=233637DE";
 const char kFrameUrl[] = "http://anotherframeurl.fakeurl.com/";
 
 }  // namespace
 
 namespace media_router {
 
 class MockDelegateObserver
     : public content::PresentationServiceDelegate::Observer {
  public:
   MOCK_METHOD0(OnDelegateDestroyed, void());
   MOCK_METHOD1(OnDefaultPresentationStarted,
-               void(const content::PresentationSessionInfo&));
+               void(const content::PresentationInfo&));
 };
 
 class MockDefaultPresentationRequestObserver
     : public PresentationServiceDelegateImpl::
           DefaultPresentationRequestObserver {
  public:
   MOCK_METHOD1(OnDefaultPresentationChanged, void(const PresentationRequest&));
   MOCK_METHOD0(OnDefaultPresentationRemoved, void());
 };
 
 class MockCreatePresentationConnnectionCallbacks {
  public:
   MOCK_METHOD1(OnCreateConnectionSuccess,
-               void(const content::PresentationSessionInfo& connection));
+               void(const content::PresentationInfo& connection));
   MOCK_METHOD1(OnCreateConnectionError,
                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,
@@ skipping 47 matching lines @@
     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));
+               void(const content::PresentationInfo& presentation_info));
 
  protected:
   virtual content::WebContents* GetWebContents() { return web_contents(); }
 
   MockOffscreenPresentationManager& GetMockOffscreenPresentationManager() {
     return *mock_offscreen_manager_;
   }
 
   void RunDefaultPresentationUrlCallbackTest(bool incognito) {
     auto callback = base::Bind(
@@ skipping 286 matching lines @@
       .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(
+  delegate_impl_->ReconnectPresentation(
       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)));
 
   EXPECT_CALL(mock_create_connection_callbacks, OnCreateConnectionSuccess(_))
       .Times(1);
   std::unique_ptr<RouteRequestResult> result = RouteRequestResult::FromSuccess(
       MediaRoute("routeId", source1_, "mediaSinkId", "description", true, "",
                  true),
       kPresentationId);
   for (const auto& route_response_callback : route_response_callbacks)
     route_response_callback.Run(*result);
 
   base::MockCallback<content::PresentationConnectionStateChangedCallback>
       mock_callback;
   auto callback = mock_callback.Get();
-  content::PresentationSessionInfo connection(presentation_url1_,
-                                              kPresentationId);
+  content::PresentationInfo connection(presentation_url1_, kPresentationId);
   EXPECT_CALL(router_, OnAddPresentationConnectionStateChangedCallbackInvoked(
                            Equals(callback)));
   delegate_impl_->ListenForConnectionStateChange(
       main_frame_process_id_, main_frame_routing_id_, connection, callback);
 }
 
 TEST_F(PresentationServiceDelegateImplTest, Reset) {
   EXPECT_CALL(router_, RegisterMediaSinksObserver(_))
       .WillRepeatedly(Return(true));
 
@@ skipping 29 matching lines @@
   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);
+  content::PresentationInfo presentation_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;
+  base::MockCallback<content::PresentationConnectionCallback> success_cb;
   EXPECT_CALL(success_cb, Run(_));
 
-  delegate_impl_->OnStartSessionSucceeded(
+  delegate_impl_->OnStartPresentationSucceeded(
       main_frame_process_id_, main_frame_routing_id_, success_cb.Get(),
-      session_info, media_route);
+      presentation_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) {
+       TestReconnectPresentationForOffscreenPresentation) {
   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;
+  base::MockCallback<content::PresentationConnectionCallback> success_cb;
+  base::MockCallback<content::PresentationConnectionErrorCallback> 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_->ReconnectPresentation(
+      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);
+  content::PresentationInfo presentation_info(presentation_url,
+                                              presentation_id);
+
   MediaRoute media_route(
-      "route_id", MediaSourceForPresentationUrl(session_info.presentation_url),
+      "route_id",
+      MediaSourceForPresentationUrl(presentation_info.presentation_url),
       "mediaSinkId", "", true, "", true);
   media_route.set_offscreen_presentation(true);
 
-  base::MockCallback<content::PresentationSessionStartedCallback> success_cb;
+  base::MockCallback<content::PresentationConnectionCallback> success_cb;
   EXPECT_CALL(success_cb, Run(_));
 
-  delegate_impl_->OnStartSessionSucceeded(render_process_id, render_frame_id,
-                                          success_cb.Get(), session_info,
-                                          media_route);
+  delegate_impl_->OnStartPresentationSucceeded(
+      render_process_id, render_frame_id, success_cb.Get(), presentation_info,
+      media_route);
 
   auto& mock_offscreen_manager = GetMockOffscreenPresentationManager();
   EXPECT_CALL(mock_offscreen_manager,
               RegisterOffscreenPresentationController(
                   presentation_id, presentation_url,
                   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));
+  delegate_impl_->ConnectToPresentation(
+      render_process_id, render_frame_id, presentation_info,
+      std::move(connection_ptr), std::move(connection_request));
 
   EXPECT_CALL(mock_offscreen_manager,
               UnregisterOffscreenPresentationController(
                   presentation_id,
                   RenderFrameHostId(render_process_id, render_frame_id)));
   EXPECT_CALL(router_, DetachRoute("route_id")).Times(0);
   delegate_impl_->Reset(render_process_id, render_frame_id);
 }
 
 #if !defined(OS_ANDROID)
@@ skipping 14 matching lines @@
     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(
+  delegate_impl_->ReconnectPresentation(
       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)));
 
   // Remove the user preference for |origin|.
   {
     ListPrefUpdate update(profile()->GetPrefs(),
                           prefs::kMediaRouterTabMirroringSources);
     update->Remove(base::Value(origin), nullptr);
   }
 
   // Auto-join requests should now go through.
   EXPECT_CALL(router_, JoinRoute(_, kPresentationId, _, _, _, _, _)).Times(1);
-  delegate_impl_->JoinSession(
+  delegate_impl_->ReconnectPresentation(
       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 21 matching lines @@
   // 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);
-  delegate_impl_->JoinSession(
+  delegate_impl_->ReconnectPresentation(
       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)));
 
   // Remove the user preference for |origin| in incognito.
   {
     ListPrefUpdate update(profile()->GetOffTheRecordProfile()->GetPrefs(),
                           prefs::kMediaRouterTabMirroringSources);
     update->Remove(base::Value(origin), nullptr);
   }
 
   // Auto-join requests should now go through.
   EXPECT_CALL(router_, JoinRoute(_, kPresentationId, _, _, _, _, _)).Times(1);
-  delegate_impl_->JoinSession(
+  delegate_impl_->ReconnectPresentation(
       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)));
 }
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace media_router