Make Web Push use InstanceID tokens instead of GCM registrations

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 30 matching lines @@
 #include "chrome/browser/ui/website_settings/permission_bubble_manager.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/features.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/common/content_settings.h"
 #include "components/content_settings/core/common/content_settings_types.h"
 #include "components/gcm_driver/common/gcm_messages.h"
 #include "components/gcm_driver/gcm_client.h"
+#include "components/gcm_driver/instance_id/fake_gcm_driver_for_instance_id.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "ui/base/window_open_disposition.h"
 
 #if BUILDFLAG(ENABLE_BACKGROUND)
 #include "chrome/browser/background/background_mode_manager.h"
 #endif
 
 namespace {
 
+const char kManifestSenderId[] = "1234567890";
+
 // NIST P-256 public key made available to tests. Must be an uncompressed
 // point in accordance with SEC1 2.3.3.
 const uint8_t kApplicationServerKey[65] = {
     0x04, 0x55, 0x52, 0x6A, 0xA5, 0x6E, 0x8E, 0xAA, 0x47, 0x97, 0x36,
     0x10, 0xC1, 0x66, 0x3C, 0x1E, 0x65, 0xBF, 0xA1, 0x7B, 0xEE, 0x48,
     0xC9, 0xC6, 0xBB, 0xBF, 0x02, 0x18, 0x53, 0x72, 0x1D, 0x0C, 0x7B,
     0xA9, 0xE3, 0x11, 0xB7, 0x03, 0x52, 0x21, 0xD3, 0x71, 0x90, 0x13,
     0xA8, 0xC1, 0xCF, 0xED, 0x20, 0xF7, 0x1F, 0xD1, 0x7F, 0xF2, 0x76,
     0xB6, 0x01, 0x20, 0xD8, 0x35, 0xA5, 0xD9, 0x3C, 0x43, 0xFD};
 
 // URL-safe base64 encoded version of the |kApplicationServerKey|.
 const char kEncodedApplicationServerKey[] =
     "BFVSaqVujqpHlzYQwWY8HmW_oXvuSMnGu78CGFNyHQx7qeMRtwNSIdNxkBOowc_tIPcf0X_ydr"
     "YBINg1pdk8Q_0";
 
 std::string GetTestApplicationServerKey() {
   return std::string(kApplicationServerKey,
                      kApplicationServerKey + arraysize(kApplicationServerKey));
 }
 
-// Class to instantiate on the stack that is meant to be used with
-// FakeGCMProfileService. The ::Run() method follows the signature of
-// FakeGCMProfileService::UnregisterCallback.
-class UnregistrationCallback {
- public:
-  UnregistrationCallback()
-      : message_loop_runner_(new content::MessageLoopRunner) {}
-
-  void Run(const std::string& app_id) {
-    app_id_ = app_id;
-    message_loop_runner_->Quit();
-  }
-
-  void WaitUntilSatisfied() { message_loop_runner_->Run(); }
-
-  const std::string& app_id() { return app_id_; }
-
- private:
-  scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
-  std::string app_id_;
-};
+void LegacyRegisterCallback(const base::Closure& done_callback,
+                            std::string* out_registration_id,
+                            gcm::GCMClient::Result* out_result,
+                            const std::string& registration_id,
+                            gcm::GCMClient::Result result) {
+  *out_registration_id = registration_id;
+  *out_result = result;
+  done_callback.Run();
+}
 
 }  // namespace
 
 class PushMessagingBrowserTest : public InProcessBrowserTest {
  public:
-  PushMessagingBrowserTest() : gcm_service_(nullptr) {}
+  PushMessagingBrowserTest() : gcm_service_(nullptr), gcm_driver_(nullptr) {}
   ~PushMessagingBrowserTest() override {}
 
   // InProcessBrowserTest:
   void SetUp() override {
     https_server_.reset(
         new net::EmbeddedTestServer(net::EmbeddedTestServer::TYPE_HTTPS));
     https_server_->ServeFilesFromSourceDirectory("chrome/test/data");
     ASSERT_TRUE(https_server_->Start());
 
 #if defined(ENABLE_NOTIFICATIONS)
     notification_manager_.reset(new StubNotificationUIManager);
 #endif
 
     InProcessBrowserTest::SetUp();
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     // Enable experimental features for subscription restrictions.
     command_line->AppendSwitch(
         switches::kEnableExperimentalWebPlatformFeatures);
     InProcessBrowserTest::SetUpCommandLine(command_line);
   }
 
   // InProcessBrowserTest:
   void SetUpOnMainThread() override {
     gcm_service_ = static_cast<gcm::FakeGCMProfileService*>(
         gcm::GCMProfileServiceFactory::GetInstance()->SetTestingFactoryAndUse(
             GetBrowser()->profile(), &gcm::FakeGCMProfileService::Build));
-    gcm_service_->set_collect(true);
+    gcm_driver_ = static_cast<instance_id::FakeGCMDriverForInstanceID*>(
+        gcm_service_->driver());
+
     push_service_ =
         PushMessagingServiceFactory::GetForProfile(GetBrowser()->profile());
 #if defined(ENABLE_NOTIFICATIONS)
     display_service_.reset(new MessageCenterDisplayService(
         GetBrowser()->profile(), notification_manager_.get()));
     notification_service()->SetNotificationDisplayServiceForTesting(
         display_service_.get());
 #endif
 
     LoadTestPage();
     InProcessBrowserTest::SetUpOnMainThread();
   }
 
+  // Calls should be wrapped in the ASSERT_NO_FATAL_FAILURE() macro.
   void RestartPushService() {
     Profile* profile = GetBrowser()->profile();
     PushMessagingServiceFactory::GetInstance()->SetTestingFactory(profile,
                                                                   nullptr);
     ASSERT_EQ(nullptr, PushMessagingServiceFactory::GetForProfile(profile));
     PushMessagingServiceFactory::GetInstance()->RestoreFactoryForTests(profile);
     PushMessagingServiceImpl::InitializeForProfile(profile);
     push_service_ = PushMessagingServiceFactory::GetForProfile(profile);
   }
 
@@ skipping 33 matching lines @@
 
   bool RunScript(const std::string& script, std::string* result,
                  content::WebContents* web_contents) {
     if (!web_contents)
       web_contents = GetBrowser()->tab_strip_model()->GetActiveWebContents();
     return content::ExecuteScriptAndExtractString(web_contents->GetMainFrame(),
                                                   script, result);
   }
 
   gcm::GCMAppHandler* GetAppHandler() {
-    return gcm_service()->driver()->GetAppHandler(
-        kPushMessagingAppIdentifierPrefix);
+    return gcm_driver_->GetAppHandler(kPushMessagingAppIdentifierPrefix);
   }
 
   PermissionBubbleManager* GetPermissionBubbleManager() {
     return PermissionBubbleManager::FromWebContents(
         GetBrowser()->tab_strip_model()->GetActiveWebContents());
   }
 
+  // Calls should be wrapped in the ASSERT_NO_FATAL_FAILURE() macro.
   void RequestAndAcceptPermission();
+  // Calls should be wrapped in the ASSERT_NO_FATAL_FAILURE() macro.
   void RequestAndDenyPermission();
 
-  void TryToSubscribeSuccessfully(
-      const std::string& expected_push_subscription_info,
-      bool use_key = true);
+  // Sets out_token to the subscription token (not including server URL).
+  // Calls should be wrapped in the ASSERT_NO_FATAL_FAILURE() macro.
+  void SubscribeSuccessfully(bool use_key = true,
+                             std::string* out_token = nullptr);
 
-  std::string GetEndpointForSubscriptionId(const std::string& subscription_id,
-                                           bool standard_protocol = true) {
-    return push_service()->GetEndpoint(standard_protocol).spec() +
-           subscription_id;
-  }
+  // Legacy subscribe path using GCMDriver rather than Instance IDs. Only
+  // for testing that we maintain support for existing stored registrations.
+  // Calls should be wrapped in the ASSERT_NO_FATAL_FAILURE() macro.
+  void LegacySubscribeSuccessfully(std::string* out_registration_id);
+
+  // Strips server URL from a registration endpoint to get subscription token.
+  // Calls should be wrapped in the ASSERT_NO_FATAL_FAILURE() macro.
+  void EndpointToToken(const std::string& endpoint,
+                       bool standard_protocol = true,
+                       std::string* out_token = nullptr);
 
   PushMessagingAppIdentifier GetAppIdentifierForServiceWorkerRegistration(
       int64_t service_worker_registration_id);
 
   void SendMessageAndWaitUntilHandled(
       const PushMessagingAppIdentifier& app_identifier,
       const gcm::IncomingMessage& message);
 
   net::EmbeddedTestServer* https_server() const { return https_server_.get(); }
 
-  gcm::FakeGCMProfileService* gcm_service() const { return gcm_service_; }
-
 #if defined(ENABLE_NOTIFICATIONS)
   // To be called when delivery of a push message has finished. The |run_loop|
   // will be told to quit after |messages_required| messages were received.
   void OnDeliveryFinished(std::vector<size_t>* number_of_notifications_shown,
                           const base::Closure& done_closure) {
     DCHECK(number_of_notifications_shown);
 
     number_of_notifications_shown->push_back(
         notification_manager_->GetNotificationCount());
 
@@ skipping 17 matching lines @@
     service->ResetScoreForURL(url, score);
   }
 
  protected:
   virtual std::string GetTestURL() { return "/push_messaging/test.html"; }
 
   virtual Browser* GetBrowser() const { return browser(); }
 
   base::HistogramTester* GetHistogramTester() { return &histogram_tester_; }
 
- private:
+ protected:
   std::unique_ptr<net::EmbeddedTestServer> https_server_;
   gcm::FakeGCMProfileService* gcm_service_;
+  instance_id::FakeGCMDriverForInstanceID* gcm_driver_;
   PushMessagingServiceImpl* push_service_;
   base::HistogramTester histogram_tester_;
 
 #if defined(ENABLE_NOTIFICATIONS)
   std::unique_ptr<StubNotificationUIManager> notification_manager_;
   std::unique_ptr<MessageCenterDisplayService> display_service_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(PushMessagingBrowserTest);
 };
 
 class PushMessagingBrowserTestEmptySubscriptionOptions
     : public PushMessagingBrowserTest {
   std::string GetTestURL() override {
     return "/push_messaging/test_no_subscription_options.html";
   }
 };
 
 void PushMessagingBrowserTest::RequestAndAcceptPermission() {
   std::string script_result;
   GetPermissionBubbleManager()->set_auto_response_for_test(
       PermissionBubbleManager::ACCEPT_ALL);
-  EXPECT_TRUE(RunScript("requestNotificationPermission();", &script_result));
-  EXPECT_EQ("permission status - granted", script_result);
+  ASSERT_TRUE(RunScript("requestNotificationPermission();", &script_result));
+  ASSERT_EQ("permission status - granted", script_result);
 }
 
 void PushMessagingBrowserTest::RequestAndDenyPermission() {
   std::string script_result;
   GetPermissionBubbleManager()->set_auto_response_for_test(
       PermissionBubbleManager::DENY_ALL);
-  EXPECT_TRUE(RunScript("requestNotificationPermission();", &script_result));
-  EXPECT_EQ("permission status - denied", script_result);
+  ASSERT_TRUE(RunScript("requestNotificationPermission();", &script_result));
+  ASSERT_EQ("permission status - denied", script_result);
 }
 
