[Presentation API] Additional plumbing for PresentationServiceImpl.

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 "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "content/browser/presentation/presentation_service_impl.h"
 #include "content/public/browser/presentation_service_delegate.h"
+#include "content/public/browser/presentation_session.h"
 #include "content/test/test_render_frame_host.h"
 #include "content/test/test_render_view_host.h"
 #include "content/test/test_web_contents.h"
 #include "mojo/public/cpp/bindings/interface_ptr.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using ::testing::_;
 using ::testing::Eq;
 using ::testing::InvokeWithoutArgs;
 using ::testing::Mock;
 using ::testing::Return;
+using ::testing::SaveArg;
 
 namespace content {
 
 class MockPresentationServiceDelegate : public PresentationServiceDelegate {
  public:
   MOCK_METHOD1(AddObserver,
       void(PresentationServiceDelegate::Observer* observer));
   MOCK_METHOD1(RemoveObserver,
       void(PresentationServiceDelegate::Observer* observer));
   MOCK_METHOD3(AddScreenAvailabilityListener,
       bool(
           int render_process_id,
           int routing_id,
           PresentationScreenAvailabilityListener* listener));
   MOCK_METHOD3(RemoveScreenAvailabilityListener,
       void(
           int render_process_id,
           int routing_id,
           PresentationScreenAvailabilityListener* listener));
   MOCK_METHOD2(RemoveAllScreenAvailabilityListeners,
       void(
           int render_process_id,
           int routing_id));
+  MOCK_METHOD3(SetDefaultPresentationUrl,
+      void(
+          int render_process_id,
+          int routing_id,
+          const std::string& default_presentation_url));
+  MOCK_METHOD6(StartSession,
+      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_METHOD6(JoinSession,
+      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));
 };
 
 class PresentationServiceImplTest : public RenderViewHostImplTestHarness {
  public:
   PresentationServiceImplTest() : callback_count_(0) {}
 
   void SetUp() override {
     RenderViewHostImplTestHarness::SetUp();
 
     EXPECT_CALL(mock_delegate_, AddObserver(_)).Times(1);
@@ skipping 32 matching lines @@
 
     EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_delegate_));
   }
 
   void ExpectListenerDoesNotExist(const std::string& presentation_url) {
     const auto& contexts = service_impl_->availability_contexts_;
     auto it = contexts.find(presentation_url);
     EXPECT_TRUE(it == contexts.end());
   }
 
+  void RunLoopUntilIdle() {
+    base::RunLoop().RunUntilIdle();
+  }
+
   void RunLoopFor(base::TimeDelta duration) {
     base::RunLoop run_loop;
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE, run_loop.QuitClosure(), duration);
     run_loop.Run();
   }
 
   void SaveQuitClosureAndRunLoop() {
     base::RunLoop run_loop;
     run_loop_quit_closure_ = run_loop.QuitClosure();
@@ skipping 13 matching lines @@
     it->second->OnScreenAvailabilityChanged(available);
   }
 
   void ScreenAvailabilityChangedCallback(bool expected, bool available) {
     ++callback_count_;
     EXPECT_EQ(expected, available);
     if (!run_loop_quit_closure_.is_null())
       run_loop_quit_closure_.Run();
   }
 
