Grant origins engagement for having interactions on their notifications.

chrome/android/javatests/src/org/chromium/chrome/browser/notifications/NotificationPlatformBridgeTest.java

 // 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.
 
 package org.chromium.chrome.browser.notifications;
 
 import static org.chromium.base.test.util.ScalableTimeout.scaleTimeout;
 
 import android.annotation.TargetApi;
 import android.app.Notification;
 import android.app.PendingIntent;
 import android.app.RemoteInput;
 import android.content.Context;
 import android.content.Intent;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.graphics.Color;
 import android.os.Build;
 import android.os.Bundle;
 import android.support.test.filters.LargeTest;
 import android.support.test.filters.MediumTest;
 
 import org.chromium.base.ThreadUtils;
 import org.chromium.base.annotations.SuppressFBWarnings;
 import org.chromium.base.test.util.CommandLineFlags;
 import org.chromium.base.test.util.Feature;
 import org.chromium.base.test.util.MinAndroidSdkLevel;
 import org.chromium.base.test.util.RetryOnFailure;
 import org.chromium.chrome.R;
+import org.chromium.chrome.browser.engagement.SiteEngagementService;
 import org.chromium.chrome.browser.infobar.InfoBar;
 import org.chromium.chrome.browser.preferences.PrefServiceBridge;
 import org.chromium.chrome.browser.preferences.website.ContentSetting;
