[Media Router] Connection state change listening redesign part 2.

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 <string>
 #include <vector>
 
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
@@ skipping 108 matching lines @@
                     PresentationSessionMessage* message_request,
                     const SendMessageCallback& send_message_cb));
   void SendMessage(int render_process_id,
                    int render_frame_id,
                    const content::PresentationSessionInfo& session,
                    scoped_ptr<PresentationSessionMessage> message_request,
                    const SendMessageCallback& send_message_cb) override {
     SendMessageRawPtr(render_process_id, render_frame_id, session,
                       message_request.release(), send_message_cb);
   }
-  MOCK_METHOD3(
-      ListenForSessionStateChange,
-      void(int render_process_id,
-           int render_frame_id,
-           const content::SessionStateChangedCallback& state_changed_cb));
+  MOCK_METHOD4(ListenForConnectionStateChange,
+               void(int render_process_id,
+                    int render_frame_id,
+                    const content::PresentationSessionInfo& connection,
+                    const content::PresentationConnectionStateChangedCallback&
+                        state_changed_cb));
 
   void set_screen_availability_listening_supported(bool value) {
     screen_availability_listening_supported_ = value;
   }
 
  private:
   bool screen_availability_listening_supported_ = true;
 };
 
 class MockPresentationServiceClient :
     public presentation::PresentationServiceClient {
  public:
   MOCK_METHOD2(OnScreenAvailabilityUpdated,
       void(const mojo::String& url, bool available));
-  void OnSessionStateChanged(
-      presentation::PresentationSessionInfoPtr session_info,
+  void OnConnectionStateChanged(
+      presentation::PresentationSessionInfoPtr connection,
       presentation::PresentationConnectionState new_state) override {
-    OnSessionStateChanged(*session_info, new_state);
+    OnConnectionStateChanged(*connection, new_state);
   }
-  MOCK_METHOD2(OnSessionStateChanged,
-               void(const presentation::PresentationSessionInfo& session_info,
+  MOCK_METHOD2(OnConnectionStateChanged,
+               void(const presentation::PresentationSessionInfo& connection,
                     presentation::PresentationConnectionState new_state));
 
   MOCK_METHOD1(OnScreenAvailabilityNotSupported, void(const mojo::String& url));
 
   void OnSessionMessagesReceived(
       presentation::PresentationSessionInfoPtr session_info,
       mojo::Array<presentation::SessionMessagePtr> messages) override {
     messages_received_ = messages.Pass();
     MessagesReceived();
   }
@@ skipping 280 matching lines @@
   presentation::PresentationSessionInfo session_info;
   session_info.url = url2;
   session_info.id = kPresentationId;
   base::RunLoop run_loop;
   EXPECT_CALL(mock_client_, OnDefaultSessionStarted(Equals(session_info)))
       .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
   callback.Run(content::PresentationSessionInfo(url2, kPresentationId));
   run_loop.Run();
 }
 
+TEST_F(PresentationServiceImplTest, ListenForConnectionStateChange) {
+  content::PresentationSessionInfo connection(kPresentationUrl,
+                                              kPresentationId);
+  content::PresentationConnectionStateChangedCallback state_changed_cb;
+  EXPECT_CALL(mock_delegate_, ListenForConnectionStateChange(_, _, _, _))
+      .WillOnce(SaveArg<3>(&state_changed_cb));
+  service_impl_->ListenForConnectionStateChange(connection);
+
+  // Trigger state change. It should be propagated back up to |mock_client_|.
+  presentation::PresentationSessionInfo presentation_connection;
+  presentation_connection.url = kPresentationUrl;
+  presentation_connection.id = kPresentationId;
+  base::RunLoop run_loop;
+  EXPECT_CALL(mock_client_,
+              OnConnectionStateChanged(
+                  Equals(presentation_connection),
+                  presentation::PRESENTATION_CONNECTION_STATE_CLOSED))
+      .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
+  state_changed_cb.Run(content::PRESENTATION_CONNECTION_STATE_CLOSED);
+  run_loop.Run();
+}
+
 TEST_F(PresentationServiceImplTest, SetSameDefaultPresentationUrl) {
   EXPECT_CALL(mock_delegate_,
               SetDefaultPresentationUrl(_, _, Eq(kPresentationUrl), _))
       .Times(1);
   service_impl_->SetDefaultPresentationURL(kPresentationUrl);
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_delegate_));
   EXPECT_EQ(kPresentationUrl, service_impl_->default_presentation_url_);
 
   // Same URL as before; no-ops.
   service_impl_->SetDefaultPresentationURL(kPresentationUrl);
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_delegate_));
   EXPECT_EQ(kPresentationUrl, service_impl_->default_presentation_url_);
 }
 
 TEST_F(PresentationServiceImplTest, StartSessionSuccess) {
   service_ptr_->StartSession(
       kPresentationUrl,
       base::Bind(
           &PresentationServiceImplTest::ExpectNewSessionMojoCallbackSuccess,
           base::Unretained(this)));
   base::RunLoop run_loop;
   base::Callback<void(const PresentationSessionInfo&)> success_cb;
   EXPECT_CALL(mock_delegate_, StartSession(_, _, Eq(kPresentationUrl), _, _))
       .WillOnce(DoAll(
             InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
             SaveArg<3>(&success_cb)));
   run_loop.Run();
+
+  EXPECT_CALL(mock_delegate_, ListenForConnectionStateChange(_, _, _, _))
+      .Times(1);
   success_cb.Run(PresentationSessionInfo(kPresentationUrl, kPresentationId));
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, StartSessionError) {
   service_ptr_->StartSession(
       kPresentationUrl,
       base::Bind(
           &PresentationServiceImplTest::ExpectNewSessionMojoCallbackError,
           base::Unretained(this)));
@@ skipping 16 matching lines @@
           &PresentationServiceImplTest::ExpectNewSessionMojoCallbackSuccess,
           base::Unretained(this)));
   base::RunLoop run_loop;
   base::Callback<void(const PresentationSessionInfo&)> success_cb;
   EXPECT_CALL(mock_delegate_, JoinSession(
       _, _, Eq(kPresentationUrl), Eq(kPresentationId), _, _))
       .WillOnce(DoAll(
             InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
             SaveArg<4>(&success_cb)));
   run_loop.Run();
