content/browser/notifications/notification_event_dispatcher_impl_unittest.cc - chromium/src - Git at Google

 // Copyright 2018 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "content/browser/notifications/notification_event_dispatcher_impl.h"

 #include <stdint.h>
 #include <memory>
 #include <utility>
 #include <vector>

 #include "base/functional/callback_helpers.h"
 #include "base/test/task_environment.h"
 #include "base/test/test_simple_task_runner.h"
 #include "content/browser/renderer_host/render_frame_host_impl.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/test/test_renderer_host.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/bindings/receiver.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/mojom/notifications/notification_service.mojom.h"

 namespace content {

 namespace {

 const char kPrimaryUniqueId[] = "this_should_be_a_unique_id";
 const char kSomeOtherUniqueId[] = "and_this_one_is_different_and_also_unique";

 class TestNotificationListener
     : public blink::mojom::NonPersistentNotificationListener {
  public:
   TestNotificationListener() = default;

   TestNotificationListener(const TestNotificationListener&) = delete;
   TestNotificationListener& operator=(const TestNotificationListener&) = delete;

   ~TestNotificationListener() override = default;

   // Closes the bindings associated with this listener.
   void Close() { receiver_.reset(); }

   // Returns an InterfacePtr to this listener.
   mojo::PendingRemote<blink::mojom::NonPersistentNotificationListener>
   GetRemote() {
     mojo::PendingRemote<blink::mojom::NonPersistentNotificationListener> remote;
     receiver_.Bind(remote.InitWithNewPipeAndPassReceiver());
     return remote;
   }

   // Returns the number of OnShow events received by this listener.
   int on_show_count() const { return on_show_count_; }

   // Returns the number of OnClick events received by this listener.
   int on_click_count() const { return on_click_count_; }

   // Returns the number of OnClose events received by this listener.
   int on_close_count() const { return on_close_count_; }

   // blink::mojom::NonPersistentNotificationListener implementation.
   void OnShow() override { on_show_count_++; }
   void OnClick(OnClickCallback completed_closure) override {
     on_click_count_++;
     std::move(completed_closure).Run();
   }
   void OnClose(OnCloseCallback completed_closure) override {
     on_close_count_++;
     std::move(completed_closure).Run();
   }

  private:
   int on_show_count_ = 0;
   int on_click_count_ = 0;
   int on_close_count_ = 0;
   mojo::Receiver<blink::mojom::NonPersistentNotificationListener> receiver_{
       this};
 };

 }  // anonymous namespace

 class NotificationEventDispatcherImplTest : public RenderViewHostTestHarness {
  public:
   NotificationEventDispatcherImplTest()
       : dispatcher_(new NotificationEventDispatcherImpl(), Deleter) {}

   NotificationEventDispatcherImplTest(
       const NotificationEventDispatcherImplTest&) = delete;
   NotificationEventDispatcherImplTest& operator=(
       const NotificationEventDispatcherImplTest&) = delete;

   ~NotificationEventDispatcherImplTest() override = default;

   // Waits until the task runner managing the Mojo connection has finished.
   void WaitForMojoTasksToComplete() { task_environment()->RunUntilIdle(); }

   static void Deleter(NotificationEventDispatcherImpl* dispatcher) {
     delete dispatcher;
   }

  protected:
   struct CreatorTypeTestData {
     RenderProcessHost::NotificationServiceCreatorType creator_type;
     bool is_document_pointer_empty;
     bool is_show_event_dispatched;
     bool is_click_event_dispatched;
     bool is_close_event_dispatched;
   };

   std::unique_ptr<NotificationEventDispatcherImpl, decltype(&Deleter)>
       dispatcher_;
 };

 TEST_F(NotificationEventDispatcherImplTest,
        DispatchNonPersistentShowEvent_NotifiesCorrectRegisteredListener) {
   auto listener = std::make_unique<TestNotificationListener>();
   dispatcher_->RegisterNonPersistentNotificationListener(
       kPrimaryUniqueId, listener->GetRemote(), main_rfh()->GetWeakDocumentPtr(),
       RenderProcessHost::NotificationServiceCreatorType::kDocument);
   auto other_listener = std::make_unique<TestNotificationListener>();
   dispatcher_->RegisterNonPersistentNotificationListener(
       kSomeOtherUniqueId, other_listener->GetRemote(),
       main_rfh()->GetWeakDocumentPtr(),
       RenderProcessHost::NotificationServiceCreatorType::kDocument);

   dispatcher_->DispatchNonPersistentShowEvent(kPrimaryUniqueId);

   WaitForMojoTasksToComplete();

   EXPECT_EQ(listener->on_show_count(), 1);
   EXPECT_EQ(other_listener->on_show_count(), 0);

   dispatcher_->DispatchNonPersistentShowEvent(kSomeOtherUniqueId);

   WaitForMojoTasksToComplete();

   EXPECT_EQ(listener->on_show_count(), 1);
   EXPECT_EQ(other_listener->on_show_count(), 1);
 }

 TEST_F(NotificationEventDispatcherImplTest,
        DispatchNonPersistentEvent_RegisterListenerWithDifferentCreatorTypes) {
   // For `kDocument` and `kDedicatedWorker`, if the document pointer is empty,
   // then all the non persistent notification event should not be dispatched.
   // For `kSharedWorker`, the document pointer should always be empty and the
   // event will always be dispatched.
   // Since it's not possible for `kServiceWorker` to create non persistent
   // notification events, the test cases for those two creator types are not
   // added.
   std::vector<CreatorTypeTestData> creator_type_tests{
       {.creator_type =
            RenderProcessHost::NotificationServiceCreatorType::kDocument,
        .is_document_pointer_empty = true,
        .is_show_event_dispatched = false,
        .is_click_event_dispatched = false,
        .is_close_event_dispatched = false},
       {.creator_type =
            RenderProcessHost::NotificationServiceCreatorType::kDocument,
        .is_document_pointer_empty = false,
        .is_show_event_dispatched = true,
        .is_click_event_dispatched = true,
        .is_close_event_dispatched = true},
       {.creator_type =
            RenderProcessHost::NotificationServiceCreatorType::kDedicatedWorker,
        .is_document_pointer_empty = true,
        .is_show_event_dispatched = false,
        .is_click_event_dispatched = false,
        .is_close_event_dispatched = false},
       {.creator_type =
            RenderProcessHost::NotificationServiceCreatorType::kDedicatedWorker,
        .is_document_pointer_empty = false,
        .is_show_event_dispatched = true,
        .is_click_event_dispatched = true,
        .is_close_event_dispatched = true},
       {.creator_type =
            RenderProcessHost::NotificationServiceCreatorType::kSharedWorker,
        .is_document_pointer_empty = true,
        .is_show_event_dispatched = true,
        .is_click_event_dispatched = true,
        .is_close_event_dispatched = true},
   };

   for (auto t : creator_type_tests) {
     int expected_show_count = t.is_show_event_dispatched ? 1 : 0;
     int expected_click_count = t.is_click_event_dispatched ? 1 : 0;
     int expected_close_count = t.is_close_event_dispatched ? 1 : 0;

     auto listener = std::make_unique<TestNotificationListener>();
     dispatcher_->RegisterNonPersistentNotificationListener(
         kPrimaryUniqueId, listener->GetRemote(),
         t.is_document_pointer_empty ? WeakDocumentPtr()
                                     : main_rfh()->GetWeakDocumentPtr(),
         t.creator_type);

     dispatcher_->DispatchNonPersistentShowEvent(kPrimaryUniqueId);

     WaitForMojoTasksToComplete();

     EXPECT_EQ(listener->on_show_count(), expected_show_count);
     EXPECT_EQ(listener->on_click_count(), 0);
     EXPECT_EQ(listener->on_close_count(), 0);

     dispatcher_->DispatchNonPersistentClickEvent(kPrimaryUniqueId,
                                                  base::DoNothing());

     WaitForMojoTasksToComplete();

     EXPECT_EQ(listener->on_show_count(), expected_show_count);
     EXPECT_EQ(listener->on_click_count(), expected_click_count);
     EXPECT_EQ(listener->on_close_count(), 0);

     dispatcher_->DispatchNonPersistentCloseEvent(kPrimaryUniqueId,
                                                  base::DoNothing());

     WaitForMojoTasksToComplete();

     EXPECT_EQ(listener->on_show_count(), expected_show_count);
     EXPECT_EQ(listener->on_click_count(), expected_click_count);
     EXPECT_EQ(listener->on_close_count(), expected_close_count);
   }
 }

 TEST_F(NotificationEventDispatcherImplTest,
        DispatchNonPersistentEvent_DocumentInBFCache) {
   auto listener = std::make_unique<TestNotificationListener>();
   const WeakDocumentPtr document = main_rfh()->GetWeakDocumentPtr();
   RenderFrameHostImpl* rfh =
       static_cast<RenderFrameHostImpl*>(document.AsRenderFrameHostIfValid());
   EXPECT_TRUE(rfh);
   // The rfh should be initially in active lifecycle state.
   EXPECT_TRUE(
       rfh->IsInLifecycleState(RenderFrameHost::LifecycleState::kActive));
   dispatcher_->RegisterNonPersistentNotificationListener(
       kPrimaryUniqueId, listener->GetRemote(), document,
       RenderProcessHost::NotificationServiceCreatorType::kDocument);

   dispatcher_->DispatchNonPersistentShowEvent(kPrimaryUniqueId);

   WaitForMojoTasksToComplete();

   // After dispatching the show and click events when the rfh is active,
   // the counter should increment as expected.
   EXPECT_EQ(listener->on_show_count(), 1);
   EXPECT_EQ(listener->on_click_count(), 0);
   EXPECT_EQ(listener->on_close_count(), 0);

   dispatcher_->DispatchNonPersistentClickEvent(kPrimaryUniqueId,
                                                base::DoNothing());

   WaitForMojoTasksToComplete();

   EXPECT_EQ(listener->on_show_count(), 1);
   EXPECT_EQ(listener->on_click_count(), 1);
   EXPECT_EQ(listener->on_close_count(), 0);

   dispatcher_->DispatchNonPersistentShowEvent(kPrimaryUniqueId);

   WaitForMojoTasksToComplete();

   EXPECT_EQ(listener->on_show_count(), 2);
   EXPECT_EQ(listener->on_click_count(), 1);
   EXPECT_EQ(listener->on_close_count(), 0);

   // Simulate the scenario where the rfh is put into the back/forward cache
   // by setting the lifecycle state explicitly.
   rfh->SetLifecycleState(
       RenderFrameHostImpl::LifecycleStateImpl::kInBackForwardCache);
   EXPECT_TRUE(rfh->IsInLifecycleState(
       RenderFrameHost::LifecycleState::kInBackForwardCache));

   dispatcher_->DispatchNonPersistentClickEvent(kPrimaryUniqueId,
                                                base::DoNothing());

   WaitForMojoTasksToComplete();

   dispatcher_->DispatchNonPersistentCloseEvent(kPrimaryUniqueId,
                                                base::DoNothing());

   WaitForMojoTasksToComplete();

   // Now the dispatched click and close events should not invoke the listener.
   EXPECT_EQ(listener->on_show_count(), 2);
   EXPECT_EQ(listener->on_click_count(), 1);
   EXPECT_EQ(listener->on_close_count(), 0);

   // Simulate the scenario where the rfh is back to active state and
   // dispatch a close event.
   rfh->SetLifecycleState(RenderFrameHostImpl::LifecycleStateImpl::kActive);
   EXPECT_FALSE(rfh->IsInLifecycleState(
       RenderFrameHost::LifecycleState::kInBackForwardCache));

   dispatcher_->DispatchNonPersistentCloseEvent(kPrimaryUniqueId,
                                                base::DoNothing());

   WaitForMojoTasksToComplete();

   // Since the rfh is active, the dispatched close event should result in
   // the increment of the close counter.
   EXPECT_EQ(listener->on_show_count(), 2);
   EXPECT_EQ(listener->on_click_count(), 1);
   EXPECT_EQ(listener->on_close_count(), 1);
 }

 TEST_F(NotificationEventDispatcherImplTest,
        RegisterNonPersistentListener_FirstListenerGetsOnClose) {
   auto original_listener = std::make_unique<TestNotificationListener>();
   dispatcher_->RegisterNonPersistentNotificationListener(
       kPrimaryUniqueId, original_listener->GetRemote(),
       main_rfh()->GetWeakDocumentPtr(),
       RenderProcessHost::NotificationServiceCreatorType::kDocument);

   dispatcher_->DispatchNonPersistentShowEvent(kPrimaryUniqueId);

   ASSERT_EQ(original_listener->on_close_count(), 0);

   auto replacement_listener = std::make_unique<TestNotificationListener>();
   dispatcher_->RegisterNonPersistentNotificationListener(
       kPrimaryUniqueId, replacement_listener->GetRemote(),
       main_rfh()->GetWeakDocumentPtr(),
       RenderProcessHost::NotificationServiceCreatorType::kDocument);

   WaitForMojoTasksToComplete();

   EXPECT_EQ(original_listener->on_close_count(), 1);
   EXPECT_EQ(replacement_listener->on_close_count(), 0);
 }

 TEST_F(NotificationEventDispatcherImplTest,
        RegisterNonPersistentListener_SecondListenerGetsOnShow) {
   auto original_listener = std::make_unique<TestNotificationListener>();
   dispatcher_->RegisterNonPersistentNotificationListener(
       kPrimaryUniqueId, original_listener->GetRemote(),
       main_rfh()->GetWeakDocumentPtr(),
       RenderProcessHost::NotificationServiceCreatorType::kDocument);

   dispatcher_->DispatchNonPersistentShowEvent(kPrimaryUniqueId);

   WaitForMojoTasksToComplete();

   ASSERT_EQ(original_listener->on_show_count(), 1);

   auto replacement_listener = std::make_unique<TestNotificationListener>();
   dispatcher_->RegisterNonPersistentNotificationListener(
       kPrimaryUniqueId, replacement_listener->GetRemote(),
       main_rfh()->GetWeakDocumentPtr(),
       RenderProcessHost::NotificationServiceCreatorType::kDocument);

   dispatcher_->DispatchNonPersistentShowEvent(kPrimaryUniqueId);

   WaitForMojoTasksToComplete();

   ASSERT_EQ(original_listener->on_show_count(), 1);
   ASSERT_EQ(replacement_listener->on_show_count(), 1);
 }

 TEST_F(NotificationEventDispatcherImplTest,
        RegisterNonPersistentListener_ReplacedListenerGetsOnClick) {
   auto original_listener = std::make_unique<TestNotificationListener>();
   dispatcher_->RegisterNonPersistentNotificationListener(
       kPrimaryUniqueId, original_listener->GetRemote(),
       main_rfh()->GetWeakDocumentPtr(),
       RenderProcessHost::NotificationServiceCreatorType::kDocument);

   dispatcher_->DispatchNonPersistentShowEvent(kPrimaryUniqueId);

   auto replacement_listener = std::make_unique<TestNotificationListener>();
   dispatcher_->RegisterNonPersistentNotificationListener(
       kPrimaryUniqueId, replacement_listener->GetRemote(),
       main_rfh()->GetWeakDocumentPtr(),
       RenderProcessHost::NotificationServiceCreatorType::kDocument);

   WaitForMojoTasksToComplete();

   dispatcher_->DispatchNonPersistentClickEvent(kPrimaryUniqueId,
                                                base::DoNothing());

   WaitForMojoTasksToComplete();

   EXPECT_EQ(original_listener->on_click_count(), 0);
   EXPECT_EQ(original_listener->on_close_count(), 1);
   EXPECT_EQ(replacement_listener->on_click_count(), 1);
   EXPECT_EQ(replacement_listener->on_close_count(), 0);
 }

 TEST_F(NotificationEventDispatcherImplTest,
        DispatchNonPersistentClickEvent_NotifiesCorrectRegisteredListener) {
   auto listener = std::make_unique<TestNotificationListener>();
   dispatcher_->RegisterNonPersistentNotificationListener(
       kPrimaryUniqueId, listener->GetRemote(), main_rfh()->GetWeakDocumentPtr(),
       RenderProcessHost::NotificationServiceCreatorType::kDocument);
   auto other_listener = std::make_unique<TestNotificationListener>();
   dispatcher_->RegisterNonPersistentNotificationListener(
       kSomeOtherUniqueId, other_listener->GetRemote(),
       main_rfh()->GetWeakDocumentPtr(),
       RenderProcessHost::NotificationServiceCreatorType::kDocument);

   dispatcher_->DispatchNonPersistentClickEvent(kPrimaryUniqueId,
                                                base::DoNothing());

   WaitForMojoTasksToComplete();

   EXPECT_EQ(listener->on_click_count(), 1);
   EXPECT_EQ(other_listener->on_click_count(), 0);

   dispatcher_->DispatchNonPersistentClickEvent(kSomeOtherUniqueId,
                                                base::DoNothing());

   WaitForMojoTasksToComplete();

   EXPECT_EQ(listener->on_click_count(), 1);
   EXPECT_EQ(other_listener->on_click_count(), 1);
 }

 TEST_F(NotificationEventDispatcherImplTest,
        DispatchNonPersistentCloseEvent_NotifiesCorrectRegisteredListener) {
   auto listener = std::make_unique<TestNotificationListener>();
   dispatcher_->RegisterNonPersistentNotificationListener(
       kPrimaryUniqueId, listener->GetRemote(), main_rfh()->GetWeakDocumentPtr(),
       RenderProcessHost::NotificationServiceCreatorType::kDocument);
   auto other_listener = std::make_unique<TestNotificationListener>();
   dispatcher_->RegisterNonPersistentNotificationListener(
       kSomeOtherUniqueId, other_listener->GetRemote(),
       main_rfh()->GetWeakDocumentPtr(),
       RenderProcessHost::NotificationServiceCreatorType::kDocument);

   dispatcher_->DispatchNonPersistentCloseEvent(kPrimaryUniqueId,
                                                base::DoNothing());

   WaitForMojoTasksToComplete();

   EXPECT_EQ(listener->on_close_count(), 1);
   EXPECT_EQ(other_listener->on_close_count(), 0);

   dispatcher_->DispatchNonPersistentCloseEvent(kSomeOtherUniqueId,
                                                base::DoNothing());

   WaitForMojoTasksToComplete();

   EXPECT_EQ(listener->on_close_count(), 1);
   EXPECT_EQ(other_listener->on_close_count(), 1);
 }

 TEST_F(NotificationEventDispatcherImplTest,
        DispatchMultipleNonPersistentEvents_StopsNotifyingAfterClose) {
   auto listener = std::make_unique<TestNotificationListener>();
   dispatcher_->RegisterNonPersistentNotificationListener(
       kPrimaryUniqueId, listener->GetRemote(), main_rfh()->GetWeakDocumentPtr(),
       RenderProcessHost::NotificationServiceCreatorType::kDocument);

   dispatcher_->DispatchNonPersistentShowEvent(kPrimaryUniqueId);
   dispatcher_->DispatchNonPersistentClickEvent(kPrimaryUniqueId,
                                                base::DoNothing());
   dispatcher_->DispatchNonPersistentCloseEvent(kPrimaryUniqueId,
                                                base::DoNothing());

   WaitForMojoTasksToComplete();

   EXPECT_EQ(listener->on_show_count(), 1);
   EXPECT_EQ(listener->on_click_count(), 1);
   EXPECT_EQ(listener->on_close_count(), 1);

   // Should not be counted as the notification was already closed.
   dispatcher_->DispatchNonPersistentClickEvent(kPrimaryUniqueId,
                                                base::DoNothing());

   WaitForMojoTasksToComplete();

   EXPECT_EQ(listener->on_click_count(), 1);
 }
 }  // namespace content
	// Copyright 2018 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "content/browser/notifications/notification_event_dispatcher_impl.h"

	#include <stdint.h>
	#include <memory>
	#include <utility>
	#include <vector>

	#include "base/functional/callback_helpers.h"
	#include "base/test/task_environment.h"
	#include "base/test/test_simple_task_runner.h"
	#include "content/browser/renderer_host/render_frame_host_impl.h"
	#include "content/public/browser/render_process_host.h"
	#include "content/public/test/test_renderer_host.h"
	#include "mojo/public/cpp/bindings/pending_remote.h"
	#include "mojo/public/cpp/bindings/receiver.h"
	#include "testing/gtest/include/gtest/gtest.h"
	#include "third_party/blink/public/mojom/notifications/notification_service.mojom.h"

	namespace content {

	namespace {

	const char kPrimaryUniqueId[] = "this_should_be_a_unique_id";
	const char kSomeOtherUniqueId[] = "and_this_one_is_different_and_also_unique";

	class TestNotificationListener
	: public blink::mojom::NonPersistentNotificationListener {
	public:
	TestNotificationListener() = default;

	TestNotificationListener(const TestNotificationListener&) = delete;
	TestNotificationListener& operator=(const TestNotificationListener&) = delete;

	~TestNotificationListener() override = default;

	// Closes the bindings associated with this listener.
	void Close() { receiver_.reset(); }

	// Returns an InterfacePtr to this listener.
	mojo::PendingRemote<blink::mojom::NonPersistentNotificationListener>
	GetRemote() {
	mojo::PendingRemote<blink::mojom::NonPersistentNotificationListener> remote;
	receiver_.Bind(remote.InitWithNewPipeAndPassReceiver());
	return remote;
	}

	// Returns the number of OnShow events received by this listener.
	int on_show_count() const { return on_show_count_; }

	// Returns the number of OnClick events received by this listener.
	int on_click_count() const { return on_click_count_; }

	// Returns the number of OnClose events received by this listener.
	int on_close_count() const { return on_close_count_; }

	// blink::mojom::NonPersistentNotificationListener implementation.
	void OnShow() override { on_show_count_++; }
	void OnClick(OnClickCallback completed_closure) override {
	on_click_count_++;
	std::move(completed_closure).Run();
	}
	void OnClose(OnCloseCallback completed_closure) override {
	on_close_count_++;
	std::move(completed_closure).Run();
	}

	private:
	int on_show_count_ = 0;
	int on_click_count_ = 0;
	int on_close_count_ = 0;
	mojo::Receiver<blink::mojom::NonPersistentNotificationListener> receiver_{
	this};
	};

	} // anonymous namespace

	class NotificationEventDispatcherImplTest : public RenderViewHostTestHarness {
	public:
	NotificationEventDispatcherImplTest()
	: dispatcher_(new NotificationEventDispatcherImpl(), Deleter) {}

	NotificationEventDispatcherImplTest(
	const NotificationEventDispatcherImplTest&) = delete;
	NotificationEventDispatcherImplTest& operator=(
	const NotificationEventDispatcherImplTest&) = delete;

	~NotificationEventDispatcherImplTest() override = default;

	// Waits until the task runner managing the Mojo connection has finished.
	void WaitForMojoTasksToComplete() { task_environment()->RunUntilIdle(); }

	static void Deleter(NotificationEventDispatcherImpl* dispatcher) {
	delete dispatcher;
	}

	protected:
	struct CreatorTypeTestData {
	RenderProcessHost::NotificationServiceCreatorType creator_type;
	bool is_document_pointer_empty;
	bool is_show_event_dispatched;
	bool is_click_event_dispatched;
	bool is_close_event_dispatched;
	};

	std::unique_ptr<NotificationEventDispatcherImpl, decltype(&Deleter)>
	dispatcher_;
	};

	TEST_F(NotificationEventDispatcherImplTest,
	DispatchNonPersistentShowEvent_NotifiesCorrectRegisteredListener) {
	auto listener = std::make_unique<TestNotificationListener>();
	dispatcher_->RegisterNonPersistentNotificationListener(
	kPrimaryUniqueId, listener->GetRemote(), main_rfh()->GetWeakDocumentPtr(),
	RenderProcessHost::NotificationServiceCreatorType::kDocument);
	auto other_listener = std::make_unique<TestNotificationListener>();
	dispatcher_->RegisterNonPersistentNotificationListener(
	kSomeOtherUniqueId, other_listener->GetRemote(),
	main_rfh()->GetWeakDocumentPtr(),
	RenderProcessHost::NotificationServiceCreatorType::kDocument);

	dispatcher_->DispatchNonPersistentShowEvent(kPrimaryUniqueId);

	WaitForMojoTasksToComplete();

	EXPECT_EQ(listener->on_show_count(), 1);
	EXPECT_EQ(other_listener->on_show_count(), 0);

	dispatcher_->DispatchNonPersistentShowEvent(kSomeOtherUniqueId);

	WaitForMojoTasksToComplete();

	EXPECT_EQ(listener->on_show_count(), 1);
	EXPECT_EQ(other_listener->on_show_count(), 1);
	}

	TEST_F(NotificationEventDispatcherImplTest,
	DispatchNonPersistentEvent_RegisterListenerWithDifferentCreatorTypes) {
	// For `kDocument` and `kDedicatedWorker`, if the document pointer is empty,
	// then all the non persistent notification event should not be dispatched.
	// For `kSharedWorker`, the document pointer should always be empty and the
	// event will always be dispatched.
	// Since it's not possible for `kServiceWorker` to create non persistent
	// notification events, the test cases for those two creator types are not
	// added.
	std::vector<CreatorTypeTestData> creator_type_tests{
	{.creator_type =
	RenderProcessHost::NotificationServiceCreatorType::kDocument,
	.is_document_pointer_empty = true,
	.is_show_event_dispatched = false,
	.is_click_event_dispatched = false,
	.is_close_event_dispatched = false},
	{.creator_type =
	RenderProcessHost::NotificationServiceCreatorType::kDocument,
	.is_document_pointer_empty = false,
	.is_show_event_dispatched = true,
	.is_click_event_dispatched = true,
	.is_close_event_dispatched = true},
	{.creator_type =
	RenderProcessHost::NotificationServiceCreatorType::kDedicatedWorker,
	.is_document_pointer_empty = true,
	.is_show_event_dispatched = false,
	.is_click_event_dispatched = false,
	.is_close_event_dispatched = false},
	{.creator_type =
	RenderProcessHost::NotificationServiceCreatorType::kDedicatedWorker,
	.is_document_pointer_empty = false,
	.is_show_event_dispatched = true,
	.is_click_event_dispatched = true,
	.is_close_event_dispatched = true},
	{.creator_type =
	RenderProcessHost::NotificationServiceCreatorType::kSharedWorker,
	.is_document_pointer_empty = true,
	.is_show_event_dispatched = true,
	.is_click_event_dispatched = true,
	.is_close_event_dispatched = true},
	};

	for (auto t : creator_type_tests) {
	int expected_show_count = t.is_show_event_dispatched ? 1 : 0;
	int expected_click_count = t.is_click_event_dispatched ? 1 : 0;
	int expected_close_count = t.is_close_event_dispatched ? 1 : 0;

	auto listener = std::make_unique<TestNotificationListener>();
	dispatcher_->RegisterNonPersistentNotificationListener(
	kPrimaryUniqueId, listener->GetRemote(),
	t.is_document_pointer_empty ? WeakDocumentPtr()
	: main_rfh()->GetWeakDocumentPtr(),
	t.creator_type);

	dispatcher_->DispatchNonPersistentShowEvent(kPrimaryUniqueId);

	WaitForMojoTasksToComplete();

	EXPECT_EQ(listener->on_show_count(), expected_show_count);
	EXPECT_EQ(listener->on_click_count(), 0);
	EXPECT_EQ(listener->on_close_count(), 0);

	dispatcher_->DispatchNonPersistentClickEvent(kPrimaryUniqueId,
	base::DoNothing());

	WaitForMojoTasksToComplete();

	EXPECT_EQ(listener->on_show_count(), expected_show_count);
	EXPECT_EQ(listener->on_click_count(), expected_click_count);
	EXPECT_EQ(listener->on_close_count(), 0);

	dispatcher_->DispatchNonPersistentCloseEvent(kPrimaryUniqueId,
	base::DoNothing());

	WaitForMojoTasksToComplete();

	EXPECT_EQ(listener->on_show_count(), expected_show_count);
	EXPECT_EQ(listener->on_click_count(), expected_click_count);
	EXPECT_EQ(listener->on_close_count(), expected_close_count);
	}
	}

	TEST_F(NotificationEventDispatcherImplTest,
	DispatchNonPersistentEvent_DocumentInBFCache) {
	auto listener = std::make_unique<TestNotificationListener>();
	const WeakDocumentPtr document = main_rfh()->GetWeakDocumentPtr();
	RenderFrameHostImpl* rfh =
	static_cast<RenderFrameHostImpl*>(document.AsRenderFrameHostIfValid());
	EXPECT_TRUE(rfh);
	// The rfh should be initially in active lifecycle state.
	EXPECT_TRUE(
	rfh->IsInLifecycleState(RenderFrameHost::LifecycleState::kActive));
	dispatcher_->RegisterNonPersistentNotificationListener(
	kPrimaryUniqueId, listener->GetRemote(), document,
	RenderProcessHost::NotificationServiceCreatorType::kDocument);

	dispatcher_->DispatchNonPersistentShowEvent(kPrimaryUniqueId);

	WaitForMojoTasksToComplete();

	// After dispatching the show and click events when the rfh is active,
	// the counter should increment as expected.
	EXPECT_EQ(listener->on_show_count(), 1);
	EXPECT_EQ(listener->on_click_count(), 0);
	EXPECT_EQ(listener->on_close_count(), 0);

	dispatcher_->DispatchNonPersistentClickEvent(kPrimaryUniqueId,
	base::DoNothing());

	WaitForMojoTasksToComplete();

	EXPECT_EQ(listener->on_show_count(), 1);
	EXPECT_EQ(listener->on_click_count(), 1);
	EXPECT_EQ(listener->on_close_count(), 0);

	dispatcher_->DispatchNonPersistentShowEvent(kPrimaryUniqueId);

	WaitForMojoTasksToComplete();

	EXPECT_EQ(listener->on_show_count(), 2);
	EXPECT_EQ(listener->on_click_count(), 1);
	EXPECT_EQ(listener->on_close_count(), 0);

	// Simulate the scenario where the rfh is put into the back/forward cache
	// by setting the lifecycle state explicitly.
	rfh->SetLifecycleState(
	RenderFrameHostImpl::LifecycleStateImpl::kInBackForwardCache);
	EXPECT_TRUE(rfh->IsInLifecycleState(
	RenderFrameHost::LifecycleState::kInBackForwardCache));

	dispatcher_->DispatchNonPersistentClickEvent(kPrimaryUniqueId,
	base::DoNothing());

	WaitForMojoTasksToComplete();

	dispatcher_->DispatchNonPersistentCloseEvent(kPrimaryUniqueId,
	base::DoNothing());

	WaitForMojoTasksToComplete();

	// Now the dispatched click and close events should not invoke the listener.
	EXPECT_EQ(listener->on_show_count(), 2);
	EXPECT_EQ(listener->on_click_count(), 1);
	EXPECT_EQ(listener->on_close_count(), 0);

	// Simulate the scenario where the rfh is back to active state and
	// dispatch a close event.
	rfh->SetLifecycleState(RenderFrameHostImpl::LifecycleStateImpl::kActive);
	EXPECT_FALSE(rfh->IsInLifecycleState(
	RenderFrameHost::LifecycleState::kInBackForwardCache));

	dispatcher_->DispatchNonPersistentCloseEvent(kPrimaryUniqueId,
	base::DoNothing());

	WaitForMojoTasksToComplete();

	// Since the rfh is active, the dispatched close event should result in
	// the increment of the close counter.
	EXPECT_EQ(listener->on_show_count(), 2);
	EXPECT_EQ(listener->on_click_count(), 1);
	EXPECT_EQ(listener->on_close_count(), 1);
	}

	TEST_F(NotificationEventDispatcherImplTest,
	RegisterNonPersistentListener_FirstListenerGetsOnClose) {
	auto original_listener = std::make_unique<TestNotificationListener>();
	dispatcher_->RegisterNonPersistentNotificationListener(
	kPrimaryUniqueId, original_listener->GetRemote(),
	main_rfh()->GetWeakDocumentPtr(),
	RenderProcessHost::NotificationServiceCreatorType::kDocument);

	dispatcher_->DispatchNonPersistentShowEvent(kPrimaryUniqueId);

	ASSERT_EQ(original_listener->on_close_count(), 0);

	auto replacement_listener = std::make_unique<TestNotificationListener>();
	dispatcher_->RegisterNonPersistentNotificationListener(
	kPrimaryUniqueId, replacement_listener->GetRemote(),
	main_rfh()->GetWeakDocumentPtr(),
	RenderProcessHost::NotificationServiceCreatorType::kDocument);

	WaitForMojoTasksToComplete();

	EXPECT_EQ(original_listener->on_close_count(), 1);
	EXPECT_EQ(replacement_listener->on_close_count(), 0);
	}

	TEST_F(NotificationEventDispatcherImplTest,
	RegisterNonPersistentListener_SecondListenerGetsOnShow) {
	auto original_listener = std::make_unique<TestNotificationListener>();
	dispatcher_->RegisterNonPersistentNotificationListener(
	kPrimaryUniqueId, original_listener->GetRemote(),
	main_rfh()->GetWeakDocumentPtr(),
	RenderProcessHost::NotificationServiceCreatorType::kDocument);

	dispatcher_->DispatchNonPersistentShowEvent(kPrimaryUniqueId);

	WaitForMojoTasksToComplete();

	ASSERT_EQ(original_listener->on_show_count(), 1);

	auto replacement_listener = std::make_unique<TestNotificationListener>();
	dispatcher_->RegisterNonPersistentNotificationListener(
	kPrimaryUniqueId, replacement_listener->GetRemote(),
	main_rfh()->GetWeakDocumentPtr(),
	RenderProcessHost::NotificationServiceCreatorType::kDocument);

	dispatcher_->DispatchNonPersistentShowEvent(kPrimaryUniqueId);

	WaitForMojoTasksToComplete();

	ASSERT_EQ(original_listener->on_show_count(), 1);
	ASSERT_EQ(replacement_listener->on_show_count(), 1);
	}

	TEST_F(NotificationEventDispatcherImplTest,
	RegisterNonPersistentListener_ReplacedListenerGetsOnClick) {
	auto original_listener = std::make_unique<TestNotificationListener>();
	dispatcher_->RegisterNonPersistentNotificationListener(
	kPrimaryUniqueId, original_listener->GetRemote(),
	main_rfh()->GetWeakDocumentPtr(),
	RenderProcessHost::NotificationServiceCreatorType::kDocument);

	dispatcher_->DispatchNonPersistentShowEvent(kPrimaryUniqueId);

	auto replacement_listener = std::make_unique<TestNotificationListener>();
	dispatcher_->RegisterNonPersistentNotificationListener(
	kPrimaryUniqueId, replacement_listener->GetRemote(),
	main_rfh()->GetWeakDocumentPtr(),
	RenderProcessHost::NotificationServiceCreatorType::kDocument);

	WaitForMojoTasksToComplete();

	dispatcher_->DispatchNonPersistentClickEvent(kPrimaryUniqueId,
	base::DoNothing());

	WaitForMojoTasksToComplete();

	EXPECT_EQ(original_listener->on_click_count(), 0);
	EXPECT_EQ(original_listener->on_close_count(), 1);
	EXPECT_EQ(replacement_listener->on_click_count(), 1);
	EXPECT_EQ(replacement_listener->on_close_count(), 0);
	}

	TEST_F(NotificationEventDispatcherImplTest,
	DispatchNonPersistentClickEvent_NotifiesCorrectRegisteredListener) {
	auto listener = std::make_unique<TestNotificationListener>();
	dispatcher_->RegisterNonPersistentNotificationListener(
	kPrimaryUniqueId, listener->GetRemote(), main_rfh()->GetWeakDocumentPtr(),
	RenderProcessHost::NotificationServiceCreatorType::kDocument);
	auto other_listener = std::make_unique<TestNotificationListener>();
	dispatcher_->RegisterNonPersistentNotificationListener(
	kSomeOtherUniqueId, other_listener->GetRemote(),
	main_rfh()->GetWeakDocumentPtr(),
	RenderProcessHost::NotificationServiceCreatorType::kDocument);

	dispatcher_->DispatchNonPersistentClickEvent(kPrimaryUniqueId,
	base::DoNothing());

	WaitForMojoTasksToComplete();

	EXPECT_EQ(listener->on_click_count(), 1);
	EXPECT_EQ(other_listener->on_click_count(), 0);

	dispatcher_->DispatchNonPersistentClickEvent(kSomeOtherUniqueId,
	base::DoNothing());

	WaitForMojoTasksToComplete();

	EXPECT_EQ(listener->on_click_count(), 1);
	EXPECT_EQ(other_listener->on_click_count(), 1);
	}

	TEST_F(NotificationEventDispatcherImplTest,
	DispatchNonPersistentCloseEvent_NotifiesCorrectRegisteredListener) {
	auto listener = std::make_unique<TestNotificationListener>();
	dispatcher_->RegisterNonPersistentNotificationListener(
	kPrimaryUniqueId, listener->GetRemote(), main_rfh()->GetWeakDocumentPtr(),
	RenderProcessHost::NotificationServiceCreatorType::kDocument);
	auto other_listener = std::make_unique<TestNotificationListener>();
	dispatcher_->RegisterNonPersistentNotificationListener(
	kSomeOtherUniqueId, other_listener->GetRemote(),
	main_rfh()->GetWeakDocumentPtr(),
	RenderProcessHost::NotificationServiceCreatorType::kDocument);

	dispatcher_->DispatchNonPersistentCloseEvent(kPrimaryUniqueId,
	base::DoNothing());

	WaitForMojoTasksToComplete();

	EXPECT_EQ(listener->on_close_count(), 1);
	EXPECT_EQ(other_listener->on_close_count(), 0);

	dispatcher_->DispatchNonPersistentCloseEvent(kSomeOtherUniqueId,
	base::DoNothing());

	WaitForMojoTasksToComplete();

	EXPECT_EQ(listener->on_close_count(), 1);
	EXPECT_EQ(other_listener->on_close_count(), 1);
	}

	TEST_F(NotificationEventDispatcherImplTest,
	DispatchMultipleNonPersistentEvents_StopsNotifyingAfterClose) {
	auto listener = std::make_unique<TestNotificationListener>();
	dispatcher_->RegisterNonPersistentNotificationListener(
	kPrimaryUniqueId, listener->GetRemote(), main_rfh()->GetWeakDocumentPtr(),
	RenderProcessHost::NotificationServiceCreatorType::kDocument);

	dispatcher_->DispatchNonPersistentShowEvent(kPrimaryUniqueId);
	dispatcher_->DispatchNonPersistentClickEvent(kPrimaryUniqueId,
	base::DoNothing());
	dispatcher_->DispatchNonPersistentCloseEvent(kPrimaryUniqueId,
	base::DoNothing());

	WaitForMojoTasksToComplete();

	EXPECT_EQ(listener->on_show_count(), 1);
	EXPECT_EQ(listener->on_click_count(), 1);
	EXPECT_EQ(listener->on_close_count(), 1);

	// Should not be counted as the notification was already closed.
	dispatcher_->DispatchNonPersistentClickEvent(kPrimaryUniqueId,
	base::DoNothing());

	WaitForMojoTasksToComplete();

	EXPECT_EQ(listener->on_click_count(), 1);
	}
	} // namespace content