+import org.chromium.chrome.browser.profiles.Profile;
 import org.chromium.chrome.browser.tab.Tab;
 import org.chromium.chrome.browser.widget.RoundedIconGenerator;
 import org.chromium.chrome.test.util.InfoBarUtil;
 import org.chromium.chrome.test.util.browser.TabTitleObserver;
 import org.chromium.chrome.test.util.browser.notifications.MockNotificationManagerProxy.NotificationEntry;
 import org.chromium.components.url_formatter.UrlFormatter;
 import org.chromium.content.browser.test.util.Criteria;
 import org.chromium.content.browser.test.util.CriteriaHelper;
 
 import java.net.URL;
 import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeoutException;
 
 /**
  * Instrumentation tests for the Notification Bridge.
  *
  * Web Notifications are only supported on Android JellyBean and beyond.
  */
 public class NotificationPlatformBridgeTest extends NotificationTestBase {
     private static final String NOTIFICATION_TEST_PAGE =
             "/chrome/test/data/notifications/android_test.html";
     private static final int TITLE_UPDATE_TIMEOUT_SECONDS = (int) scaleTimeout(5);
 
     @Override
     protected void setUp() throws Exception {
         super.setUp();
+        SiteEngagementService.setParamValuesForTesting();
         loadUrl(getTestServer().getURL(NOTIFICATION_TEST_PAGE));
     }
 
     private void waitForTitle(String expectedTitle) throws InterruptedException {
         Tab tab = getActivity().getActivityTab();
         TabTitleObserver titleObserver = new TabTitleObserver(tab, expectedTitle);
         try {
             titleObserver.waitForTitleUpdate(TITLE_UPDATE_TIMEOUT_SECONDS);
         } catch (TimeoutException e) {
             // The title is not as expected, this assertion neatly logs what the difference is.
@@ skipping 23 matching lines @@
         assertEquals(0, getInfoBars().size());
     }
 
     private void checkThatShowNotificationIsDenied() throws Exception {
         runJavaScriptCodeInCurrentTab("showNotification('MyNotification', {})");
         waitForTitle("TypeError: No notification permission has been granted for this origin.");
         // Ideally we'd wait a little here, but it's hard to wait for things that shouldn't happen.
         assertTrue(getNotificationEntries().isEmpty());
     }
 
+    private double getEngagementScoreBlocking() {
+        try {
+            return ThreadUtils.runOnUiThreadBlocking(new Callable<Double>() {
+                @Override
+                public Double call() throws Exception {
+                    return SiteEngagementService.getForProfile(Profile.getLastUsedProfile())
+                            .getScore(getOrigin());
+                }
+            });
+        } catch (ExecutionException ex) {
+            assert false : "Unexpected ExecutionException";
+        }
+        return 0.0;
+    }
+
     /**
      * Verifies that notifcations cannot be shown without permission, and that dismissing or denying
      * the infobar works correctly.
      */
     @LargeTest
     @Feature({"Browser", "Notifications"})
     public void testPermissionDenied() throws Exception {
         // Notifications permission should initially be prompt, and showing should fail.
         assertEquals("\"default\"", runJavaScriptCodeInCurrentTab("Notification.permission"));
         checkThatShowNotificationIsDenied();
@@ skipping 144 matching lines @@
         Notification.Action action = notification.actions[0];
         assertEquals("reply", action.title);
         assertNotNull(notification.actions[0].getRemoteInputs());
         assertEquals(1, action.getRemoteInputs().length);
         assertEquals("hi", action.getRemoteInputs()[0].getLabel());
     }
 
     /**
      * Verifies that setting a reply on the remote input of a notification action with type 'text'
      * and triggering the action's intent causes the same reply to be received in the subsequent
-     * notificationclick event on the service worker.
+     * notificationclick event on the service worker. Verifies that site engagement is incremented
+     * appropriately.
      */
     @CommandLineFlags.Add("enable-experimental-web-platform-features")
     @MinAndroidSdkLevel(Build.VERSION_CODES.KITKAT_WATCH)
     @TargetApi(Build.VERSION_CODES.KITKAT_WATCH) // RemoteInputs were only added in KITKAT_WATCH.
     @MediumTest
     @Feature({"Browser", "Notifications"})
     public void testReplyToNotification() throws Exception {
         setNotificationContentSettingForCurrentOrigin(ContentSetting.ALLOW);
         Context context = getInstrumentation().getTargetContext();
 
+        // +5 engagement from notification permission and +0.5 from navigating to the test page.
+        assertEquals(5.5, getEngagementScoreBlocking());
         Notification notification = showAndGetNotification("MyNotification", "{ "
                         + " actions: [{action: 'myAction', title: 'reply', type: 'text'}],"
                         + " data: 'ACTION_REPLY'}");
 
         // Check the action is present with a remote input attached.
         Notification.Action action = notification.actions[0];
         assertEquals("reply", action.title);
         RemoteInput[] remoteInputs = action.getRemoteInputs();
         assertNotNull(remoteInputs);
 
         // Set a reply using the action's remote input key and send it on the intent.
         sendIntentWithRemoteInput(context, action.actionIntent, remoteInputs,
                 remoteInputs[0].getResultKey(), "My Reply" /* reply */);
 
         // Check reply was received by the service worker (see android_test_worker.js).
+        // Expect +1 engagement from interacting with the notification.
         waitForTitle("reply: My Reply");
+        assertEquals(6.5, getEngagementScoreBlocking());
     }
 
     /**
      * Verifies that setting an empty reply on the remote input of a notification action with type
      * 'text' and triggering the action's intent causes an empty reply string to be received in the
-     * subsequent notificationclick event on the service worker.
+     * subsequent notificationclick event on the service worker. Verifies that site engagement is
+     * incremented appropriately.
      */
     @CommandLineFlags.Add("enable-experimental-web-platform-features")
     @MinAndroidSdkLevel(Build.VERSION_CODES.KITKAT_WATCH)
     @TargetApi(Build.VERSION_CODES.KITKAT_WATCH) // RemoteInputs added in KITKAT_WATCH.
     @MediumTest
     @Feature({"Browser", "Notifications"})
     public void testReplyToNotificationWithEmptyReply() throws Exception {
         setNotificationContentSettingForCurrentOrigin(ContentSetting.ALLOW);
         Context context = getInstrumentation().getTargetContext();
 
+        // +5 engagement from notification permission and +0.5 from navigating to the test page.
+        assertEquals(5.5, getEngagementScoreBlocking());
         Notification notification = showAndGetNotification("MyNotification", "{ "
                         + " actions: [{action: 'myAction', title: 'reply', type: 'text'}],"
                         + " data: 'ACTION_REPLY'}");
 
         // Check the action is present with a remote input attached.
         Notification.Action action = notification.actions[0];
         assertEquals("reply", action.title);
         RemoteInput[] remoteInputs = action.getRemoteInputs();
         assertNotNull(remoteInputs);
 
         // Set a reply using the action's remote input key and send it on the intent.
         sendIntentWithRemoteInput(context, action.actionIntent, remoteInputs,
                 remoteInputs[0].getResultKey(), "" /* reply */);
 
         // Check empty reply was received by the service worker (see android_test_worker.js).
+        // Expect +1 engagement from interacting with the notification.
         waitForTitle("reply:");
+        assertEquals(6.5, getEngagementScoreBlocking());
     }
 
     @TargetApi(Build.VERSION_CODES.KITKAT_WATCH) // RemoteInputs added in KITKAT_WATCH.
     private static void sendIntentWithRemoteInput(Context context, PendingIntent pendingIntent,
             RemoteInput[] remoteInputs, String resultKey, String reply)
             throws PendingIntent.CanceledException {
         Bundle results = new Bundle();
         results.putString(resultKey, reply);
         Intent fillInIntent = new Intent().addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
         RemoteInput.addResultsToIntent(remoteInputs, fillInIntent, results);
 
         // Send the pending intent filled in with the additional information from the new intent.
         pendingIntent.send(context, 0 /* code */, fillInIntent);
     }
 
     /**
      * Verifies that *not* setting a reply on the remote input of a notification action with type
      * 'text' and triggering the action's intent causes a null reply to be received in the
-     * subsequent notificationclick event on the service worker.
+     * subsequent notificationclick event on the service worker.  Verifies that site engagement is
+     * incremented appropriately.
      */
     @TargetApi(Build.VERSION_CODES.KITKAT) // Notification.Action.actionIntent added in Android K.
     @CommandLineFlags.Add("enable-experimental-web-platform-features")
     @MediumTest
     @Feature({"Browser", "Notifications"})
     public void testReplyToNotificationWithNoRemoteInput() throws Exception {
         setNotificationContentSettingForCurrentOrigin(ContentSetting.ALLOW);
 
+        // +5 engagement from notification permission and +0.5 from navigating to the test page.
+        assertEquals(5.5, getEngagementScoreBlocking());
         Notification notification = showAndGetNotification("MyNotification", "{ "
                         + " actions: [{action: 'myAction', title: 'reply', type: 'text'}],"
                         + " data: 'ACTION_REPLY'}");
 
         assertEquals("reply", notification.actions[0].title);
         notification.actions[0].actionIntent.send();
 
         // Check reply was received by the service worker (see android_test_worker.js).
+        // Expect +1 engagement from interacting with the notification.
         waitForTitle("reply: null");
+        assertEquals(6.5, getEngagementScoreBlocking());
     }
 
     /**
      * Verifies that the ONLY_ALERT_ONCE flag is not set when renotify is true.
      */
     @MediumTest
     @Feature({"Browser", "Notifications"})
     public void testNotificationRenotifyProperty() throws Exception {
         setNotificationContentSettingForCurrentOrigin(ContentSetting.ALLOW);
 
@@ skipping 201 matching lines @@
     /*
      * Verifies that starting the PendingIntent stored as the notification's content intent will
      * start up the associated Service Worker, where the JavaScript code will close the notification
      * by calling event.notification.close().
      */
     @LargeTest
     @Feature({"Browser", "Notifications"})
     @RetryOnFailure
     public void testNotificationContentIntentClosesNotification() throws Exception {
         setNotificationContentSettingForCurrentOrigin(ContentSetting.ALLOW);
+        // +5 engagement from notification permission and +0.5 from navigating to the test page.
+        assertEquals(5.5, getEngagementScoreBlocking());
 
         Notification notification = showAndGetNotification("MyNotification", "{}");
 
         // Sending the PendingIntent resembles activating the notification.
         assertNotNull(notification.contentIntent);
         notification.contentIntent.send();
 
         // The Service Worker will close the notification upon receiving the notificationclick
         // event. This will eventually bubble up to a call to cancel() in the NotificationManager.
+        // Expect +1 engagement from interacting with the notification.
         waitForNotificationManagerMutation();
         assertTrue(getNotificationEntries().isEmpty());
+        assertEquals(6.5, getEngagementScoreBlocking());
     }
 
     /**
      * Verifies that starting the PendingIntent stored as the notification's content intent will
      * start up the associated Service Worker, where the JavaScript code will create a new tab for
      * displaying the notification's event to the user.
      */
     @LargeTest
     @Feature({"Browser", "Notifications"})
     @RetryOnFailure
@@ skipping 25 matching lines @@
 
     /**
      * Verifies that creating a notification with an associated "tag" will cause any previous
      * notification with the same tag to be dismissed prior to being shown.
      */
     @SuppressFBWarnings("DLS_DEAD_LOCAL_STORE")
     @MediumTest
     @Feature({"Browser", "Notifications"})
     public void testNotificationTagReplacement() throws Exception {
         setNotificationContentSettingForCurrentOrigin(ContentSetting.ALLOW);
+        // +5 engagement from notification permission and +0.5 from navigating to the test page.
+        assertEquals(5.5, getEngagementScoreBlocking());
 
         runJavaScriptCodeInCurrentTab("showNotification('MyNotification', {tag: 'myTag'});");
         waitForNotificationManagerMutation();
         List<NotificationEntry> notifications = getNotificationEntries();
         String tag = notifications.get(0).tag;
         int id = notifications.get(0).id;
 
         runJavaScriptCodeInCurrentTab("showNotification('SecondNotification', {tag: 'myTag'});");
         waitForNotificationManagerMutation();
 
         // Verify that the notification was successfully replaced.
         notifications = getNotificationEntries();
         assertEquals(1, notifications.size());
         assertEquals("SecondNotification",
                 NotificationTestUtil.getExtraTitle(notifications.get(0).notification));
 
         // Verify that for replaced notifications their tag was the same.
         assertEquals(tag, notifications.get(0).tag);
 
         // Verify that as always, the same integer is used, also for replaced notifications.
         assertEquals(id, notifications.get(0).id);
         assertEquals(NotificationPlatformBridge.PLATFORM_ID, notifications.get(0).id);
+
+        // Engagement should not have changed since we didn't interact.
+        assertEquals(5.5, getEngagementScoreBlocking());
     }
 
     /**
      * Verifies that multiple notifications without a tag can be opened and closed without
      * affecting eachother.
      */
     @LargeTest
     @Feature({"Browser", "Notifications"})
     public void testShowAndCloseMultipleNotifications() throws Exception {
         setNotificationContentSettingForCurrentOrigin(ContentSetting.ALLOW);
+        // +5 engagement from notification permission and +0.5 from navigating to the test page.
+        assertEquals(5.5, getEngagementScoreBlocking());
 
         // Open the first notification and verify it is displayed.
         runJavaScriptCodeInCurrentTab("showNotification('One');");
         waitForNotificationManagerMutation();
         List<NotificationEntry> notifications = getNotificationEntries();
         assertEquals(1, notifications.size());
         Notification notificationOne = notifications.get(0).notification;
         assertEquals("One", NotificationTestUtil.getExtraTitle(notificationOne));
 
         // Open the second notification and verify it is displayed.
@@ skipping 20 matching lines @@
         // Close the first notification and verify that only the second remains.
         // Sending the content intent resembles touching the notification. In response tho this the
         // notificationclick event is fired. The test service worker will close the notification
         // upon receiving the event.
         notificationOne.contentIntent.send();
         waitForNotificationManagerMutation();
         notifications = getNotificationEntries();
         assertEquals(1, notifications.size());
         assertEquals("Two", NotificationTestUtil.getExtraTitle(notifications.get(0).notification));
 
+        // Expect +1 engagement from interacting with the notification.
+        assertEquals(6.5, getEngagementScoreBlocking());
+
         // Close the last notification and verify that none remain.
         notifications.get(0).notification.contentIntent.send();
         waitForNotificationManagerMutation();
         assertTrue(getNotificationEntries().isEmpty());
+
+        // Expect +1 engagement from interacting with the notification.
+        assertEquals(7.5, getEngagementScoreBlocking());
     }
 }