-void PushMessagingBrowserTest::TryToSubscribeSuccessfully(
-    const std::string& expected_push_subscription_info,
-    bool use_key) {
+void PushMessagingBrowserTest::SubscribeSuccessfully(bool use_key,
+                                                     std::string* out_token) {
   std::string script_result;
 
-  EXPECT_TRUE(RunScript("registerServiceWorker()", &script_result));
-  EXPECT_EQ("ok - service worker registered", script_result);
+  ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
+  ASSERT_EQ("ok - service worker registered", script_result);
 
-  RequestAndAcceptPermission();
+  ASSERT_NO_FATAL_FAILURE(RequestAndAcceptPermission());
 
   if (use_key) {
     ASSERT_TRUE(RunScript("removeManifest()", &script_result));
     ASSERT_EQ("manifest removed", script_result);
 
-    EXPECT_TRUE(RunScript("documentSubscribePush()", &script_result));
+    ASSERT_TRUE(RunScript("documentSubscribePush()", &script_result));
   } else {
     // Test backwards compatibility with old ID based subscriptions.
-    EXPECT_TRUE(RunScript("documentSubscribePushWithoutKey()", &script_result));
+    ASSERT_TRUE(RunScript("documentSubscribePushWithoutKey()", &script_result));
   }
 
-  EXPECT_EQ(
-      GetEndpointForSubscriptionId(expected_push_subscription_info, use_key),
-      script_result);
+  ASSERT_NO_FATAL_FAILURE(EndpointToToken(script_result, use_key, out_token));
+}
+
+void PushMessagingBrowserTest::LegacySubscribeSuccessfully(
+    std::string* out_registration_id) {
+  // Create a non-InstanceID GCM registration. We have to directly access

[Peter Beverloo, 2016/06/02 15:53:17]

micro nit: no 'we' in comments. I also question the value of the final part of
this comment- the code only cares about the current (and maybe future) state of
itself.

[johnme, 2016/06/07 14:16:42]

Removed we. The 2nd part seems useful in explaining why this code is here rather
than in say PushMessagingServiceImpl.

+  // GCMDriver, since this codepath has been deleted from Push.
+  DCHECK(out_registration_id);
+
+  std::string script_result;
+  ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
+  ASSERT_EQ("ok - service worker registered", script_result);
+
+  ASSERT_NO_FATAL_FAILURE(RequestAndAcceptPermission());
+
+  GURL requesting_origin = https_server()->GetURL("/").GetOrigin();
+  int64_t service_worker_registration_id = 0LL;
+  PushMessagingAppIdentifier app_identifier =
+      PushMessagingAppIdentifier::Generate(requesting_origin,
+                                           service_worker_registration_id);
+  push_service_->IncreasePushSubscriptionCount(1, true /* is_pending */);
+
+  {
+    base::RunLoop run_loop;
+    gcm::GCMClient::Result register_result = gcm::GCMClient::UNKNOWN_ERROR;
+    gcm_driver_->Register(
+        app_identifier.app_id(), {kManifestSenderId},
+        base::Bind(&LegacyRegisterCallback, run_loop.QuitClosure(),
+                   out_registration_id, &register_result));
+    run_loop.Run();
+    ASSERT_EQ(gcm::GCMClient::SUCCESS, register_result);
+  }
+
+  app_identifier.PersistToPrefs(GetBrowser()->profile());
+  push_service_->IncreasePushSubscriptionCount(1, false /* is_pending */);
+  push_service_->DecreasePushSubscriptionCount(1, true /* was_pending */);
+
+  {
+    base::RunLoop run_loop;
+    push_service_->StorePushSubscriptionForTesting(
+        GetBrowser()->profile(),
+        requesting_origin,
+        service_worker_registration_id,
+        *out_registration_id,
+        kManifestSenderId,
+        run_loop.QuitClosure());
+    run_loop.Run();
+  }
+}
+
+void PushMessagingBrowserTest::EndpointToToken(const std::string& endpoint,
+                                               bool standard_protocol,
+                                               std::string* out_token) {

[Peter Beverloo, 2016/06/02 15:53:17]

This file has an inconsistency between requiring out_* values and having them be
optional. Could we do one or the other? (My preference is always requiring
them.)

[johnme, 2016/06/07 14:16:42]

Done. Made them all optional, since there are 21 calls to SubscribeSuccessfully
alone which don't pass an out_token, and it would add a lot of clutter to
require that.

+  size_t last_slash = endpoint.rfind('/');
+
+  ASSERT_EQ(endpoint.substr(0, last_slash + 1),
+            push_service()->GetEndpoint(standard_protocol).spec());
+
+  // Generous token sanity check.
+  size_t min_token_length = 5;

[Peter Beverloo, 2016/06/02 15:53:17]

Why 5? Why not >0? If there is no known size, let's not care about it at all?

[johnme, 2016/06/07 14:16:42]

Done (now only check it's non-empty).

+  ASSERT_LT(last_slash, endpoint.length() - min_token_length);
+
+  if (out_token)
+    *out_token = endpoint.substr(last_slash + 1);
 }
 
 PushMessagingAppIdentifier
 PushMessagingBrowserTest::GetAppIdentifierForServiceWorkerRegistration(
     int64_t service_worker_registration_id) {
   GURL origin = https_server()->GetURL("/").GetOrigin();
   PushMessagingAppIdentifier app_identifier =
       PushMessagingAppIdentifier::FindByServiceWorker(
           GetBrowser()->profile(), origin, service_worker_registration_id);
   EXPECT_FALSE(app_identifier.is_null());
   return app_identifier;
 }
 
 void PushMessagingBrowserTest::SendMessageAndWaitUntilHandled(
     const PushMessagingAppIdentifier& app_identifier,
     const gcm::IncomingMessage& message) {
   base::RunLoop run_loop;
   push_service()->SetMessageCallbackForTesting(run_loop.QuitClosure());
   push_service()->OnMessage(app_identifier.app_id(), message);
   run_loop.Run();
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        SubscribeWithoutKeySuccessNotificationsGranted) {
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */, false);
-
-  PushMessagingAppIdentifier app_identifier =
-      GetAppIdentifierForServiceWorkerRegistration(0LL);
-  EXPECT_EQ(app_identifier.app_id(), gcm_service()->last_registered_app_id());
-  EXPECT_EQ("1234567890", gcm_service()->last_registered_sender_ids()[0]);
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully(false /* use_key */));
+  EXPECT_EQ(kManifestSenderId, gcm_driver_->last_gettoken_authorized_entity());
+  EXPECT_EQ(GetAppIdentifierForServiceWorkerRegistration(0LL).app_id(),
+            gcm_driver_->last_gettoken_app_id());
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        SubscribeSuccessNotificationsGranted) {
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
-
-  PushMessagingAppIdentifier app_identifier =
-      GetAppIdentifierForServiceWorkerRegistration(0LL);
-  EXPECT_EQ(app_identifier.app_id(), gcm_service()->last_registered_app_id());
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
   EXPECT_EQ(kEncodedApplicationServerKey,
-            gcm_service()->last_registered_sender_ids()[0]);
+            gcm_driver_->last_gettoken_authorized_entity());
+  EXPECT_EQ(GetAppIdentifierForServiceWorkerRegistration(0LL).app_id(),
+            gcm_driver_->last_gettoken_app_id());
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        SubscribeSuccessNotificationsPrompt) {
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
   GetPermissionBubbleManager()->set_auto_response_for_test(
       PermissionBubbleManager::ACCEPT_ALL);
   ASSERT_TRUE(RunScript("documentSubscribePush()", &script_result));
-  EXPECT_EQ(GetEndpointForSubscriptionId("1-0"), script_result);
-
-  PushMessagingAppIdentifier app_identifier =
-      GetAppIdentifierForServiceWorkerRegistration(0LL);
-  EXPECT_EQ(app_identifier.app_id(), gcm_service()->last_registered_app_id());
-  EXPECT_EQ(kEncodedApplicationServerKey,
-            gcm_service()->last_registered_sender_ids()[0]);
+  // Both of these methods EXPECT that they succeed.
+  ASSERT_NO_FATAL_FAILURE(EndpointToToken(script_result));
+  GetAppIdentifierForServiceWorkerRegistration(0LL);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, SubscribeFailureBadKey) {
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
-  RequestAndAcceptPermission();
+  ASSERT_NO_FATAL_FAILURE(RequestAndAcceptPermission());
 
   ASSERT_TRUE(RunScript("documentSubscribePushBadKey()", &script_result));
   EXPECT_EQ(
       "InvalidAccessError - Failed to execute 'subscribe' on 'PushManager': "
       "The provided applicationServerKey is not valid.",
       script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        SubscribeFailureNotificationsBlocked) {
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
-  RequestAndDenyPermission();
+  ASSERT_NO_FATAL_FAILURE(RequestAndDenyPermission());
 
   ASSERT_TRUE(RunScript("documentSubscribePush()", &script_result));
   EXPECT_EQ("PermissionDeniedError - Registration failed - permission denied",
             script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, SubscribeFailureNoManifest) {
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
-  RequestAndAcceptPermission();
+  ASSERT_NO_FATAL_FAILURE(RequestAndAcceptPermission());
 
   ASSERT_TRUE(RunScript("removeManifest()", &script_result));
   ASSERT_EQ("manifest removed", script_result);
 
   ASSERT_TRUE(RunScript("documentSubscribePushWithoutKey()", &script_result));
   EXPECT_EQ("AbortError - Registration failed - manifest empty or missing",
             script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, SubscribeFailureNoSenderId) {
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
-  RequestAndAcceptPermission();
+  ASSERT_NO_FATAL_FAILURE(RequestAndAcceptPermission());
 
   ASSERT_TRUE(RunScript("swapManifestNoSenderId()", &script_result));
   ASSERT_EQ("sender id removed from manifest", script_result);
 
   ASSERT_TRUE(RunScript("documentSubscribePushWithoutKey()", &script_result));
   EXPECT_EQ(
       "AbortError - Registration failed - gcm_sender_id not found in manifest",
       script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTestEmptySubscriptionOptions,
                        RegisterFailureEmptyPushSubscriptionOptions) {
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
-  RequestAndAcceptPermission();
+  ASSERT_NO_FATAL_FAILURE(RequestAndAcceptPermission());
 
   ASSERT_TRUE(RunScript("documentSubscribePush()", &script_result));
   EXPECT_EQ("PermissionDeniedError - Registration failed - permission denied",
             script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, SubscribeWorker) {
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
-  RequestAndAcceptPermission();
+  ASSERT_NO_FATAL_FAILURE(RequestAndAcceptPermission());
 
   LoadTestPage();  // Reload to become controlled.
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("true - is controlled", script_result);
 
   // Try to subscribe from a worker without a key. This should fail.
   ASSERT_TRUE(RunScript("workerSubscribePushNoKey()", &script_result));
   EXPECT_EQ(
       "AbortError - Registration failed - gcm_sender_id not found in manifest",
       script_result);
   // Now run the subscribe from the service worker with a key. This
   // should succeed, and write the key to the datastore.
   ASSERT_TRUE(RunScript("workerSubscribePush()", &script_result));
-  EXPECT_EQ(GetEndpointForSubscriptionId("1-0"), script_result);
+  std::string token1;
+  ASSERT_NO_FATAL_FAILURE(
+      EndpointToToken(script_result, true /* standard_protocol */, &token1));
 
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
   EXPECT_NE(push_service(), GetAppHandler());
 
   // Now run the subscribe from the service worker without a key.
   // In this case, the key will be read from the datastore.
   ASSERT_TRUE(RunScript("workerSubscribePushNoKey()", &script_result));
-  EXPECT_EQ(GetEndpointForSubscriptionId("1-1"), script_result);
+  std::string token2;
+  ASSERT_NO_FATAL_FAILURE(
+      EndpointToToken(script_result, true /* standard_protocol */, &token2));
+  EXPECT_NE(token1, token2);
 
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
   EXPECT_NE(push_service(), GetAppHandler());
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, SubscribeWorkerUsingManifest) {
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
-  RequestAndAcceptPermission();
+  ASSERT_NO_FATAL_FAILURE(RequestAndAcceptPermission());
 
   LoadTestPage();  // Reload to become controlled.
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("true - is controlled", script_result);
 
   // Try to subscribe from a worker without a key. This should fail.
   ASSERT_TRUE(RunScript("workerSubscribePushNoKey()", &script_result));
   EXPECT_EQ(
       "AbortError - Registration failed - gcm_sender_id not found in manifest",
       script_result);
   EXPECT_NE(push_service(), GetAppHandler());
 
   // Run the subscription from the document without a key, this will trigger
   // the code to read sender id from the manifest and will write it to the
   // datastore.
   ASSERT_TRUE(RunScript("documentSubscribePushWithoutKey()", &script_result));
-  EXPECT_EQ(GetEndpointForSubscriptionId("1-0", false), script_result);
+  std::string token1;
+  ASSERT_NO_FATAL_FAILURE(
+      EndpointToToken(script_result, false /* standard_protocol */, &token1));
 
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
   EXPECT_NE(push_service(), GetAppHandler());
 
   // Now run the subscribe from the service worker without a key.
   // In this case, the sender id will be read from the datastore.
   ASSERT_TRUE(RunScript("workerSubscribePushNoKey()", &script_result));
-  EXPECT_EQ(GetEndpointForSubscriptionId("1-1", false), script_result);
+  std::string token2;
+  ASSERT_NO_FATAL_FAILURE(
+      EndpointToToken(script_result, false /* standard_protocol */, &token2));
+  EXPECT_NE(token1, token2);
 
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
   EXPECT_NE(push_service(), GetAppHandler());
 }
 
 // Disabled on Windows and Linux due to flakiness (http://crbug.com/554003).
 #if defined(OS_WIN) || defined(OS_LINUX)
 #define MAYBE_SubscribePersisted DISABLED_SubscribePersisted
 #else
 #define MAYBE_SubscribePersisted SubscribePersisted
 #endif
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, MAYBE_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).
 
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
+  std::string token1;
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully(true /* use_key */, &token1));
   PushMessagingAppIdentifier sw0_identifier =
       GetAppIdentifierForServiceWorkerRegistration(0LL);
-  EXPECT_EQ(sw0_identifier.app_id(), gcm_service()->last_registered_app_id());
+  EXPECT_EQ(sw0_identifier.app_id(), gcm_driver_->last_gettoken_app_id());
 
   LoadTestPage("/push_messaging/subscope1/test.html");
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
   LoadTestPage("/push_messaging/subscope2/test.html");
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
   // Note that we need to reload the page after registering, otherwise
   // navigator.serviceWorker.ready is going to be resolved with the parent
   // Service Worker which still controls the page.
   LoadTestPage("/push_messaging/subscope2/test.html");
-  TryToSubscribeSuccessfully("1-1" /* expected_push_subscription_id */);
+  std::string token2;
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully(true /* use_key */, &token2));
+  EXPECT_NE(token1, token2);
   PushMessagingAppIdentifier sw2_identifier =
       GetAppIdentifierForServiceWorkerRegistration(2LL);
-  EXPECT_EQ(sw2_identifier.app_id(), gcm_service()->last_registered_app_id());
+  EXPECT_EQ(sw2_identifier.app_id(), gcm_driver_->last_gettoken_app_id());
 
   LoadTestPage("/push_messaging/subscope1/test.html");
-  TryToSubscribeSuccessfully("1-2" /* expected_push_subscription_id */);
+  std::string token3;
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully(true /* use_key */, &token3));
+  EXPECT_NE(token1, token3);
+  EXPECT_NE(token2, token3);
   PushMessagingAppIdentifier sw1_identifier =
       GetAppIdentifierForServiceWorkerRegistration(1LL);
-  EXPECT_EQ(sw1_identifier.app_id(), gcm_service()->last_registered_app_id());
+  EXPECT_EQ(sw1_identifier.app_id(), gcm_driver_->last_gettoken_app_id());
 
   // Now test that the Service Worker registration IDs and push subscription IDs
   // generated above were persisted to SW storage, by checking that they are
   // unchanged despite requesting them in a different order.
   // TODO(johnme): Ideally we would restart the browser at this point to check
   // they were persisted to disk, but that's not currently possible since the
   // test server uses random port numbers for each test (even PRE_Foo and Foo),
   // so we wouldn't be able to load the test pages with the same origin.
 
   LoadTestPage("/push_messaging/subscope1/test.html");
-  TryToSubscribeSuccessfully("1-2" /* expected_push_subscription_id */);
-  EXPECT_EQ(sw1_identifier.app_id(), gcm_service()->last_registered_app_id());
+  std::string token4;
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully(true /* use_key */, &token4));
+  EXPECT_EQ(token3, token4);
+  EXPECT_EQ(sw1_identifier.app_id(), gcm_driver_->last_gettoken_app_id());
 
   LoadTestPage("/push_messaging/subscope2/test.html");
