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

content/browser/presentation/presentation_service_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 "content/browser/presentation/presentation_service_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 26 matching lines @@
 
 namespace content {
 
 namespace {
 
 // Matches Mojo structs.
 MATCHER_P(Equals, expected, "") {
   return expected.Equals(arg);
 }
 
-// Matches PresentationSessionInfo passed by reference.
+// Matches blink::mojom::PresentationSessionInfo passed by reference.
 MATCHER_P(SessionInfoEquals, expected, "") {
   blink::mojom::PresentationSessionInfo& expected_value = expected;
   return expected_value.Equals(arg);
 }
 
+// Matches content::PresentationSessionInfo passed by reference.
+MATCHER_P(ContentSessionInfoEquals, expected, "") {
+  const content::PresentationSessionInfo& expected_value = expected;
+  return expected_value.presentation_url == arg.presentation_url &&
+         expected_value.presentation_id == arg.presentation_id &&
+         expected_value.is_offscreen == arg.is_offscreen;
+}
+
 const char kPresentationId[] = "presentationId";
 const char kPresentationUrl1[] = "http://foo.com/index.html";
 const char kPresentationUrl2[] = "http://example.com/index.html";
 const char kPresentationUrl3[] = "http://example.net/index.html";
 
 void DoNothing(blink::mojom::PresentationSessionInfoPtr info,
                blink::mojom::PresentationErrorPtr error) {}
 
 }  // namespace
 
-class MockPresentationServiceDelegate : public PresentationServiceDelegate {
+class MockPresentationServiceDelegate
+    : public ControllerPresentationServiceDelegate {
  public:
   MOCK_METHOD3(AddObserver,
-      void(int render_process_id,
-           int render_frame_id,
-           PresentationServiceDelegate::Observer* observer));
+               void(int render_process_id,
+                    int render_frame_id,
+                    PresentationServiceDelegate::Observer* observer));
   MOCK_METHOD2(RemoveObserver,
       void(int render_process_id, int render_frame_id));
 
   bool AddScreenAvailabilityListener(
       int render_process_id,
       int routing_id,
       PresentationScreenAvailabilityListener* listener) override {
     if (!screen_availability_listening_supported_)
       listener->OnScreenAvailabilityNotSupported();
 
@@ skipping 53 matching lines @@
     SendMessageRawPtr(render_process_id, render_frame_id, session,
                       message_request.release(), send_message_cb);
   }
   MOCK_METHOD4(ListenForConnectionStateChange,
                void(int render_process_id,
                     int render_frame_id,
                     const content::PresentationSessionInfo& connection,
                     const content::PresentationConnectionStateChangedCallback&
                         state_changed_cb));
 
+  void ConnectToOffscreenPresentation(
+      int render_process_id,
+      int render_frame_id,
+      const content::PresentationSessionInfo& session,
+      PresentationConnectionPtr connection) override {
+    RegisterOffscreenPresentationConnectionRaw(
+        render_process_id, render_frame_id, session, connection.get());
+  }
+
+  MOCK_METHOD4(RegisterOffscreenPresentationConnectionRaw,
+               void(int render_process_id,
+                    int render_frame_id,
+                    const content::PresentationSessionInfo& session,
+                    blink::mojom::PresentationConnection* connection));
+
   void set_screen_availability_listening_supported(bool value) {
     screen_availability_listening_supported_ = value;
   }
 
  private:
   bool screen_availability_listening_supported_ = true;
 };
 
+class MockReceiverPresentationServiceDelegate
+    : public ReceiverPresentationServiceDelegate {
+ public:
+  MOCK_METHOD3(AddObserver,
+               void(int render_process_id,
+                    int render_frame_id,
+                    PresentationServiceDelegate::Observer* observer));
+  MOCK_METHOD2(RemoveObserver,
+               void(int render_process_id, int render_frame_id));
+  MOCK_METHOD2(Reset, void(int render_process_id, int routing_id));
+  MOCK_METHOD1(RegisterReceiverConnectionAvailableCallback,
+               void(const content::ReceiverConnectionAvailableCallback&));
+};
+
+class MockPresentationConnection : public blink::mojom::PresentationConnection {
+ public:
+  void SetTargetConnection(
+      blink::mojom::PresentationConnectionPtr connection) override {
+    SetTargetConnection(*connection);
+  }
+  MOCK_METHOD1(SetTargetConnection,
+               void(blink::mojom::PresentationConnection& connection));
+
+  void OnMessage(blink::mojom::SessionMessagePtr message) override {
+    OnConnectionMessageReceived(*message);
+  }
+  MOCK_METHOD1(OnConnectionMessageReceived,
+               void(const blink::mojom::SessionMessage& message));
+};
+
 class MockPresentationServiceClient
     : public blink::mojom::PresentationServiceClient {
  public:
   MOCK_METHOD2(OnScreenAvailabilityUpdated,
                void(const GURL& url, bool available));
   void OnConnectionStateChanged(
       blink::mojom::PresentationSessionInfoPtr connection,
       blink::mojom::PresentationConnectionState new_state) override {
     OnConnectionStateChanged(*connection, new_state);
   }
@@ skipping 47 matching lines @@
         presentation_url3_(GURL(kPresentationUrl3)) {}
 
   void SetUp() override {
     RenderViewHostImplTestHarness::SetUp();
 
     auto request = mojo::GetProxy(&service_ptr_);
     EXPECT_CALL(mock_delegate_, AddObserver(_, _, _)).Times(1);
     TestRenderFrameHost* render_frame_host = contents()->GetMainFrame();
     render_frame_host->InitializeRenderFrameIfNeeded();
     service_impl_.reset(new PresentationServiceImpl(
-        render_frame_host, contents(), &mock_delegate_));
+        render_frame_host, contents(), &mock_delegate_, nullptr));
     service_impl_->Bind(std::move(request));
 
     blink::mojom::PresentationServiceClientPtr client_ptr;
     client_binding_.reset(
         new mojo::Binding<blink::mojom::PresentationServiceClient>(
             &mock_client_, mojo::GetProxy(&client_ptr)));
     service_impl_->SetClient(std::move(client_ptr));
 
     presentation_urls_.push_back(presentation_url1_);
     presentation_urls_.push_back(presentation_url2_);
@@ skipping 139 matching lines @@
       base::RunLoop run_loop;
       EXPECT_CALL(mock_client_, MessagesReceived())
           .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
       message_cb.Run(std::move(messages), pass_ownership);
       run_loop.Run();
     }
     ExpectSessionMessages(expected_msgs, mock_client_.messages_received_);
   }
 
   MockPresentationServiceDelegate mock_delegate_;
