[Presentation API] (3rd) (1-UA) Split PresentationServiceDelegateImpl(PSDImpl)

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 "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/presentation_session.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.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 {
@@ skipping 25 matching lines @@
 };
 
 class MockCreatePresentationConnnectionCallbacks {
  public:
   MOCK_METHOD1(OnCreateConnectionSuccess,
                void(const content::PresentationSessionInfo& 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,
+      content::PresentationConnectionPtr controller,
+      content::PresentationConnectionRequest) override {
+    RegisterOffscreenPresentationController(presentation_id, presentation_url,
+                                            render_frame_id);
+  }
+
+  MOCK_METHOD3(RegisterOffscreenPresentationController,
+               void(const std::string& presentation_id,
+                    const GURL& presentation_url,
+                    const RenderFrameHostId& render_frame_id));
+  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));
+};
+
+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_),
@@ skipping 363 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, 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);
+
+  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_->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;
   const std::string kPresentationId("auto-join");
   ASSERT_TRUE(IsAutoJoinPresentationId(kPresentationId));
@@ skipping 90 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