-  TryToSubscribeSuccessfully("1-1" /* expected_push_subscription_id */);
-  EXPECT_EQ(sw1_identifier.app_id(), gcm_service()->last_registered_app_id());
+  std::string token5;
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully(true /* use_key */, &token5));
+  EXPECT_EQ(token2, token5);
+  EXPECT_EQ(sw1_identifier.app_id(), gcm_driver_->last_gettoken_app_id());
 
   LoadTestPage();
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
-  EXPECT_EQ(sw1_identifier.app_id(), gcm_service()->last_registered_app_id());
+  std::string token6;
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully(true /* use_key */, &token6));
+  EXPECT_EQ(token1, token6);
+  EXPECT_EQ(sw1_identifier.app_id(), gcm_driver_->last_gettoken_app_id());
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, AppHandlerOnlyIfSubscribed) {
   // This test restarts the push service to simulate restarting the browser.
 
   EXPECT_NE(push_service(), GetAppHandler());
   ASSERT_NO_FATAL_FAILURE(RestartPushService());
   EXPECT_NE(push_service(), GetAppHandler());
 
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
 
   EXPECT_EQ(push_service(), GetAppHandler());
   ASSERT_NO_FATAL_FAILURE(RestartPushService());
   EXPECT_EQ(push_service(), GetAppHandler());
 
   // Unsubscribe.
   std::string script_result;
-  gcm_service()->AddExpectedUnregisterResponse(gcm::GCMClient::SUCCESS);
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
 
   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;
 
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
-
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
   PushMessagingAppIdentifier app_identifier =
       GetAppIdentifierForServiceWorkerRegistration(0LL);
-  EXPECT_EQ(app_identifier.app_id(), gcm_service()->last_registered_app_id());
-  EXPECT_EQ(kEncodedApplicationServerKey,
-            gcm_service()->last_registered_sender_ids()[0]);
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("false - is not controlled", script_result);
 
   LoadTestPage();  // Reload to become controlled.
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("true - is controlled", script_result);
 
   EXPECT_TRUE(IsRegisteredKeepAliveEqualTo(false));
   gcm::IncomingMessage message;
   message.sender_id = GetTestApplicationServerKey();
   message.raw_data = "testdata";
   message.decrypted = true;
   push_service()->OnMessage(app_identifier.app_id(), message);
   EXPECT_TRUE(IsRegisteredKeepAliveEqualTo(true));
   ASSERT_TRUE(RunScript("resultQueue.pop()", &script_result));
   EXPECT_EQ("testdata", script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, PushEventWithoutPayload) {
   std::string script_result;
 
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
-
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
   PushMessagingAppIdentifier app_identifier =
       GetAppIdentifierForServiceWorkerRegistration(0LL);
-  EXPECT_EQ(app_identifier.app_id(), gcm_service()->last_registered_app_id());
-  EXPECT_EQ(kEncodedApplicationServerKey,
-            gcm_service()->last_registered_sender_ids()[0]);
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("false - is not controlled", script_result);
 
   LoadTestPage();  // Reload to become controlled.
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("true - is controlled", script_result);
 
   gcm::IncomingMessage message;
   message.sender_id = GetTestApplicationServerKey();
   message.decrypted = false;
 
   push_service()->OnMessage(app_identifier.app_id(), message);
   ASSERT_TRUE(RunScript("resultQueue.pop()", &script_result));
   EXPECT_EQ("[NULL]", script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, PushEventNoServiceWorker) {
   std::string script_result;
 
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
-
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
   PushMessagingAppIdentifier app_identifier =
       GetAppIdentifierForServiceWorkerRegistration(0LL);
-  EXPECT_EQ(app_identifier.app_id(), gcm_service()->last_registered_app_id());
-  EXPECT_EQ(kEncodedApplicationServerKey,
-            gcm_service()->last_registered_sender_ids()[0]);
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("false - is not controlled", script_result);
 
   LoadTestPage();  // Reload to become controlled.
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("true - is controlled", script_result);
 
   // Unregister service worker. Sending a message should now fail.
   ASSERT_TRUE(RunScript("unregisterServiceWorker()", &script_result));
   ASSERT_EQ("service worker unregistration status: true", script_result);
 
-  // When the push service will receive it next message, given that there is no
-  // SW available, it should unregister |app_identifier.app_id()|.
-  UnregistrationCallback callback;
-  gcm_service()->SetUnregisterCallback(
-      base::Bind(&UnregistrationCallback::Run, base::Unretained(&callback)));
+  // Unregistering the service worker doesn't yet unsubscribe from push (though
+  // it should), and FindByServiceWorker doesn't require a live SW.
+  GURL origin = https_server()->GetURL("/").GetOrigin();
+  PushMessagingAppIdentifier app_identifier2 =
+      PushMessagingAppIdentifier::FindByServiceWorker(
+          GetBrowser()->profile(), origin,
+          0LL /* service_worker_registration_id */);
+  EXPECT_FALSE(app_identifier2.is_null());
+  EXPECT_EQ(app_identifier.app_id(), app_identifier2.app_id());
 
   gcm::IncomingMessage message;
   message.sender_id = GetTestApplicationServerKey();
   message.raw_data = "testdata";
   message.decrypted = true;
+
+  base::RunLoop run_loop;
+  push_service()->SetMessageCallbackForTesting(run_loop.QuitClosure());
   EXPECT_TRUE(IsRegisteredKeepAliveEqualTo(false));
   push_service()->OnMessage(app_identifier.app_id(), message);
   EXPECT_TRUE(IsRegisteredKeepAliveEqualTo(true));
-  callback.WaitUntilSatisfied();
+  run_loop.Run();
   EXPECT_TRUE(IsRegisteredKeepAliveEqualTo(false));
-  EXPECT_EQ(app_identifier.app_id(), callback.app_id());
+
+  // Now the push service has received a message and failed to find its service
+  // worker, it should have automatically unsubscribed app_identifier.app_id().
+  PushMessagingAppIdentifier app_identifier3 =
+      PushMessagingAppIdentifier::FindByServiceWorker(
+          GetBrowser()->profile(), origin,
+          0LL /* service_worker_registration_id */);
+  EXPECT_TRUE(app_identifier3.is_null());
 
   // No push data should have been received.
   ASSERT_TRUE(RunScript("resultQueue.popImmediately()", &script_result));
   EXPECT_EQ("null", script_result);
 }
 
 #if defined(ENABLE_NOTIFICATIONS)
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        PushEventEnforcesUserVisibleNotification) {
   std::string script_result;
 
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
-
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
   PushMessagingAppIdentifier app_identifier =
       GetAppIdentifierForServiceWorkerRegistration(0LL);
-  EXPECT_EQ(app_identifier.app_id(), gcm_service()->last_registered_app_id());
-  EXPECT_EQ(kEncodedApplicationServerKey,
-            gcm_service()->last_registered_sender_ids()[0]);
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("false - is not controlled", script_result);
 
   LoadTestPage();  // Reload to become controlled.
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("true - is controlled", script_result);
 
   notification_manager()->CancelAll();
@@ skipping 108 matching lines @@
           "PushMessaging.SESForLowBudgetOrigin");
   ASSERT_EQ(1.0, low_budget_buckets.size());
   EXPECT_EQ(4, low_budget_buckets[0].min);
   EXPECT_EQ(1, low_budget_buckets[0].count);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        PushEventAllowSilentPushCommandLineFlag) {
   std::string script_result;
 
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
-
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
   PushMessagingAppIdentifier app_identifier =
       GetAppIdentifierForServiceWorkerRegistration(0LL);
-  EXPECT_EQ(app_identifier.app_id(), gcm_service()->last_registered_app_id());
+  EXPECT_EQ(app_identifier.app_id(), gcm_driver_->last_gettoken_app_id());
   EXPECT_EQ(kEncodedApplicationServerKey,
-            gcm_service()->last_registered_sender_ids()[0]);
+            gcm_driver_->last_gettoken_authorized_entity());
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("false - is not controlled", script_result);
 
   LoadTestPage();  // Reload to become controlled.
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("true - is controlled", script_result);
 
   notification_manager()->CancelAll();
