Grant origins engagement for having interactions on their notifications.

chrome/browser/notifications/platform_notification_service_interactive_uitest.cc

 // Copyright 2014 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 <memory>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/time/time.h"
+#include "chrome/browser/engagement/site_engagement_score.h"
+#include "chrome/browser/engagement/site_engagement_service.h"
 #include "chrome/browser/notifications/desktop_notification_profile_util.h"
 #include "chrome/browser/notifications/message_center_display_service.h"
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/notifications/notification_test_util.h"
 #include "chrome/browser/notifications/platform_notification_service_impl.h"
 #include "chrome/browser/notifications/web_notification_delegate.h"
 #include "chrome/browser/permissions/permission_manager.h"
 #include "chrome/browser/permissions/permission_request_manager.h"
 #include "chrome/browser/permissions/permission_result.h"
 #include "chrome/browser/ui/browser.h"
@@ skipping 52 matching lines @@
   // Grants permission to display Web Notifications for origin of the test
   // page that's being used in this browser test.
   void GrantNotificationPermissionForTest() const;
 
   bool RequestAndAcceptPermission();
   bool RequestAndDenyPermission();
 
   void EnableFullscreenNotifications();
   void DisableFullscreenNotifications();
 
+  double GetEngagementScore(const GURL& origin) const;
+  GURL GetLastCommittedURL() const;
+
   // Returns the UI Manager on which notifications will be displayed.
   StubNotificationUIManager* ui_manager() const { return ui_manager_.get(); }
 
   const base::FilePath& server_root() const { return server_root_; }
 
   // Navigates the browser to the test page indicated by |path|.
   void NavigateToTestPage(const std::string& path) const;
 
   // Executes |script| and stores the result as a string in |result|. A boolean
   // will be returned, indicating whether the script was executed successfully.
   bool RunScript(const std::string& script, std::string* result) const;
 
   net::HostPortPair ServerHostPort() const;
   GURL TestPageUrl() const;
 
  private:
   std::string RequestAndRespondToPermission(
       PermissionRequestManager::AutoResponseType bubble_response);
 
   content::WebContents* GetActiveWebContents(Browser* browser) {
     return browser->tab_strip_model()->GetActiveWebContents();
   }
 
+  SiteEngagementService* engagement_service_;
   const base::FilePath server_root_;
   const std::string test_page_url_;
   std::unique_ptr<StubNotificationUIManager> ui_manager_;
   std::unique_ptr<MessageCenterDisplayService> display_service_;
   std::unique_ptr<net::EmbeddedTestServer> https_server_;
   base::test::ScopedFeatureList feature_list_;
 };
 
 // -----------------------------------------------------------------------------
 
@@ skipping 17 matching lines @@
 void PlatformNotificationServiceBrowserTest::SetUp() {
   ui_manager_.reset(new StubNotificationUIManager);
   https_server_.reset(
       new net::EmbeddedTestServer(net::EmbeddedTestServer::TYPE_HTTPS));
   https_server_->ServeFilesFromSourceDirectory(server_root_);
   ASSERT_TRUE(https_server_->Start());
   InProcessBrowserTest::SetUp();
 }
 
 void PlatformNotificationServiceBrowserTest::SetUpOnMainThread() {
+  SiteEngagementScore::SetParamValuesForTesting();
+  engagement_service_ = SiteEngagementService::Get(browser()->profile());
   NavigateToTestPage(test_page_url_);
   display_service_.reset(
       new MessageCenterDisplayService(browser()->profile(), ui_manager_.get()));
   service()->SetNotificationDisplayServiceForTesting(display_service_.get());
   InProcessBrowserTest::SetUpOnMainThread();
 }
 
 void PlatformNotificationServiceBrowserTest::TearDown() {
   service()->SetNotificationDisplayServiceForTesting(nullptr);
 }
@@ skipping 60 matching lines @@
     features::kPreferHtmlOverPlugins,
     features::kAllowFullscreenWebNotificationsFeature}, {});
 }
 
 void PlatformNotificationServiceBrowserTest::DisableFullscreenNotifications() {
   feature_list_.InitWithFeatures(
       {features::kPreferHtmlOverPlugins},
       {features::kAllowFullscreenWebNotificationsFeature});
 }
 
