Revert of [Presentation API] (5th) (1-UA) integrate controller and receiver side for 1-UA messaging

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"
@@ skipping 460 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, ConnectToPresentation) {
+TEST_F(PresentationServiceDelegateImplTest, ConnectToOffscreenPresentation) {
   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);
-  delegate_impl_->OnStartSessionSucceeded(render_process_id, render_frame_id,
-                                          mock_callback.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,
               RegisterOffscreenPresentationController(
                   presentation_id, presentation_url,
                   RenderFrameHostId(render_process_id, render_frame_id)));
 
   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,
-              UnregisterOffscreenPresentationController(
-                  presentation_id,
-                  RenderFrameHostId(render_process_id, render_frame_id)));
-  EXPECT_CALL(router_, DetachRoute("route_id"));
-  delegate_impl_->Reset(render_process_id, render_frame_id);
+  delegate_impl_->ConnectToOffscreenPresentation(
+      render_process_id, render_frame_id, session_info,
+      std::move(connection_ptr), std::move(connection_request));
 }
 
 #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;
@@ skipping 92 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