@@ skipping 44 matching lines @@
   ASSERT_TRUE(RunScript("resultQueue.pop()", &script_result, web_contents));
   EXPECT_EQ("testdata", script_result);
 
   ASSERT_EQ(0u, notification_manager()->GetNotificationCount());
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        PushEventEnforcesUserVisibleNotificationAfterQueue) {
   std::string script_result;
 
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
-
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
   PushMessagingAppIdentifier app_identifier =
       GetAppIdentifierForServiceWorkerRegistration(0LL);
-  EXPECT_EQ(app_identifier.app_id(), gcm_service()->last_registered_app_id());
-  EXPECT_EQ(kEncodedApplicationServerKey,
-            gcm_service()->last_registered_sender_ids()[0]);
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("false - is not controlled", script_result);
 
   LoadTestPage();  // Reload to become controlled.
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("true - is controlled", script_result);
 
   // Fire off two push messages in sequence, only the second one of which will
@@ skipping 27 matching lines @@
   EXPECT_EQ(0u, number_of_notifications_shown[0]);
   EXPECT_EQ(1u, number_of_notifications_shown[1]);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        PushEventNotificationWithoutEventWaitUntil) {
   std::string script_result;
   content::WebContents* web_contents =
       GetBrowser()->tab_strip_model()->GetActiveWebContents();
 
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
-
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
   PushMessagingAppIdentifier app_identifier =
       GetAppIdentifierForServiceWorkerRegistration(0LL);
-  EXPECT_EQ(app_identifier.app_id(), gcm_service()->last_registered_app_id());
-  EXPECT_EQ(kEncodedApplicationServerKey,
-            gcm_service()->last_registered_sender_ids()[0]);
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("false - is not controlled", script_result);
 
   LoadTestPage();  // Reload to become controlled.
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("true - is controlled", script_result);
 
   scoped_refptr<content::MessageLoopRunner> message_loop_runner =
@@ skipping 33 matching lines @@
   ASSERT_TRUE(RunScript("permissionState()", &script_result));
   ASSERT_EQ("permission status - prompt", script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, PermissionStateSaysGranted) {
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
-  RequestAndAcceptPermission();
+  ASSERT_NO_FATAL_FAILURE(RequestAndAcceptPermission());
 
   ASSERT_TRUE(RunScript("documentSubscribePush()", &script_result));
-  EXPECT_EQ(GetEndpointForSubscriptionId("1-0"), script_result);
+  ASSERT_NO_FATAL_FAILURE(EndpointToToken(script_result));
 
   ASSERT_TRUE(RunScript("permissionState()", &script_result));
   EXPECT_EQ("permission status - granted", script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, PermissionStateSaysDenied) {
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
-  RequestAndDenyPermission();
+  ASSERT_NO_FATAL_FAILURE(RequestAndDenyPermission());
 
   ASSERT_TRUE(RunScript("documentSubscribePush()", &script_result));
   EXPECT_EQ("PermissionDeniedError - Registration failed - permission denied",
             script_result);
 
   ASSERT_TRUE(RunScript("permissionState()", &script_result));
   EXPECT_EQ("permission status - denied", script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, UnsubscribeSuccess) {
   std::string script_result;
 
   EXPECT_TRUE(RunScript("registerServiceWorker()", &script_result));
   EXPECT_EQ("ok - service worker registered", script_result);
 
   // Resolves true if there was a subscription.
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */, false);
-  gcm_service()->AddExpectedUnregisterResponse(gcm::GCMClient::SUCCESS);
+  std::string token1;
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully(false /* use_key */, &token1));
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
 
+  // Resolves false if there was no longer a subscription.
+  ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
+  EXPECT_EQ("unsubscribe result: false", script_result);
+
+  // TODO(johnme): Test that doesn't reject if there was a network error (should
+  // deactivate subscription locally anyway).
+  // TODO(johnme): Test that doesn't reject if there were other push service
+  // errors (should deactivate subscription locally anyway).
+
+  // Unsubscribing (with an existing reference to a PushSubscription), after
+  // unregistering the Service Worker, just means push subscription isn't found.
+  std::string token2;
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully(false /* use_key */, &token2));
+  EXPECT_NE(token1, token2);
+  ASSERT_TRUE(RunScript("unregisterServiceWorker()", &script_result));
+  ASSERT_EQ("service worker unregistration status: true", script_result);
+  ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
+  EXPECT_EQ("unsubscribe result: false", script_result);
+}
+
+// Push subscriptions used to be non-InstanceID GCM registrations. We still need