+
+  EXPECT_CALL(mock_delegate_, ListenForConnectionStateChange(_, _, _, _))
+      .Times(1);
   success_cb.Run(PresentationSessionInfo(kPresentationUrl, kPresentationId));
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, JoinSessionError) {
   service_ptr_->JoinSession(
       kPresentationUrl,
       kPresentationId,
       base::Bind(
           &PresentationServiceImplTest::ExpectNewSessionMojoCallbackError,
@@ skipping 32 matching lines @@
 
 TEST_F(PresentationServiceImplTest, ListenForSessionMessagesWithEmptyMsg) {
   std::string text_msg("");
   std::vector<uint8_t> binary_data;
   RunListenForSessionMessages(text_msg, binary_data, false);
 }
 
 TEST_F(PresentationServiceImplTest, StartSessionInProgress) {
   std::string presentation_url1("http://fooUrl");
   std::string presentation_url2("http://barUrl");
+  EXPECT_CALL(mock_delegate_, StartSession(_, _, Eq(presentation_url1), _, _))
+      .Times(1);
   service_ptr_->StartSession(presentation_url1,
                              base::Bind(&DoNothing));
+
   // This request should fail immediately, since there is already a StartSession
   // in progress.
   service_ptr_->StartSession(
       presentation_url2,
       base::Bind(
           &PresentationServiceImplTest::ExpectNewSessionMojoCallbackError,
           base::Unretained(this)));
   SaveQuitClosureAndRunLoop();
 }
 
@@ skipping 169 matching lines @@
   // Exceeded maximum queue size, should invoke mojo callback with error.
   service_ptr_->JoinSession(
         base::StringPrintf(presentation_url, i),
         base::StringPrintf(presentation_id, i),
         base::Bind(
             &PresentationServiceImplTest::ExpectNewSessionMojoCallbackError,
             base::Unretained(this)));
   SaveQuitClosureAndRunLoop();
 }
 
-TEST_F(PresentationServiceImplTest, ListenForSessionStateChange) {
-  base::RunLoop run_loop;
-  EXPECT_CALL(mock_delegate_, ListenForSessionStateChange(_, _, _))
-      .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
-  service_ptr_->ListenForSessionStateChange();
-  run_loop.Run();
-
-  presentation::PresentationSessionInfo session_info;
-  session_info.url = kPresentationUrl;
-  session_info.id = kPresentationId;
-
-  EXPECT_CALL(mock_client_,
-              OnSessionStateChanged(
-                  Equals(session_info),
-                  presentation::PRESENTATION_CONNECTION_STATE_CONNECTED));
-  service_impl_->OnSessionStateChanged(
-      content::PresentationSessionInfo(kPresentationUrl, kPresentationId),
-      content::PRESENTATION_CONNECTION_STATE_CONNECTED);
-}
-
 TEST_F(PresentationServiceImplTest, ScreenAvailabilityNotSupported) {
   mock_delegate_.set_screen_availability_listening_supported(false);
   EXPECT_CALL(mock_client_,
               OnScreenAvailabilityNotSupported(Eq(kPresentationUrl)));
 
   ListenForScreenAvailabilityAndWait(kPresentationUrl, false);
 }
 
 }  // namespace content