Revert of [Presentation API / Media Router] Clean up default pres URL logic.

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 23 matching lines @@
 namespace {
 
 // Matches mojo structs.
 MATCHER_P(Equals, expected, "") {
   return expected.Equals(arg);
 }
 
 const char *const kPresentationId = "presentationId";
 const char *const kPresentationUrl = "http://foo.com/index.html";
 
+bool ArePresentationSessionsEqual(
+    const presentation::PresentationSessionInfo& expected,
+    const presentation::PresentationSessionInfo& actual) {
+  return expected.url == actual.url && expected.id == actual.id;
+}
+
 bool ArePresentationSessionMessagesEqual(
     const presentation::SessionMessage* expected,
     const presentation::SessionMessage* actual) {
   return expected->type == actual->type &&
          expected->message == actual->message &&
          expected->data.Equals(actual->data);
 }
 
 void DoNothing(
     presentation::PresentationSessionInfoPtr info,
@@ skipping 24 matching lines @@
 
   MOCK_METHOD3(RemoveScreenAvailabilityListener,
       void(
           int render_process_id,
           int routing_id,
           PresentationScreenAvailabilityListener* listener));
   MOCK_METHOD2(Reset,
       void(
           int render_process_id,
           int routing_id));
-  MOCK_METHOD4(SetDefaultPresentationUrl,
-               void(int render_process_id,
-                    int routing_id,
-                    const std::string& default_presentation_url,
-                    const PresentationSessionStartedCallback& callback));
+  MOCK_METHOD3(SetDefaultPresentationUrl,
+      void(
+          int render_process_id,
+          int routing_id,
+          const std::string& default_presentation_url));
   MOCK_METHOD5(StartSession,
-               void(int render_process_id,
-                    int render_frame_id,
-                    const std::string& presentation_url,
-                    const PresentationSessionStartedCallback& success_cb,
-                    const PresentationSessionErrorCallback& error_cb));
+      void(
+          int render_process_id,
+          int render_frame_id,
+          const std::string& presentation_url,
+          const PresentationSessionSuccessCallback& success_cb,
+          const PresentationSessionErrorCallback& error_cb));
   MOCK_METHOD6(JoinSession,
-               void(int render_process_id,
-                    int render_frame_id,
-                    const std::string& presentation_url,
-                    const std::string& presentation_id,
-                    const PresentationSessionStartedCallback& success_cb,
-                    const PresentationSessionErrorCallback& error_cb));
+      void(
+          int render_process_id,
+          int render_frame_id,
+          const std::string& presentation_url,
+          const std::string& presentation_id,
+          const PresentationSessionSuccessCallback& success_cb,
+          const PresentationSessionErrorCallback& error_cb));
   MOCK_METHOD3(CloseSession,
                void(int render_process_id,
                     int render_frame_id,
                     const std::string& presentation_id));
   MOCK_METHOD4(ListenForSessionMessages,
                void(int render_process_id,
                     int render_frame_id,
                     const content::PresentationSessionInfo& session,
                     const PresentationSessionMessageCallback& message_cb));
   MOCK_METHOD5(SendMessageRawPtr,
@@ skipping 41 matching lines @@
   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();
   }
   MOCK_METHOD0(MessagesReceived, void());
 
