Push API: Don't wait for network when unsubscribing

chrome/browser/push_messaging/push_messaging_browsertest.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 <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <string>
 
@@ skipping 551 matching lines @@
       "gcm_sender_id not found in manifest",
       script_result);
 
   // Now run the subscribe with a key. This should succeed.
   ASSERT_TRUE(RunScript("workerSubscribePush()", &script_result));
   ASSERT_NO_FATAL_FAILURE(
       EndpointToToken(script_result, true /* standard_protocol */));
 
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
-  EXPECT_NE(push_service(), GetAppHandler());
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        ResubscribeWithoutKeyAfterSubscribingWithKeyInManifest) {
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
   ASSERT_NO_FATAL_FAILURE(RequestAndAcceptPermission());
@@ skipping 25 matching lines @@
   // Now run the subscribe from the service worker without a key.
   // In this case, the sender id should be read from the datastore.
   ASSERT_TRUE(RunScript("workerSubscribePushNoKey()", &script_result));
   std::string token2;
   ASSERT_NO_FATAL_FAILURE(
       EndpointToToken(script_result, false /* standard_protocol */, &token2));
   EXPECT_EQ(token1, token2);
 
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
-  EXPECT_NE(push_service(), GetAppHandler());
 
   // After unsubscribing, subscribe again from the worker with no key.
   // The sender id should again be read from the datastore, so the
   // subcribe should succeed, and we should get a new subscription token.
   ASSERT_TRUE(RunScript("workerSubscribePushNoKey()", &script_result));
   std::string token3;
   ASSERT_NO_FATAL_FAILURE(
       EndpointToToken(script_result, false /* standard_protocol */, &token3));
   EXPECT_NE(token1, token3);
 
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
-  EXPECT_NE(push_service(), GetAppHandler());
 }
 
 IN_PROC_BROWSER_TEST_F(
     PushMessagingBrowserTest,
     ResubscribeWithoutKeyAfterSubscribingFromDocumentWithP256Key) {
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
@@ skipping 18 matching lines @@
   // Now try to resubscribe from the service worker without a key.
   // This should also fail as the original key was not numeric.
   ASSERT_TRUE(RunScript("workerSubscribePushNoKey()", &script_result));
   EXPECT_EQ(
       "AbortError - Registration failed - missing applicationServerKey, "
       "and gcm_sender_id not found in manifest",
       script_result);
 
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
-  EXPECT_NE(push_service(), GetAppHandler());
 
   // After unsubscribing, try to resubscribe again without a key.
   // This should again fail.
   ASSERT_TRUE(RunScript("workerSubscribePushNoKey()", &script_result));
   EXPECT_EQ(
       "AbortError - Registration failed - missing applicationServerKey, "
       "and gcm_sender_id not found in manifest",
       script_result);
 }
 
