Reland of: [Presentation API] Implement ondefaultsessionstart in PSImpl.

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 "base/test/test_timeouts.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 {
 
+namespace {
+
+bool ArePresentationSessionsEqual(
+    const presentation::PresentationSessionInfo& expected,
+    const presentation::PresentationSessionInfo& actual) {
+  return expected.url == actual.url && expected.id == actual.id;
+}
+}  // namespace
+
 class MockPresentationServiceDelegate : public PresentationServiceDelegate {
  public:
-  MOCK_METHOD1(AddObserver,
-      void(PresentationServiceDelegate::Observer* observer));
-  MOCK_METHOD1(RemoveObserver,
-      void(PresentationServiceDelegate::Observer* observer));
+  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_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));
@@ skipping 20 matching lines @@
           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) {}
+  PresentationServiceImplTest()
+      : callback_count_(0), default_session_started_count_(0) {}
 
   void SetUp() override {
     RenderViewHostImplTestHarness::SetUp();
 
     auto request = mojo::GetProxy(&service_ptr_);
-    EXPECT_CALL(mock_delegate_, AddObserver(_)).Times(1);
+
+    EXPECT_CALL(mock_delegate_, AddObserver(_, _, _)).Times(1);
     service_impl_.reset(new PresentationServiceImpl(
         contents()->GetMainFrame(), contents(), &mock_delegate_));
     service_impl_->Bind(request.Pass());
   }
 
   void TearDown() override {
     service_ptr_.reset();
     if (service_impl_.get()) {
-      EXPECT_CALL(mock_delegate_, RemoveObserver(Eq(service_impl_.get())))
-          .Times(1);
+      EXPECT_CALL(mock_delegate_, RemoveObserver(_, _)).Times(1);
       service_impl_.reset();
     }
-
     RenderViewHostImplTestHarness::TearDown();
   }
 
   void ListenForScreenAvailabilityAndWait(
       const std::string& presentation_url,
       const base::Callback<void(const std::string&, bool)>& callback,
       bool delegate_success) {
     base::RunLoop run_loop;
     // This will call to |service_impl_| via mojo. Process the message
     // using RunLoop.
@@ skipping 46 matching lines @@
       bool expected,
       const std::string& presentation_url,
       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_, Reset(_, _))
-        .Times(1);
+    EXPECT_CALL(mock_delegate_, Reset(_, _)).Times(1);
   }
 
   void ExpectCleanState() {
     EXPECT_TRUE(service_impl_->availability_contexts_.empty());
     EXPECT_TRUE(service_impl_->default_presentation_url_.empty());
     EXPECT_TRUE(service_impl_->default_presentation_id_.empty());
     EXPECT_TRUE(service_impl_->queued_start_session_requests_.empty());
+    EXPECT_FALSE(service_impl_->default_session_start_context_.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();
+  }
+
   MockPresentationServiceDelegate mock_delegate_;
   scoped_ptr<PresentationServiceImpl> service_impl_;
   mojo::InterfacePtr<presentation::PresentationService> service_ptr_;
   base::Closure run_loop_quit_closure_;
   int callback_count_;
+  int default_session_started_count_;
 };
 
 TEST_F(PresentationServiceImplTest, ListenForScreenAvailability) {
   std::string presentation_url("http://fooUrl");
   ListenForScreenAvailabilityAndWait(
       presentation_url,
       base::Bind(
           &PresentationServiceImplTest::ScreenAvailabilityChangedCallback,
           base::Unretained(this), true),
       true);
@@ skipping 85 matching lines @@
   ListenForScreenAvailabilityAndWait(
       presentation_url,
       base::Bind(&PresentationServiceImplTest::ShouldNotBeCalled,
           base::Unretained(this)),
       true);
 
   ExpectReset();
 
   // Since the frame matched the service, |service_impl_| will be deleted.
   PresentationServiceImpl* service = service_impl_.release();
-  EXPECT_CALL(mock_delegate_, RemoveObserver(Eq(service))).Times(1);
+  EXPECT_CALL(mock_delegate_, RemoveObserver(_, _)).Times(1);
   service->RenderFrameDeleted(contents()->GetMainFrame());
 }
 
 TEST_F(PresentationServiceImplTest, NotThisRenderFrameDeleted) {
     std::string presentation_url("http://fooUrl");
   ListenForScreenAvailabilityAndWait(
       presentation_url,
       base::Bind(
           &PresentationServiceImplTest::ScreenAvailabilityChangedCallback,
           base::Unretained(this),
@@ skipping 266 matching lines @@
 
   // Running the callback means the first request is done. It should now
   // move on to the queued request.
   EXPECT_CALL(mock_delegate_, StartSession(
       _, _, Eq(presentation_url2), Eq(presentation_id2), _, _))
       .Times(1);
   success_cb.Run(PresentationSessionInfo(presentation_url1, presentation_id1));
   SaveQuitClosureAndRunLoop();
 }
 
+TEST_F(PresentationServiceImplTest, ListenForDefaultSessionStart) {
+  std::string presentation_url1("http://fooUrl1");
+  std::string presentation_id1("presentationId1");
+  presentation::PresentationSessionInfo expected_session;
+  expected_session.url = presentation_url1;
+  expected_session.id = presentation_id1;
+  service_ptr_->ListenForDefaultSessionStart(
+      base::Bind(&PresentationServiceImplTest::ExpectDefaultSessionStarted,
+                 base::Unretained(this),
+                 expected_session));
+  RunLoopFor(base::TimeDelta::FromMilliseconds(50));
+  service_impl_->OnDefaultPresentationStarted(
+      content::PresentationSessionInfo(presentation_url1, presentation_id1));
+  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_);
+}
+
 }  // namespace content