-  void OnDefaultSessionStarted(
-      presentation::PresentationSessionInfoPtr session_info) override {
-    OnDefaultSessionStarted(*session_info);
-  }
-  MOCK_METHOD1(OnDefaultSessionStarted,
-               void(const presentation::PresentationSessionInfo& session_info));
-
   mojo::Array<presentation::SessionMessagePtr> messages_received_;
 };
 
 class PresentationServiceImplTest : public RenderViewHostImplTestHarness {
  public:
   PresentationServiceImplTest() : default_session_started_count_(0) {}
 
   void SetUp() override {
     RenderViewHostImplTestHarness::SetUp();
 
@@ skipping 65 matching lines @@
 
   void ExpectReset() {
     EXPECT_CALL(mock_delegate_, Reset(_, _)).Times(1);
   }
 
   void ExpectCleanState() {
     EXPECT_TRUE(service_impl_->default_presentation_url_.empty());
     EXPECT_EQ(
         service_impl_->screen_availability_listeners_.find(kPresentationUrl),
         service_impl_->screen_availability_listeners_.end());
+    EXPECT_FALSE(service_impl_->default_session_start_context_.get());
     EXPECT_FALSE(service_impl_->on_session_messages_callback_.get());
   }
 
   void ExpectNewSessionMojoCallbackSuccess(
       presentation::PresentationSessionInfoPtr info,
       presentation::PresentationErrorPtr error) {
     EXPECT_FALSE(info.is_null());
     EXPECT_TRUE(error.is_null());
     if (!run_loop_quit_closure_.is_null())
       run_loop_quit_closure_.Run();
   }
 
   void ExpectNewSessionMojoCallbackError(
       presentation::PresentationSessionInfoPtr info,
       presentation::PresentationErrorPtr error) {
     EXPECT_TRUE(info.is_null());
     EXPECT_FALSE(error.is_null());
     if (!run_loop_quit_closure_.is_null())
       run_loop_quit_closure_.Run();
   }
+
+  void ExpectDefaultSessionStarted(
+      const presentation::PresentationSessionInfo& expected_session,
+      presentation::PresentationSessionInfoPtr actual_session) {
+    ASSERT_TRUE(!actual_session.is_null());
+    EXPECT_TRUE(ArePresentationSessionsEqual(
+        expected_session, *actual_session));
+    ++default_session_started_count_;
+    if (!run_loop_quit_closure_.is_null())
+      run_loop_quit_closure_.Run();
+  }
+
+  void ExpectDefaultSessionNull(
+      presentation::PresentationSessionInfoPtr actual_session) {
+    EXPECT_TRUE(actual_session.is_null());
+    ++default_session_started_count_;
+    if (!run_loop_quit_closure_.is_null())
+      run_loop_quit_closure_.Run();
+  }
 
   void ExpectSessionMessages(
       const mojo::Array<presentation::SessionMessagePtr>& expected_msgs,
       const mojo::Array<presentation::SessionMessagePtr>& actual_msgs) {
     EXPECT_EQ(expected_msgs.size(), actual_msgs.size());
     for (size_t i = 0; i < actual_msgs.size(); ++i) {
       EXPECT_TRUE(ArePresentationSessionMessagesEqual(expected_msgs[i].get(),
                                                       actual_msgs[i].get()));
     }
   }
@@ skipping 133 matching lines @@
 
 TEST_F(PresentationServiceImplTest, DelegateFails) {
   ListenForScreenAvailabilityAndWait(kPresentationUrl, false);
   ASSERT_EQ(
       service_impl_->screen_availability_listeners_.find(kPresentationUrl),
       service_impl_->screen_availability_listeners_.end());
 }
 
 TEST_F(PresentationServiceImplTest, SetDefaultPresentationUrl) {
   std::string url1("http://fooUrl");
-  EXPECT_CALL(mock_delegate_, SetDefaultPresentationUrl(_, _, Eq(url1), _))
+  EXPECT_CALL(mock_delegate_,
+      SetDefaultPresentationUrl(_, _, Eq(url1)))
       .Times(1);
   service_impl_->SetDefaultPresentationURL(url1);
   EXPECT_EQ(url1, service_impl_->default_presentation_url_);
 
   std::string url2("http://barUrl");
   // Sets different DPU.
-  content::PresentationSessionStartedCallback callback;
-  EXPECT_CALL(mock_delegate_, SetDefaultPresentationUrl(_, _, Eq(url2), _))
-      .WillOnce(SaveArg<3>(&callback));
+  EXPECT_CALL(mock_delegate_,
+      SetDefaultPresentationUrl(_, _, Eq(url2)))
+      .Times(1);
   service_impl_->SetDefaultPresentationURL(url2);
   EXPECT_EQ(url2, service_impl_->default_presentation_url_);
-
-  presentation::PresentationSessionInfo session_info;
-  session_info.url = url2;
-  session_info.id = kPresentationId;
-  EXPECT_CALL(mock_client_, OnDefaultSessionStarted(Equals(session_info)))
-      .Times(1);
-  callback.Run(content::PresentationSessionInfo(url2, kPresentationId));
 }
 
 TEST_F(PresentationServiceImplTest, SetSameDefaultPresentationUrl) {
   EXPECT_CALL(mock_delegate_,
-              SetDefaultPresentationUrl(_, _, Eq(kPresentationUrl), _))
+      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_);
 }
@@ skipping 104 matching lines @@
   // 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();
 }
 