@@ skipping 82 matching lines @@
   // manifest, not a numeric applicationServerKey, but for code simplicity
   // this case is allowed.
   ASSERT_TRUE(RunScript("workerSubscribePushNoKey()", &script_result));
   std::string token2;
   ASSERT_NO_FATAL_FAILURE(
       EndpointToToken(script_result, false /* standard_protocol */, &token2));
   EXPECT_EQ(token1, token2);
 
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
-  EXPECT_NE(push_service(), GetAppHandler());
 
   // After unsubscribing, subscribe again from the worker with no key.
   // The sender id should again be read from the datastore, so the
   // subcribe should succeed, and we should get a new subscription token.
   ASSERT_TRUE(RunScript("workerSubscribePushNoKey()", &script_result));
   std::string token3;
   ASSERT_NO_FATAL_FAILURE(
       EndpointToToken(script_result, false /* standard_protocol */, &token3));
   EXPECT_NE(token1, token3);
 
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
-  EXPECT_NE(push_service(), GetAppHandler());
 }
 
 IN_PROC_BROWSER_TEST_F(
     PushMessagingBrowserTest,
     ResubscribeWithoutKeyAfterSubscribingFromWorkerWithNumber) {
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
@@ skipping 25 matching lines @@
   // manifest, not a numeric applicationServerKey, but for code simplicity
   // this case is allowed.
   ASSERT_TRUE(RunScript("workerSubscribePushNoKey()", &script_result));
   std::string token2;
   ASSERT_NO_FATAL_FAILURE(
       EndpointToToken(script_result, false /* standard_protocol */, &token2));
   EXPECT_EQ(token1, token2);
 
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
-  EXPECT_NE(push_service(), GetAppHandler());
 
   // After unsubscribing, subscribe again from the worker with no key.
   // The sender id should again be read from the datastore, so the
   // subcribe should succeed, and we should get a new subscription token.
   ASSERT_TRUE(RunScript("workerSubscribePushNoKey()", &script_result));
   std::string token3;
   ASSERT_NO_FATAL_FAILURE(
       EndpointToToken(script_result, false /* standard_protocol */, &token3));
   EXPECT_NE(token1, token3);
 
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
-  EXPECT_NE(push_service(), GetAppHandler());
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, ResubscribeWithMismatchedKey) {
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
   ASSERT_NO_FATAL_FAILURE(RequestAndAcceptPermission());
 
@@ skipping 22 matching lines @@
   // Try to resubscribe with the original key - should succeed.
   ASSERT_TRUE(
       RunScript("workerSubscribePushWithNumericKey('11111')", &script_result));
   std::string token2;
   ASSERT_NO_FATAL_FAILURE(
       EndpointToToken(script_result, false /* standard_protocol */, &token2));
   EXPECT_EQ(token1, token2);
 
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
-  EXPECT_NE(push_service(), GetAppHandler());
 
   // Resubscribe with a different key after unsubscribing.
   // Should succeed, and we should get a new subscription token.
   ASSERT_TRUE(
       RunScript("workerSubscribePushWithNumericKey('22222')", &script_result));
   std::string token3;
   ASSERT_NO_FATAL_FAILURE(
       EndpointToToken(script_result, false /* standard_protocol */, &token3));
   EXPECT_NE(token1, token3);
 
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
-  EXPECT_NE(push_service(), GetAppHandler());
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, SubscribePersisted) {
   std::string script_result;
 
   // First, test that Service Worker registration IDs are assigned in order of
   // registering the Service Workers, and the (fake) push subscription ids are
   // assigned in order of push subscription (even when these orders are
   // different).
 
@@ skipping 64 matching lines @@
   EXPECT_NE(push_service(), GetAppHandler());
   ASSERT_NO_FATAL_FAILURE(RestartPushService());
   EXPECT_NE(push_service(), GetAppHandler());
 
   ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
 
   EXPECT_EQ(push_service(), GetAppHandler());
   ASSERT_NO_FATAL_FAILURE(RestartPushService());
   EXPECT_EQ(push_service(), GetAppHandler());
 
+  std::string script_result;
+
   // Unsubscribe.
-  std::string script_result;
+  base::RunLoop run_loop;
+  push_service()->SetUnsubscribeCallbackForTesting(run_loop.QuitClosure());
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
+  // The app handler is only guaranteed to be unregistered once the unsubscribe
+  // callback for testing has been run (PushSubscription.unsubscribe() usually
+  // resolves before that, in order to avoid blocking on network retries etc).
+  run_loop.Run();
 
   EXPECT_NE(push_service(), GetAppHandler());
   ASSERT_NO_FATAL_FAILURE(RestartPushService());
   EXPECT_NE(push_service(), GetAppHandler());
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, PushEventSuccess) {
   std::string script_result;
 
   ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
@@ skipping 688 matching lines @@
   histogram_tester_.ExpectBucketCount(
       "PushMessaging.UnregistrationReason",
       content::PUSH_UNREGISTRATION_REASON_SERVICE_WORKER_UNREGISTERED, 1);
   histogram_tester_.ExpectTotalCount("PushMessaging.UnregistrationReason", 6);
 
   // Now manual unsubscribe should return false.
   ASSERT_TRUE(RunScript("unsubscribeStoredPushSubscription()", &script_result));
   EXPECT_EQ("unsubscribe result: false", script_result);
 }
 
+IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, UnsubscribeOffline) {
+  std::string script_result;
+
+  EXPECT_NE(push_service(), GetAppHandler());
+
+  std::string token;
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully(true /* use_key */, &token));
+
+  gcm_service_->set_offline(true);
+
+  // Should quickly resolve true after deleting local state (rather than waiting
+  // until unsubscribing over the network exceeds the maximum backoff duration).
+  ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
+  EXPECT_EQ("unsubscribe result: true", script_result);
+  histogram_tester_.ExpectUniqueSample(
+      "PushMessaging.UnregistrationReason",
+      content::PUSH_UNREGISTRATION_REASON_JAVASCRIPT_API, 1);
+
+  // Since the service is offline, the network request to GCM is still being
+  // retried, so the app handler shouldn't have been unregistered yet.
+  EXPECT_EQ(push_service(), GetAppHandler());
+  // But restarting the push service will unregister the app handler, since the
+  // subscription is no longer stored in the PushMessagingAppIdentifier map.
+  ASSERT_NO_FATAL_FAILURE(RestartPushService());
+  EXPECT_NE(push_service(), GetAppHandler());
+}
+
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        UnregisteringServiceWorkerUnsubscribes) {
   std::string script_result;
 
   ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
 
   LoadTestPage();  // Reload to become controlled.
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("true - is controlled", script_result);
 
@@ skipping 415 matching lines @@
   BackgroundModeManager* background_mode_manager =
       g_browser_process->background_mode_manager();
   ASSERT_FALSE(background_mode_manager->IsBackgroundModeActive());
 
   // Once there is a push subscription background mode is still inactive.
   ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
   ASSERT_FALSE(background_mode_manager->IsBackgroundModeActive());
 
   // After dropping the last subscription it is still inactive.
   std::string script_result;
+  base::RunLoop run_loop;
+  push_service()->SetUnsubscribeCallbackForTesting(run_loop.QuitClosure());
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
+  // Background mode is only guaranteed to have updated once the unsubscribe
+  // callback for testing has been run (PushSubscription.unsubscribe() usually
+  // resolves before that, in order to avoid blocking on network retries etc).
+  run_loop.Run();
   ASSERT_FALSE(background_mode_manager->IsBackgroundModeActive());
 }
 
 class PushMessagingBackgroundModeEnabledBrowserTest
     : public PushMessagingBrowserTest {
  public:
   ~PushMessagingBackgroundModeEnabledBrowserTest() override {}
 
   // PushMessagingBrowserTest:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitch(switches::kEnablePushApiBackgroundMode);
     PushMessagingBrowserTest::SetUpCommandLine(command_line);
   }
 };
 
 // In this test the command line enables push background mode.
 IN_PROC_BROWSER_TEST_F(PushMessagingBackgroundModeEnabledBrowserTest,
                        BackgroundModeEnabledWithCommandLine) {
   // Initially background mode is inactive.
   BackgroundModeManager* background_mode_manager =
       g_browser_process->background_mode_manager();
   ASSERT_FALSE(background_mode_manager->IsBackgroundModeActive());
 
   // Once there is a push subscription background mode is active.
   ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
   ASSERT_TRUE(background_mode_manager->IsBackgroundModeActive());
 
   // Dropping the last subscription deactivates background mode.
   std::string script_result;
+  base::RunLoop run_loop;
+  push_service()->SetUnsubscribeCallbackForTesting(run_loop.QuitClosure());
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
+  // Background mode is only guaranteed to have updated once the unsubscribe
+  // callback for testing has been run (PushSubscription.unsubscribe() usually
+  // resolves before that, in order to avoid blocking on network retries etc).
+  run_loop.Run();
   ASSERT_FALSE(background_mode_manager->IsBackgroundModeActive());
 }
 
 class PushMessagingBackgroundModeDisabledBrowserTest
     : public PushMessagingBrowserTest {
  public:
   ~PushMessagingBackgroundModeDisabledBrowserTest() override {}
 
   // PushMessagingBrowserTest:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitch(switches::kDisablePushApiBackgroundMode);
     PushMessagingBrowserTest::SetUpCommandLine(command_line);
   }
 };
 
 // In this test the command line disables push background mode.
 IN_PROC_BROWSER_TEST_F(PushMessagingBackgroundModeDisabledBrowserTest,
                        BackgroundModeDisabledWithCommandLine) {
   // Initially background mode is inactive.
   BackgroundModeManager* background_mode_manager =
       g_browser_process->background_mode_manager();
   ASSERT_FALSE(background_mode_manager->IsBackgroundModeActive());
 
   // Once there is a push subscription background mode is still inactive.
   ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
   ASSERT_FALSE(background_mode_manager->IsBackgroundModeActive());
 
   // After dropping the last subscription background mode is still inactive.
   std::string script_result;
+  base::RunLoop run_loop;
+  push_service()->SetUnsubscribeCallbackForTesting(run_loop.QuitClosure());
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
+  // Background mode is only guaranteed to have updated once the unsubscribe
+  // callback for testing has been run (PushSubscription.unsubscribe() usually
+  // resolves before that, in order to avoid blocking on network retries etc).
+  run_loop.Run();
   ASSERT_FALSE(background_mode_manager->IsBackgroundModeActive());
 }
 #endif  // BUILDFLAG(ENABLE_BACKGROUND) && !defined(OS_CHROMEOS)