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

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 130 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 {
+  void ConnectToPresentation(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));
 
@@ skipping 22 matching lines @@
 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,
-                 const base::Callback<void(bool)>& send_message_cb) override {
+                 const base::Callback<void(bool)>& callback) override {
     OnConnectionMessageReceived(*message);
   }
   MOCK_METHOD1(OnConnectionMessageReceived,
                void(const blink::mojom::SessionMessage& message));
   MOCK_METHOD1(DidChangeState,
                void(blink::mojom::PresentationConnectionState state));
 };
 
 class MockPresentationServiceClient
     : public blink::mojom::PresentationServiceClient {
@@ skipping 31 matching lines @@
   MOCK_METHOD0(MessagesReceived, void());
 
   void OnDefaultSessionStarted(
       blink::mojom::PresentationSessionInfoPtr session_info) override {
     OnDefaultSessionStarted(*session_info);
   }
   MOCK_METHOD1(OnDefaultSessionStarted,
                void(const blink::mojom::PresentationSessionInfo& session_info));
 
   void OnReceiverConnectionAvailable(
-      blink::mojom::PresentationSessionInfoPtr session_info) override {
+      blink::mojom::PresentationSessionInfoPtr session_info,
+      blink::mojom::PresentationConnectionPtr connection) override {
     OnReceiverConnectionAvailable(*session_info);
   }
   MOCK_METHOD1(OnReceiverConnectionAvailable,
                void(const blink::mojom::PresentationSessionInfo& session_info));
 
   std::vector<blink::mojom::SessionMessagePtr> messages_received_;
 };
 
 class PresentationServiceImplTest : public RenderViewHostImplTestHarness {
  public:
@@ skipping 280 matching lines @@
   base::RunLoop run_loop;
   EXPECT_CALL(mock_client_,
               OnDefaultSessionStarted(SessionInfoEquals(ByRef(session_info))))
       .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
   EXPECT_CALL(mock_delegate_, ListenForConnectionStateChange(_, _, _, _));
   callback.Run(content::PresentationSessionInfo(presentation_url2_,
                                                 kPresentationId, false));
   run_loop.Run();
 }
 
-TEST_F(PresentationServiceImplTest,
-       ListenForConnectionStateChangeAndChangeState) {
+TEST_F(PresentationServiceImplTest, ListenForConnectionStateChange) {
   content::PresentationSessionInfo connection(presentation_url1_,
                                               kPresentationId, false);
   content::PresentationConnectionStateChangedCallback state_changed_cb;
   // Trigger state change. It should be propagated back up to |mock_client_|.
   blink::mojom::PresentationSessionInfo presentation_connection;
   presentation_connection.url = presentation_url1_;
   presentation_connection.id = kPresentationId;
 
   EXPECT_CALL(mock_delegate_, ListenForConnectionStateChange(_, _, _, _))
       .WillOnce(SaveArg<3>(&state_changed_cb));
-  EXPECT_CALL(mock_client_,
-              OnConnectionStateChanged(
-                  SessionInfoEquals(ByRef(presentation_connection)),
-                  blink::mojom::PresentationConnectionState::CONNECTED));
-  service_impl_->ListenForConnectionStateChangeAndChangeState(connection);
+  service_impl_->ListenForConnectionStateChange(connection);
 
   {
     base::RunLoop run_loop;
     EXPECT_CALL(mock_client_,
                 OnConnectionStateChanged(
                     SessionInfoEquals(ByRef(presentation_connection)),
                     blink::mojom::PresentationConnectionState::TERMINATED))
         .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
     state_changed_cb.Run(PresentationConnectionStateChangeInfo(
         PRESENTATION_CONNECTION_STATE_TERMINATED));
     run_loop.Run();
   }
 }
 
 TEST_F(PresentationServiceImplTest, ListenForConnectionClose) {
   content::PresentationSessionInfo connection(presentation_url1_,
                                               kPresentationId, false);
   content::PresentationConnectionStateChangedCallback state_changed_cb;
   EXPECT_CALL(mock_delegate_, ListenForConnectionStateChange(_, _, _, _))
       .WillOnce(SaveArg<3>(&state_changed_cb));
-  service_impl_->ListenForConnectionStateChangeAndChangeState(connection);
+  service_impl_->ListenForConnectionStateChange(connection);
 
   // Trigger connection close. It should be propagated back up to
   // |mock_client_|.
   blink::mojom::PresentationSessionInfo presentation_connection;
   presentation_connection.url = presentation_url1_;
   presentation_connection.id = kPresentationId;
   {
     base::RunLoop run_loop;
     PresentationConnectionStateChangeInfo closed_info(
         PRESENTATION_CONNECTION_STATE_CLOSED);
@@ skipping 370 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