+  void ExpectReset() {
+    EXPECT_CALL(mock_delegate_, RemoveAllScreenAvailabilityListeners(_, _))
+        .Times(1);
+    EXPECT_CALL(mock_delegate_, SetDefaultPresentationUrl(_, _, Eq("")))
+        .Times(1);
+  }
+
+  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();
+  }
+
   MockPresentationServiceDelegate mock_delegate_;
   scoped_ptr<PresentationServiceImpl> service_impl_;
   mojo::InterfacePtr<presentation::PresentationService> service_ptr_;
   base::Closure run_loop_quit_closure_;
   int callback_count_;
 };
 
 TEST_F(PresentationServiceImplTest, GetScreenAvailability) {
   std::string presentation_url("http://fooUrl");
   GetScreenAvailabilityAndWait(
@@ skipping 24 matching lines @@
   service_ptr_->GetScreenAvailability(
       presentation_url,
       base::Bind(
           &PresentationServiceImplTest::ScreenAvailabilityChangedCallback,
           base::Unretained(this),
           false));
   SaveQuitClosureAndRunLoop();
   EXPECT_EQ(2, callback_count_);
 }
 
-TEST_F(PresentationServiceImplTest, RemoveAllListeners) {
+TEST_F(PresentationServiceImplTest, Reset) {
   std::string presentation_url("http://fooUrl");
   GetScreenAvailabilityAndWait(
       presentation_url,
       base::Bind(&PresentationServiceImplTest::ShouldNotBeCalled,
           base::Unretained(this)),
       true);
 
-  service_impl_->RemoveAllListeners();
+  ExpectReset();
+  service_impl_->Reset();
 
   ExpectListenerDoesNotExist(presentation_url);
 
   EXPECT_EQ(0, callback_count_);
 }
 
 TEST_F(PresentationServiceImplTest, DidNavigateThisFrame) {
   std::string presentation_url("http://fooUrl");
   GetScreenAvailabilityAndWait(
       presentation_url,
       base::Bind(&PresentationServiceImplTest::ShouldNotBeCalled,
           base::Unretained(this)),
       true);
 
+  ExpectReset();
   service_impl_->DidNavigateAnyFrame(
       contents()->GetMainFrame(),
       content::LoadCommittedDetails(),
       content::FrameNavigateParams());
 
   ExpectListenerDoesNotExist(presentation_url);
 }
 
 TEST_F(PresentationServiceImplTest, DidNavigateNotThisFrame) {
   std::string presentation_url("http://fooUrl");
@@ skipping 19 matching lines @@
 }
 
 TEST_F(PresentationServiceImplTest, ThisRenderFrameDeleted) {
   std::string presentation_url("http://fooUrl");
   GetScreenAvailabilityAndWait(
       presentation_url,
       base::Bind(&PresentationServiceImplTest::ShouldNotBeCalled,
           base::Unretained(this)),
       true);
 
+  ExpectReset();
   service_impl_->RenderFrameDeleted(contents()->GetMainFrame());
 
   ExpectListenerDoesNotExist(presentation_url);
 }
 
 TEST_F(PresentationServiceImplTest, NotThisRenderFrameDeleted) {
     std::string presentation_url("http://fooUrl");
   GetScreenAvailabilityAndWait(
       presentation_url,
       base::Bind(
@@ skipping 44 matching lines @@
   std::string presentation_url("http://fooUrl");
   GetScreenAvailabilityAndWait(
       presentation_url,
       base::Bind(&PresentationServiceImplTest::ShouldNotBeCalled,
           base::Unretained(this)),
       false);
 
   ExpectListenerDoesNotExist(presentation_url);
 }
 
+TEST_F(PresentationServiceImplTest, SetDefaultPresentationUrl) {
+  std::string url1("http://fooUrl");
+  EXPECT_CALL(mock_delegate_, SetDefaultPresentationUrl(_, _, Eq(url1)))
+        .Times(1);
+  service_impl_->SetDefaultPresentationUrl(url1);
+
+  std::string url2("http://barUrl");
+  EXPECT_CALL(mock_delegate_, SetDefaultPresentationUrl(_, _, Eq(url2)))
+        .Times(1);
+  service_impl_->SetDefaultPresentationUrl(url2);
+}
+
+TEST_F(PresentationServiceImplTest, SetSameDefaultPresentationUrl) {
+  std::string url("http://fooUrl");
+  EXPECT_CALL(mock_delegate_, SetDefaultPresentationUrl(_, _, Eq(url)))
+        .Times(1);
+  service_impl_->SetDefaultPresentationUrl(url);
+  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_delegate_));
+
+  // Same URL as before; no-ops.
+  service_impl_->SetDefaultPresentationUrl(url);
+  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_delegate_));
+}
+
+TEST_F(PresentationServiceImplTest, ClearDefaultPresentationUrl) {
+  std::string url("http://fooUrl");
+  EXPECT_CALL(mock_delegate_, SetDefaultPresentationUrl(_, _, Eq(url)))
+        .Times(1);
+  service_impl_->SetDefaultPresentationUrl(url);
+
+  // Clears the default presentation URL.
+  EXPECT_CALL(
+      mock_delegate_,
+      SetDefaultPresentationUrl(_, _, Eq(std::string())))
+      .Times(1);
+  service_impl_->SetDefaultPresentationUrl(std::string());
+  EXPECT_TRUE(service_impl_->default_presentation_url_.empty());
+}
+
+TEST_F(PresentationServiceImplTest, StartSessionSuccess) {
+  std::string presentation_url("http://fooUrl");
+  std::string presentation_id("presentationId");
+  service_ptr_->StartSession(
+      presentation_url,
+      presentation_id,
+      base::Bind(
+          &PresentationServiceImplTest::ExpectNewSessionMojoCallbackSuccess,
+          base::Unretained(this)));
+  base::Callback<void(const PresentationSessionInfo&)> success_cb;
+  EXPECT_CALL(mock_delegate_, StartSession(
+      _, _, Eq(presentation_url), Eq(presentation_id), _, _))
+      .WillOnce(SaveArg<4>(&success_cb));
+  RunLoopUntilIdle();
+  success_cb.Run(PresentationSessionInfo(presentation_url, presentation_id));
+  SaveQuitClosureAndRunLoop();
+}
+
+TEST_F(PresentationServiceImplTest, StartSessionError) {
+  std::string presentation_url("http://fooUrl");
+  std::string presentation_id("presentationId");
+  service_ptr_->StartSession(
+      presentation_url,
+      presentation_id,
+      base::Bind(
+          &PresentationServiceImplTest::ExpectNewSessionMojoCallbackError,
+          base::Unretained(this)));
+  base::Callback<void(const PresentationError&)> error_cb;
+  EXPECT_CALL(mock_delegate_, StartSession(
+      _, _, Eq(presentation_url), Eq(presentation_id), _, _))
+      .WillOnce(SaveArg<5>(&error_cb));
+  RunLoopUntilIdle();
+  error_cb.Run(PresentationError(PRESENTATION_ERROR_UNKNOWN, "Error message"));
+  SaveQuitClosureAndRunLoop();
+}
+
+TEST_F(PresentationServiceImplTest, JoinSessionSuccess) {
+  std::string presentation_url("http://fooUrl");
+  std::string presentation_id("presentationId");
+  service_ptr_->JoinSession(
+      presentation_url,
+      presentation_id,
+      base::Bind(
+          &PresentationServiceImplTest::ExpectNewSessionMojoCallbackSuccess,
+          base::Unretained(this)));
+  base::Callback<void(const PresentationSessionInfo&)> success_cb;
+  EXPECT_CALL(mock_delegate_, JoinSession(
+      _, _, Eq(presentation_url), Eq(presentation_id), _, _))
+      .WillOnce(SaveArg<4>(&success_cb));
+  RunLoopUntilIdle();
+  success_cb.Run(PresentationSessionInfo(presentation_url, presentation_id));
+  SaveQuitClosureAndRunLoop();
+}
+
+TEST_F(PresentationServiceImplTest, JoinSessionError) {
+  std::string presentation_url("http://fooUrl");
+  std::string presentation_id("presentationId");
+  service_ptr_->JoinSession(
+      presentation_url,
+      presentation_id,
+      base::Bind(
+          &PresentationServiceImplTest::ExpectNewSessionMojoCallbackError,
+          base::Unretained(this)));
+  base::Callback<void(const PresentationError&)> error_cb;
+  EXPECT_CALL(mock_delegate_, JoinSession(
+      _, _, Eq(presentation_url), Eq(presentation_id), _, _))
+      .WillOnce(SaveArg<5>(&error_cb));
+  RunLoopUntilIdle();
+  error_cb.Run(PresentationError(PRESENTATION_ERROR_UNKNOWN, "Error message"));
+  SaveQuitClosureAndRunLoop();
+}
+
+TEST_F(PresentationServiceImplTest, StartSessionInProgress) {
+  std::string presentation_url("http://fooUrl");
+  std::string presentation_id("presentationId");
+  service_ptr_->StartSession(
+      presentation_url,
+      presentation_id,
+      base::Bind(
+          &PresentationServiceImplTest::ExpectNewSessionMojoCallbackSuccess,
+          base::Unretained(this)));
+  service_ptr_->StartSession(
+      presentation_url,
+      presentation_id,
+      base::Bind(
+          &PresentationServiceImplTest::ExpectNewSessionMojoCallbackSuccess,
+          base::Unretained(this)));
+  EXPECT_CALL(mock_delegate_, StartSession(
+      _, _, Eq(presentation_url), Eq(presentation_id), _, _))
+      .Times(1);
+  RunLoopUntilIdle();
+}
+
 }  // namespace content