[Peter Beverloo, 2016/06/02 15:53:17]

nit: no 'we'

[johnme, 2016/06/07 14:16:42]

Done.

+// to be able to unsubscribe these, even though we no longer create new ones.
+IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, LegacyUnsubscribeSuccess) {

[Peter Beverloo, 2016/06/02 15:53:17]

Can we test receiving messages for `legacy` subscriptions?

In line with the comments I shared when reviewing the GCM Driver changes, I
still have a very strong preference for avoiding the use of "legacy" in our
code.

[johnme, 2016/06/07 14:16:42]

Done
I still have a strong preference for testing migrated data that our users
continue to depend on :)

+  std::string script_result;
+
+  // Resolves true if there was a subscription.
+  std::string registration_id1;
+  ASSERT_NO_FATAL_FAILURE(LegacySubscribeSuccessfully(&registration_id1));
+  gcm_service_->AddExpectedUnregisterResponse(gcm::GCMClient::SUCCESS);
+  ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
+  EXPECT_EQ("unsubscribe result: true", script_result);
+
   // Resolves false if there was no longer a subscription.
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: false", script_result);
 
   // Doesn't reject if there was a network error (deactivates subscription
   // locally anyway).
-  TryToSubscribeSuccessfully("1-1" /* expected_push_subscription_id */, false);
-  gcm_service()->AddExpectedUnregisterResponse(gcm::GCMClient::NETWORK_ERROR);
+  std::string registration_id2;
+  ASSERT_NO_FATAL_FAILURE(LegacySubscribeSuccessfully(&registration_id2));
+  EXPECT_NE(registration_id1, registration_id2);
+  gcm_service_->AddExpectedUnregisterResponse(gcm::GCMClient::NETWORK_ERROR);
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
   ASSERT_TRUE(RunScript("hasSubscription()", &script_result));
   EXPECT_EQ("false - not subscribed", script_result);
 
   // Doesn't reject if there were other push service errors (deactivates
   // subscription locally anyway).