+  MockReceiverPresentationServiceDelegate mock_receiver_delegate_;
 
   std::unique_ptr<PresentationServiceImpl> service_impl_;
   mojo::InterfacePtr<blink::mojom::PresentationService> service_ptr_;
 
   MockPresentationServiceClient mock_client_;
   std::unique_ptr<mojo::Binding<blink::mojom::PresentationServiceClient>>
       client_binding_;
 
   base::Closure run_loop_quit_closure_;
 
@@ skipping 275 matching lines @@
   std::vector<uint8_t> binary_data(3, '\1');
   RunListenForSessionMessages(text_msg, binary_data, false);
 }
 
 TEST_F(PresentationServiceImplTest, ListenForSessionMessagesWithEmptyMsg) {
   std::string text_msg("");
   std::vector<uint8_t> binary_data;
   RunListenForSessionMessages(text_msg, binary_data, false);
 }
 
+TEST_F(PresentationServiceImplTest, SetPresentationConnection) {
+  blink::mojom::PresentationSessionInfoPtr session(
+      blink::mojom::PresentationSessionInfo::New());
+  session->url = presentation_url1_;
+  session->id = kPresentationId;
+
+  blink::mojom::PresentationConnectionPtr connection;
+  MockPresentationConnection mock_presentation_connection;
+  mojo::Binding<blink::mojom::PresentationConnection> connection_binding(
+      &mock_presentation_connection, mojo::GetProxy(&connection));
+
+  content::PresentationSessionInfo expected(presentation_url1_, kPresentationId,
+                                            false);
+  EXPECT_CALL(mock_delegate_,
+              RegisterOffscreenPresentationConnectionRaw(
+                  _, _, ContentSessionInfoEquals(ByRef(expected)), _));
+
+  service_impl_->SetPresentationConnection(std::move(session),
+                                           std::move(connection));
+}
+
+TEST_F(PresentationServiceImplTest, ReceiverPresentationServiceDelegate) {
+  MockReceiverPresentationServiceDelegate mock_receiver_delegate;
+
+  PresentationServiceImpl service_impl(contents()->GetMainFrame(), contents(),
+                                       nullptr, &mock_receiver_delegate);
+
+  ReceiverConnectionAvailableCallback callback;
+  EXPECT_CALL(mock_receiver_delegate,
+              RegisterReceiverConnectionAvailableCallback(_))
+      .WillOnce(SaveArg<0>(&callback));
+
+  blink::mojom::PresentationServiceClientPtr client_ptr;
+  client_binding_.reset(
+      new mojo::Binding<blink::mojom::PresentationServiceClient>(
+          &mock_client_, mojo::GetProxy(&client_ptr)));
+  service_impl.controller_delegate_ = nullptr;
+  service_impl.SetClient(std::move(client_ptr));
+  EXPECT_FALSE(callback.is_null());
+
+  // NO-OP for ControllerPresentationServiceDelegate API functions
+  EXPECT_CALL(mock_delegate_, ListenForSessionMessages(_, _, _, _)).Times(0);
+
+  blink::mojom::PresentationSessionInfoPtr session(
+      blink::mojom::PresentationSessionInfo::New());
+  session->url = GURL(kPresentationUrl1);
+  session->id = kPresentationId;
+
+  service_impl.ListenForSessionMessages(std::move(session));
+}
+
 TEST_F(PresentationServiceImplTest, StartSessionInProgress) {
   EXPECT_CALL(mock_delegate_, StartSession(_, _, presentation_urls_, _, _))
       .Times(1);
   service_ptr_->StartSession(presentation_urls_, base::Bind(&DoNothing));
 
   // This request should fail immediately, since there is already a StartSession
   // in progress.
   service_ptr_->StartSession(
       presentation_urls_,
       base::Bind(&PresentationServiceImplTest::ExpectNewSessionCallbackError,
@@ skipping 178 matching lines @@
   mock_delegate_.set_screen_availability_listening_supported(false);
   base::RunLoop run_loop;
   EXPECT_CALL(mock_client_,
               OnScreenAvailabilityNotSupported(presentation_url1_))
       .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
   ListenForScreenAvailabilityAndWait(presentation_url1_, false);
   run_loop.Run();
 }
 
 }  // namespace content