+double PlatformNotificationServiceBrowserTest::GetEngagementScore(
+    const GURL& origin) const {
+  return engagement_service_->GetScore(origin);
+}
+
+GURL PlatformNotificationServiceBrowserTest::GetLastCommittedURL() const {
+  return browser()
+      ->tab_strip_model()
+      ->GetActiveWebContents()
+      ->GetLastCommittedURL();
+}
+
 // -----------------------------------------------------------------------------
 
 // TODO(peter): Move PlatformNotificationService-related tests over from
 // notification_browsertest.cc to this file.
 
 IN_PROC_BROWSER_TEST_F(PlatformNotificationServiceBrowserTest,
                        DisplayPersistentNotificationWithoutPermission) {
   RequestAndDenyPermission();
 
   std::string script_result;
   ASSERT_TRUE(RunScript("DisplayPersistentNotification()", &script_result));
   EXPECT_EQ(
       "TypeError: No notification permission has been granted for this origin.",
       script_result);
 
   ASSERT_EQ(0u, ui_manager()->GetNotificationCount());
 }
 
 IN_PROC_BROWSER_TEST_F(PlatformNotificationServiceBrowserTest,
                        DisplayPersistentNotificationWithPermission) {
   RequestAndAcceptPermission();
 
+  // Expect 5 engagement for notification permission and 0.5 for the navigation.
+  EXPECT_DOUBLE_EQ(5.5, GetEngagementScore(GetLastCommittedURL()));
+
   std::string script_result;
   ASSERT_TRUE(RunScript("DisplayPersistentNotification('action_none')",
        &script_result));
   EXPECT_EQ("ok", script_result);
 
   ASSERT_EQ(1u, ui_manager()->GetNotificationCount());
 
 #if BUILDFLAG(ENABLE_BACKGROUND)
   ASSERT_FALSE(KeepAliveRegistry::GetInstance()->IsOriginRegistered(
       KeepAliveOrigin::PENDING_NOTIFICATION_CLICK_EVENT));
 #endif
 
+  // We expect +1 engagement for the notification interaction.
   const Notification& notification = ui_manager()->GetNotificationAt(0);
   notification.delegate()->Click();
+  EXPECT_DOUBLE_EQ(6.5, GetEngagementScore(GetLastCommittedURL()));
 
 #if BUILDFLAG(ENABLE_BACKGROUND)
   ASSERT_TRUE(KeepAliveRegistry::GetInstance()->IsOriginRegistered(
       KeepAliveOrigin::PENDING_NOTIFICATION_CLICK_EVENT));
 #endif
 
   ASSERT_TRUE(RunScript("GetMessageFromWorker()", &script_result));
   EXPECT_EQ("action_none", script_result);
 
 #if BUILDFLAG(ENABLE_BACKGROUND)
@@ skipping 67 matching lines @@
             base::UTF16ToUTF8(all_options_notification.buttons()[0].title));
   EXPECT_FALSE(all_options_notification.buttons()[0].icon.IsEmpty());
   EXPECT_EQ(kIconWidth, all_options_notification.buttons()[0].icon.Width());
   EXPECT_EQ(kIconHeight, all_options_notification.buttons()[0].icon.Height());
 }
 
 IN_PROC_BROWSER_TEST_F(PlatformNotificationServiceBrowserTest,
                        WebNotificationSiteSettingsButton) {
   ASSERT_NO_FATAL_FAILURE(GrantNotificationPermissionForTest());
 
+  // Expect 5 engagement for notification permission and 0.5 for the navigation.
+  content::WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
+  GURL origin = web_contents->GetLastCommittedURL();
+  EXPECT_DOUBLE_EQ(5.5, GetEngagementScore(origin));
+
   std::string script_result;
   ASSERT_TRUE(RunScript("DisplayPersistentNotification('Some title', {})",
                         &script_result));
   EXPECT_EQ("ok", script_result);
 
   ASSERT_EQ(1u, ui_manager()->GetNotificationCount());
 
   const Notification& notification = ui_manager()->GetNotificationAt(0);
   const std::vector<message_center::ButtonInfo>& buttons =
       notification.buttons();
   EXPECT_EQ(0u, buttons.size());
 
   notification.delegate()->SettingsClick();
   ASSERT_EQ(1u, ui_manager()->GetNotificationCount());
-  content::WebContents* web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
+  web_contents = browser()->tab_strip_model()->GetActiveWebContents();
   ASSERT_TRUE(content::WaitForLoadStop(web_contents));
 
+  // No engagement should be granted for clicking on the settings link.
+  EXPECT_DOUBLE_EQ(5.5, GetEngagementScore(origin));
+
   std::string url = web_contents->GetLastCommittedURL().spec();
   if (base::FeatureList::IsEnabled(features::kMaterialDesignSettings))
     ASSERT_EQ("chrome://settings/content/notifications", url);
   else
     ASSERT_EQ("chrome://settings/contentExceptions#notifications", url);
 }
 
 IN_PROC_BROWSER_TEST_F(PlatformNotificationServiceBrowserTest,
                        WebNotificationOptionsVibrationPattern) {
   ASSERT_NO_FATAL_FAILURE(GrantNotificationPermissionForTest());
@@ skipping 10 matching lines @@
   EXPECT_EQ("Contents", base::UTF16ToUTF8(notification.message()));
 
   EXPECT_THAT(notification.vibration_pattern(),
       testing::ElementsAreArray(kNotificationVibrationPattern));
 }
 
 IN_PROC_BROWSER_TEST_F(PlatformNotificationServiceBrowserTest,
                        CloseDisplayedPersistentNotification) {
   ASSERT_NO_FATAL_FAILURE(GrantNotificationPermissionForTest());
 
+  // Expect 5 engagement for notification permission and 0.5 for the navigation.
+  EXPECT_DOUBLE_EQ(5.5, GetEngagementScore(GetLastCommittedURL()));
+
   std::string script_result;
   ASSERT_TRUE(RunScript("DisplayPersistentNotification('action_close')",
                         &script_result));
   EXPECT_EQ("ok", script_result);
 
   ASSERT_EQ(1u, ui_manager()->GetNotificationCount());
 
   const Notification& notification = ui_manager()->GetNotificationAt(0);
   notification.delegate()->Click();
 
+  // We have interacted with the button, so expect a notification bump.
+  EXPECT_DOUBLE_EQ(6.5, GetEngagementScore(GetLastCommittedURL()));
+
   ASSERT_TRUE(RunScript("GetMessageFromWorker()", &script_result));
   EXPECT_EQ("action_close", script_result);
 
   ASSERT_EQ(0u, ui_manager()->GetNotificationCount());
 }
 
 IN_PROC_BROWSER_TEST_F(PlatformNotificationServiceBrowserTest,
                        UserClosesPersistentNotification) {
   ASSERT_NO_FATAL_FAILURE(GrantNotificationPermissionForTest());
 
+  // Expect 5 engagement for notification permission and 0.5 for the navigation.
+  EXPECT_DOUBLE_EQ(5.5, GetEngagementScore(GetLastCommittedURL()));
+
   std::string script_result;
   ASSERT_TRUE(
       RunScript("DisplayPersistentNotification('close_test')", &script_result));
   EXPECT_EQ("ok", script_result);
 
   ASSERT_EQ(1u, ui_manager()->GetNotificationCount());
   const Notification& notification = ui_manager()->GetNotificationAt(0);
   notification.delegate()->Close(true /* by_user */);
 
+  // The user closed this notification so the score should remain the same.
+  EXPECT_DOUBLE_EQ(5.5, GetEngagementScore(GetLastCommittedURL()));
+
   ASSERT_TRUE(RunScript("GetMessageFromWorker()", &script_result));
   EXPECT_EQ("closing notification: close_test", script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PlatformNotificationServiceBrowserTest,
                        TestDisplayOriginContextMessage) {
   RequestAndAcceptPermission();
 
   // Creates a simple notification.
   std::string script_result;
@@ skipping 103 matching lines @@
 
   EXPECT_EQ("Blob Title", base::UTF16ToUTF8(notification.title()));
   EXPECT_EQ(kIconWidth, notification.icon().Width());
   EXPECT_EQ(kIconHeight, notification.icon().Height());
 }
 
 IN_PROC_BROWSER_TEST_F(PlatformNotificationServiceBrowserTest,
                        DisplayPersistentNotificationWithActionButtons) {
   ASSERT_NO_FATAL_FAILURE(GrantNotificationPermissionForTest());
 
+  // Expect 5 engagement for notification permission and 0.5 for the navigation.
+  EXPECT_DOUBLE_EQ(5.5, GetEngagementScore(GetLastCommittedURL()));
+
   std::string script_result;
   ASSERT_TRUE(RunScript("DisplayPersistentNotificationWithActionButtons()",
                         &script_result));
   EXPECT_EQ("ok", script_result);
   ASSERT_EQ(1u, ui_manager()->GetNotificationCount());
 
   const Notification& notification = ui_manager()->GetNotificationAt(0);
   ASSERT_EQ(2u, notification.buttons().size());
   EXPECT_EQ("actionTitle1", base::UTF16ToUTF8(notification.buttons()[0].title));
   EXPECT_EQ("actionTitle2", base::UTF16ToUTF8(notification.buttons()[1].title));
 
   notification.delegate()->ButtonClick(0);
   ASSERT_TRUE(RunScript("GetMessageFromWorker()", &script_result));
   EXPECT_EQ("action_button_click actionId1", script_result);
+  EXPECT_DOUBLE_EQ(6.5, GetEngagementScore(GetLastCommittedURL()));
 
   notification.delegate()->ButtonClick(1);
   ASSERT_TRUE(RunScript("GetMessageFromWorker()", &script_result));
   EXPECT_EQ("action_button_click actionId2", script_result);
+  EXPECT_DOUBLE_EQ(7.5, GetEngagementScore(GetLastCommittedURL()));
 }
 
 IN_PROC_BROWSER_TEST_F(PlatformNotificationServiceBrowserTest,
                        DisplayPersistentNotificationWithReplyButton) {
   ASSERT_NO_FATAL_FAILURE(GrantNotificationPermissionForTest());
 
+  // Expect 5 engagement for notification permission and 0.5 for the navigation.
+  EXPECT_DOUBLE_EQ(5.5, GetEngagementScore(GetLastCommittedURL()));
+
   std::string script_result;
   ASSERT_TRUE(RunScript("DisplayPersistentNotificationWithReplyButton()",
                         &script_result));
   EXPECT_EQ("ok", script_result);
   ASSERT_EQ(1u, ui_manager()->GetNotificationCount());
 
   const Notification& notification = ui_manager()->GetNotificationAt(0);
   ASSERT_EQ(1u, notification.buttons().size());
   EXPECT_EQ("actionTitle1", base::UTF16ToUTF8(notification.buttons()[0].title));
 
   notification.delegate()->ButtonClickWithReply(0, base::ASCIIToUTF16("hello"));
   ASSERT_TRUE(RunScript("GetMessageFromWorker()", &script_result));
   EXPECT_EQ("action_button_click actionId1 hello", script_result);
+  EXPECT_DOUBLE_EQ(6.5, GetEngagementScore(GetLastCommittedURL()));
 }
 
 IN_PROC_BROWSER_TEST_F(PlatformNotificationServiceBrowserTest,
                        GetDisplayedNotifications) {
   RequestAndAcceptPermission();
 
   std::string script_result;
   std::string script_message;
   ASSERT_TRUE(RunScript("DisplayNonPersistentNotification('NonPersistent')",
                         &script_result));
@@ skipping 187 matching lines @@
       RunScript("DisplayPersistentAllOptionsNotification()", &script_result));
   EXPECT_EQ("ok", script_result);
 
   ASSERT_EQ(1u, ui_manager()->GetNotificationCount());
   const Notification& notification = ui_manager()->GetNotificationAt(0);
 
   // Since the kNotificationContentImage kill switch has disabled images, the
   // notification should be shown without an image.
   EXPECT_TRUE(notification.image().IsEmpty());
 }