-  TryToSubscribeSuccessfully("1-2" /* expected_push_subscription_id */, false);
-  gcm_service()->AddExpectedUnregisterResponse(
+  std::string registration_id3;
+  ASSERT_NO_FATAL_FAILURE(LegacySubscribeSuccessfully(&registration_id3));
+  EXPECT_NE(registration_id1, registration_id3);
+  EXPECT_NE(registration_id2, registration_id3);
+  gcm_service_->AddExpectedUnregisterResponse(
       gcm::GCMClient::INVALID_PARAMETER);
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
 
   // Unsubscribing (with an existing reference to a PushSubscription), after
   // unregistering the Service Worker, just means push subscription isn't found.
-  TryToSubscribeSuccessfully("1-3" /* expected_push_subscription_id */, false);
+  std::string registration_id4;
+  ASSERT_NO_FATAL_FAILURE(LegacySubscribeSuccessfully(&registration_id4));
+  EXPECT_NE(registration_id1, registration_id4);
+  EXPECT_NE(registration_id2, registration_id4);
+  EXPECT_NE(registration_id3, registration_id4);
   ASSERT_TRUE(RunScript("unregisterServiceWorker()", &script_result));
   ASSERT_EQ("service worker unregistration status: true", script_result);
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: false", script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        GlobalResetPushPermissionUnsubscribes) {
   std::string script_result;
 
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
 
   ASSERT_TRUE(RunScript("hasSubscription()", &script_result));
   EXPECT_EQ("true - subscribed", script_result);
 
   ASSERT_TRUE(RunScript("permissionState()", &script_result));
   EXPECT_EQ("permission status - granted", script_result);
 
   scoped_refptr<content::MessageLoopRunner> message_loop_runner =
       new content::MessageLoopRunner;
   push_service()->SetContentSettingChangedCallbackForTesting(
@@ skipping 11 matching lines @@
   EXPECT_EQ("permission status - prompt", script_result);
 
   ASSERT_TRUE(RunScript("hasSubscription()", &script_result));
   EXPECT_EQ("false - not subscribed", script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        LocalResetPushPermissionUnsubscribes) {
   std::string script_result;
 
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
 
   ASSERT_TRUE(RunScript("hasSubscription()", &script_result));
   EXPECT_EQ("true - subscribed", script_result);
 
   ASSERT_TRUE(RunScript("permissionState()", &script_result));
   EXPECT_EQ("permission status - granted", script_result);
 
   scoped_refptr<content::MessageLoopRunner> message_loop_runner =
       new content::MessageLoopRunner;
   push_service()->SetContentSettingChangedCallbackForTesting(
@@ skipping 15 matching lines @@
   EXPECT_EQ("permission status - prompt", script_result);
 
   ASSERT_TRUE(RunScript("hasSubscription()", &script_result));
   EXPECT_EQ("false - not subscribed", script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        DenyPushPermissionUnsubscribes) {
   std::string script_result;
 
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
 
   ASSERT_TRUE(RunScript("hasSubscription()", &script_result));
   EXPECT_EQ("true - subscribed", script_result);
 
   ASSERT_TRUE(RunScript("permissionState()", &script_result));
   EXPECT_EQ("permission status - granted", script_result);
 
   scoped_refptr<content::MessageLoopRunner> message_loop_runner =
       new content::MessageLoopRunner;
   push_service()->SetContentSettingChangedCallbackForTesting(
@@ skipping 11 matching lines @@
   EXPECT_EQ("permission status - denied", script_result);
 
   ASSERT_TRUE(RunScript("hasSubscription()", &script_result));
   EXPECT_EQ("false - not subscribed", script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        GlobalResetNotificationsPermissionUnsubscribes) {
   std::string script_result;
 
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
 
   ASSERT_TRUE(RunScript("hasSubscription()", &script_result));
   EXPECT_EQ("true - subscribed", script_result);
 
   ASSERT_TRUE(RunScript("permissionState()", &script_result));
   EXPECT_EQ("permission status - granted", script_result);
 
   scoped_refptr<content::MessageLoopRunner> message_loop_runner =
       new content::MessageLoopRunner;
   push_service()->SetContentSettingChangedCallbackForTesting(
       message_loop_runner->QuitClosure());
 
   HostContentSettingsMapFactory::GetForProfile(GetBrowser()->profile())
       ->ClearSettingsForOneType(CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
 
   message_loop_runner->Run();
 
   ASSERT_TRUE(RunScript("permissionState()", &script_result));
   EXPECT_EQ("permission status - prompt", script_result);
 
   ASSERT_TRUE(RunScript("hasSubscription()", &script_result));
   EXPECT_EQ("false - not subscribed", script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        LocalResetNotificationsPermissionUnsubscribes) {
   std::string script_result;
 
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
 
   ASSERT_TRUE(RunScript("hasSubscription()", &script_result));
   EXPECT_EQ("true - subscribed", script_result);
 
   ASSERT_TRUE(RunScript("permissionState()", &script_result));
   EXPECT_EQ("permission status - granted", script_result);
 
   scoped_refptr<content::MessageLoopRunner> message_loop_runner =
       new content::MessageLoopRunner;
   push_service()->SetContentSettingChangedCallbackForTesting(
@@ skipping 11 matching lines @@
   EXPECT_EQ("permission status - prompt", script_result);
 
   ASSERT_TRUE(RunScript("hasSubscription()", &script_result));
   EXPECT_EQ("false - not subscribed", script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        DenyNotificationsPermissionUnsubscribes) {
   std::string script_result;
 
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
 
   ASSERT_TRUE(RunScript("hasSubscription()", &script_result));
   EXPECT_EQ("true - subscribed", script_result);
 
   ASSERT_TRUE(RunScript("permissionState()", &script_result));
   EXPECT_EQ("permission status - granted", script_result);
 
   scoped_refptr<content::MessageLoopRunner> message_loop_runner =
       new content::MessageLoopRunner;
   push_service()->SetContentSettingChangedCallbackForTesting(
@@ skipping 11 matching lines @@
   EXPECT_EQ("permission status - denied", script_result);
 
   ASSERT_TRUE(RunScript("hasSubscription()", &script_result));
   EXPECT_EQ("false - not subscribed", script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        GrantAlreadyGrantedPermissionDoesNotUnsubscribe) {
   std::string script_result;
 
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
 
   ASSERT_TRUE(RunScript("hasSubscription()", &script_result));
   EXPECT_EQ("true - subscribed", script_result);
 
   ASSERT_TRUE(RunScript("permissionState()", &script_result));
   EXPECT_EQ("permission status - granted", script_result);
 
   scoped_refptr<content::MessageLoopRunner> message_loop_runner =
       new content::MessageLoopRunner;
   push_service()->SetContentSettingChangedCallbackForTesting(
@@ skipping 19 matching lines @@
 }
 
 // This test is testing some non-trivial content settings rules and make sure
 // that they are respected with regards to automatic unsubscription. In other
 // words, it checks that the push service does not end up unsubscribing origins
 // that have push permission with some non-common rules.
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        AutomaticUnsubscriptionFollowsContentSettingRules) {
   std::string script_result;
 
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
 
   ASSERT_TRUE(RunScript("hasSubscription()", &script_result));
   EXPECT_EQ("true - subscribed", script_result);
 
   ASSERT_TRUE(RunScript("permissionState()", &script_result));
   EXPECT_EQ("permission status - granted", script_result);
 
   scoped_refptr<content::MessageLoopRunner> message_loop_runner =
       new content::MessageLoopRunner;
   push_service()->SetContentSettingChangedCallbackForTesting(
@@ skipping 25 matching lines @@
   // The Push service should not unsubcribe |origin| because at no point it was
   // left without permission to use Push.
 
   ASSERT_TRUE(RunScript("permissionState()", &script_result));
   EXPECT_EQ("permission status - granted", script_result);
 
   ASSERT_TRUE(RunScript("hasSubscription()", &script_result));
   EXPECT_EQ("true - subscribed", script_result);
 }
 
-// Checks that automatically unsubscribing due to a revoked permission is
-// handled well if the sender ID needed to unsubscribe was already deleted.
+// Checks automatically unsubscribing due to a revoked permission after
+// previously clearing site data.
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        ResetPushPermissionAfterClearingSiteData) {
   std::string script_result;
 
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
 
   PushMessagingAppIdentifier app_identifier =
       GetAppIdentifierForServiceWorkerRegistration(0LL);
-  EXPECT_EQ(app_identifier.app_id(), gcm_service()->last_registered_app_id());
   PushMessagingAppIdentifier stored_app_identifier =
       PushMessagingAppIdentifier::FindByAppId(GetBrowser()->profile(),
                                               app_identifier.app_id());
   EXPECT_FALSE(stored_app_identifier.is_null());
 
   // Simulate a user clearing site data (including Service Workers, crucially).
   BrowsingDataRemover* remover =
       BrowsingDataRemoverFactory::GetForBrowserContext(GetBrowser()->profile());
   BrowsingDataRemoverCompletionObserver observer(remover);
   remover->Remove(BrowsingDataRemover::Unbounded(),
                   BrowsingDataRemover::REMOVE_SITE_DATA,
                   BrowsingDataHelper::UNPROTECTED_WEB);
   observer.BlockUntilCompletion();
 
   base::RunLoop run_loop;
   push_service()->SetContentSettingChangedCallbackForTesting(
       run_loop.QuitClosure());
 
   // This shouldn't (asynchronously) cause a DCHECK.
-  // TODO(johnme): Get this test running on Android, which has a different
-  // codepath due to sender_id being required for unsubscribing there.
+  // TODO(johnme): Get this test running on Android with legacy GCM
+  // registrations, which have a different codepath due to sender_id being
+  // required for unsubscribing there.
   HostContentSettingsMapFactory::GetForProfile(GetBrowser()->profile())
       ->ClearSettingsForOneType(CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
   HostContentSettingsMapFactory::GetForProfile(GetBrowser()->profile())
       ->ClearSettingsForOneType(CONTENT_SETTINGS_TYPE_PUSH_MESSAGING);
 
   run_loop.Run();
 
   // |app_identifier| should no longer be stored in prefs.
   PushMessagingAppIdentifier stored_app_identifier2 =
       PushMessagingAppIdentifier::FindByAppId(GetBrowser()->profile(),
                                               app_identifier.app_id());
   EXPECT_TRUE(stored_app_identifier2.is_null());
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, EncryptionKeyUniqueness) {
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */, false);
+  std::string token1;
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully(false /* use_key */, &token1));
 
   std::string first_public_key;
   ASSERT_TRUE(RunScript("GetP256dh()", &first_public_key));
   EXPECT_GE(first_public_key.size(), 32u);
 
   std::string script_result;
-  gcm_service()->AddExpectedUnregisterResponse(gcm::GCMClient::SUCCESS);
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
 
-  TryToSubscribeSuccessfully("1-1" /* expected_push_subscription_id */);
+  std::string token2;
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully(true /* use_key */, &token2));
+  EXPECT_NE(token1, token2);
 
   std::string second_public_key;
   ASSERT_TRUE(RunScript("GetP256dh()", &second_public_key));
   EXPECT_GE(second_public_key.size(), 32u);
 
   EXPECT_NE(first_public_key, second_public_key);
 }
 
 class PushMessagingIncognitoBrowserTest : public PushMessagingBrowserTest {
  public:
@@ skipping 31 matching lines @@
 #if BUILDFLAG(ENABLE_BACKGROUND) && !defined(OS_CHROMEOS)
 // Push background mode is disabled by default.
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        BackgroundModeDisabledByDefault) {
   // 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.
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
   ASSERT_FALSE(background_mode_manager->IsBackgroundModeActive());
 
   // After dropping the last subscription it is still inactive.
   std::string script_result;
-  gcm_service()->AddExpectedUnregisterResponse(gcm::GCMClient::SUCCESS);
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
   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.
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
+  ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
   ASSERT_TRUE(background_mode_manager->IsBackgroundModeActive());
 
   // Dropping the last subscription deactivates background mode.
   std::string script_result;
-  gcm_service()->AddExpectedUnregisterResponse(gcm::GCMClient::SUCCESS);
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
   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.
-  TryToSubscribeSuccessfully("1-0" /* expected_push_subscription_id */);
+  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;
-  gcm_service()->AddExpectedUnregisterResponse(gcm::GCMClient::SUCCESS);
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
   ASSERT_FALSE(background_mode_manager->IsBackgroundModeActive());
 }
 #endif  // BUILDFLAG(ENABLE_BACKGROUND) && !defined(OS_CHROMEOS)