+TEST_F(PresentationServiceImplTest, ListenForDefaultSessionStart) {
+  presentation::PresentationSessionInfo expected_session;
+  expected_session.url = kPresentationUrl;
+  expected_session.id = kPresentationId;
+  service_ptr_->ListenForDefaultSessionStart(
+      base::Bind(&PresentationServiceImplTest::ExpectDefaultSessionStarted,
+                 base::Unretained(this),
+                 expected_session));
+  RunLoopFor(base::TimeDelta::FromMilliseconds(50));
+  service_impl_->OnDefaultPresentationStarted(
+      content::PresentationSessionInfo(kPresentationUrl, kPresentationId));
+  SaveQuitClosureAndRunLoop();
+  EXPECT_EQ(1, default_session_started_count_);
+}
+
+TEST_F(PresentationServiceImplTest, ListenForDefaultSessionStartAfterSet) {
+  // Note that the callback will only pick up presentation_url2/id2 since
+  // ListenForDefaultSessionStart wasn't called yet when the DPU was still
+  // presentation_url1.
+  std::string presentation_url1("http://fooUrl1");
+  std::string presentation_id1("presentationId1");
+  std::string presentation_url2("http://fooUrl2");
+  std::string presentation_id2("presentationId2");
+  service_impl_->OnDefaultPresentationStarted(
+      content::PresentationSessionInfo(presentation_url1, presentation_id1));
+
+  presentation::PresentationSessionInfo expected_session;
+  expected_session.url = presentation_url2;
+  expected_session.id = presentation_id2;
+  service_ptr_->ListenForDefaultSessionStart(
+      base::Bind(&PresentationServiceImplTest::ExpectDefaultSessionStarted,
+                 base::Unretained(this),
+                 expected_session));
+  RunLoopFor(base::TimeDelta::FromMilliseconds(50));
+  service_impl_->OnDefaultPresentationStarted(
+      content::PresentationSessionInfo(presentation_url2, presentation_id2));
+  SaveQuitClosureAndRunLoop();
+  EXPECT_EQ(1, default_session_started_count_);
+}
+
+TEST_F(PresentationServiceImplTest, DefaultSessionStartReset) {
+  service_ptr_->ListenForDefaultSessionStart(
+      base::Bind(&PresentationServiceImplTest::ExpectDefaultSessionNull,
+                 base::Unretained(this)));
+  RunLoopFor(TestTimeouts::tiny_timeout());
+
+  ExpectReset();
+  service_impl_->Reset();
+  ExpectCleanState();
+  SaveQuitClosureAndRunLoop();
+  EXPECT_EQ(1, default_session_started_count_);
+}
+
 TEST_F(PresentationServiceImplTest, SendStringMessage) {
   std::string message("Test presentation session message");
 
   presentation::PresentationSessionInfoPtr session(
       presentation::PresentationSessionInfo::New());
   session->url = kPresentationUrl;
   session->id = kPresentationId;
   presentation::SessionMessagePtr message_request(
       presentation::SessionMessage::New());
   message_request->type = presentation::PresentationMessageType::
@@ skipping 188 matching lines @@
 
 TEST_F(PresentationServiceImplTest, ScreenAvailabilityNotSupported) {
   mock_delegate_.set_screen_availability_listening_supported(false);
   EXPECT_CALL(mock_client_,
               OnScreenAvailabilityNotSupported(Eq(kPresentationUrl)));
 
   ListenForScreenAvailabilityAndWait(kPresentationUrl, false);
 }
 
 }  // namespace content