Push API: Return cached registration if available.

chrome/browser/services/gcm/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 <map>
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 125 matching lines @@
             browser()->profile(), &FakeGCMProfileService::Build));
     gcm_service_->set_collect(true);
 
     loadTestPage();
 
     InProcessBrowserTest::SetUpOnMainThread();
   }
 
   void loadTestPage() {
     ui_test_utils::NavigateToURL(
-        browser(), https_server_->GetURL("files/push_messaging/test.html"));
+        browser(),
+        https_server_->GetURL("files/push_messaging/test.html"));
+  }
+
+  void LoadSubscope1TestPage() {

[Michael van Ouwerkerk, 2014/12/11 17:12:53]

These methods repeat a lot of boilerplate and do not get called all that often.
How about instead adding an overload for loadTestPage that accepts a url, and
making loadTestPage call its overload?

[johnme, 2014/12/11 18:32:33]

Done (fixed the capitalization while I was at it ;)

+    ui_test_utils::NavigateToURL(
+        browser(),
+        https_server_->GetURL("files/push_messaging/subscope1/test.html"));
+  }
+
+  void LoadSubscope2TestPage() {
+    ui_test_utils::NavigateToURL(
+        browser(),
+        https_server_->GetURL("files/push_messaging/subscope2/test.html"));
   }
 
   bool RunScript(const std::string& script, std::string* result) {
     return content::ExecuteScriptAndExtractString(
         browser()->tab_strip_model()->GetActiveWebContents()->GetMainFrame(),
         script,
         result);
   }
 
+  void TryToRegisterSuccessfully(
+      const std::string& expected_push_registration_id);
+
   net::SpawnedTestServer* https_server() const { return https_server_.get(); }
 
   FakeGCMProfileService* gcm_service() const { return gcm_service_; }
 
   PushMessagingServiceImpl* push_service() {
     return static_cast<PushMessagingServiceImpl*>(
         gcm_service_->push_messaging_service());
   }
 
  private:
   scoped_ptr<net::SpawnedTestServer> https_server_;
   FakeGCMProfileService* gcm_service_;
 
   DISALLOW_COPY_AND_ASSIGN(PushMessagingBrowserTest);
 };
 
-IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, RegisterSuccess) {
+void PushMessagingBrowserTest::TryToRegisterSuccessfully(
+    const std::string& expected_push_registration_id) {
   std::string script_result;
 
-  ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
-  ASSERT_EQ("ok - service worker registered", script_result);
+  EXPECT_TRUE(RunScript("registerServiceWorker()", &script_result));
+  EXPECT_EQ("ok - service worker registered", script_result);
 
   InfoBarResponder accepting_responder(browser(), true);
-  ASSERT_TRUE(RunScript("requestNotificationPermission()", &script_result));
-  ASSERT_EQ("permission status - granted", script_result);
+  EXPECT_TRUE(RunScript("requestNotificationPermission()", &script_result));
+  EXPECT_EQ("permission status - granted", script_result);
 
-  ASSERT_TRUE(RunScript("registerPush()", &script_result));
-  EXPECT_EQ(std::string(kPushMessagingEndpoint) + " - 1-0", script_result);
+  EXPECT_TRUE(RunScript("registerPush()", &script_result));
+  EXPECT_EQ(std::string(kPushMessagingEndpoint) + " - "
+            + expected_push_registration_id, script_result);
+}
 
-  PushMessagingApplicationId app_id(https_server()->GetURL(""), 0L);
+IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, RegisterSuccess) {
+  TryToRegisterSuccessfully("1-0" /* expected_push_registration_id */);
+
+  PushMessagingApplicationId app_id(https_server()->GetURL(""),
+                                    0LL /* service_worker_registration_id */);

[Michael van Ouwerkerk, 2014/12/11 17:12:53]

Is the rest of this file doing something significantly different by using only
one L ? Let's make it all consistent.

[johnme, 2014/12/11 18:32:33]

Done.

   EXPECT_EQ(app_id.ToString(), gcm_service()->last_registered_app_id());
   EXPECT_EQ("1234567890", gcm_service()->last_registered_sender_ids()[0]);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        RegisterFailureNoPushPermission) {
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
@@ skipping 30 matching lines @@
   ASSERT_EQ("permission status - granted", script_result);
 
   ASSERT_TRUE(RunScript("removeManifest()", &script_result));
   ASSERT_EQ("manifest removed", script_result);
 
   ASSERT_TRUE(RunScript("registerPush()", &script_result));
   EXPECT_EQ("AbortError - Registration failed - no sender id provided",
             script_result);
 }
 
+IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, RegisterPersisted) {
+  std::string script_result;
+
+  // An app ID for each Service Worker registration ID we'll use.
+  PushMessagingApplicationId app_id_sw0(https_server()->GetURL(""), 0LL);
+  PushMessagingApplicationId app_id_sw1(https_server()->GetURL(""), 1LL);
+  PushMessagingApplicationId app_id_sw2(https_server()->GetURL(""), 2LL);
+
+  // First, test that Service Worker registration IDs are assigned in order of
+  // registering the Service Workers, and the (fake) push registration ids are
+  // assigned in order of push registration (even when these orders are
+  // different).
+
+  TryToRegisterSuccessfully("1-0" /* expected_push_registration_id */);
+  EXPECT_EQ(app_id_sw0.ToString(), gcm_service()->last_registered_app_id());
+
+  LoadSubscope1TestPage();
+  ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
+  ASSERT_EQ("ok - service worker registered", script_result);
+
+  LoadSubscope2TestPage();
+  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.
+  LoadSubscope2TestPage();
+  TryToRegisterSuccessfully("1-1" /* expected_push_registration_id */);
+  EXPECT_EQ(app_id_sw2.ToString(), gcm_service()->last_registered_app_id());
+
+  LoadSubscope1TestPage();
+  TryToRegisterSuccessfully("1-2" /* expected_push_registration_id */);
+  EXPECT_EQ(app_id_sw1.ToString(), gcm_service()->last_registered_app_id());
+
+  // Now test that the Service Worker registration IDs and push registration 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.
+
+  LoadSubscope1TestPage();
+  TryToRegisterSuccessfully("1-2" /* expected_push_registration_id */);
+  EXPECT_EQ(app_id_sw1.ToString(), gcm_service()->last_registered_app_id());
+
+  LoadSubscope2TestPage();
+  TryToRegisterSuccessfully("1-1" /* expected_push_registration_id */);
+  EXPECT_EQ(app_id_sw1.ToString(), gcm_service()->last_registered_app_id());
+
+  loadTestPage();
+  TryToRegisterSuccessfully("1-0" /* expected_push_registration_id */);
+  EXPECT_EQ(app_id_sw1.ToString(), gcm_service()->last_registered_app_id());
+}
+
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, PushEventSuccess) {
   std::string script_result;
 
-  ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
-  ASSERT_EQ("ok - service worker registered", script_result);
-
-  InfoBarResponder accepting_responder(browser(), true);
-  ASSERT_TRUE(RunScript("requestNotificationPermission();", &script_result));
-  ASSERT_EQ("permission status - granted", script_result);
-
-  ASSERT_TRUE(RunScript("registerPush()", &script_result));
-  EXPECT_EQ(std::string(kPushMessagingEndpoint) + " - 1-0", script_result);
+  TryToRegisterSuccessfully("1-0" /* expected_push_registration_id */);
 
   PushMessagingApplicationId app_id(https_server()->GetURL(""), 0L);
   EXPECT_EQ(app_id.ToString(), gcm_service()->last_registered_app_id());
   EXPECT_EQ("1234567890", 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);
 
   GCMClient::IncomingMessage message;
   GCMClient::MessageData messageData;
   messageData.insert(std::pair<std::string, std::string>("data", "testdata"));
   message.data = messageData;
   push_service()->OnMessage(app_id.ToString(), message);
   ASSERT_TRUE(RunScript("pushData.get()", &script_result));
   EXPECT_EQ("testdata", script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, PushEventNoServiceWorker) {
   std::string script_result;
 
-  ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
-  ASSERT_EQ("ok - service worker registered", script_result);
-
-  InfoBarResponder accepting_responder(browser(), true);
-  ASSERT_TRUE(RunScript("requestNotificationPermission();", &script_result));
-  ASSERT_EQ("permission status - granted", script_result);
-
-  ASSERT_TRUE(RunScript("registerPush()", &script_result));
-  EXPECT_EQ(std::string(kPushMessagingEndpoint) + " - 1-0", script_result);
+  TryToRegisterSuccessfully("1-0" /* expected_push_registration_id */);
 
   PushMessagingApplicationId app_id(https_server()->GetURL(""), 0L);
   EXPECT_EQ(app_id.ToString(), gcm_service()->last_registered_app_id());
   EXPECT_EQ("1234567890", 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.
 
@@ skipping 20 matching lines @@
   EXPECT_EQ(app_id.ToString(), callback.app_id());
 
   // No push data should have been received.
   ASSERT_TRUE(RunScript("pushData.getImmediately()", &script_result));
   EXPECT_EQ("null", script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, PushEventNoPermission) {
   std::string script_result;
 
-  ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
-  ASSERT_EQ("ok - service worker registered", script_result);
-
-  InfoBarResponder accepting_responder(browser(), true);
-  ASSERT_TRUE(RunScript("requestNotificationPermission();", &script_result));
-  ASSERT_EQ("permission status - granted", script_result);
-
-  ASSERT_TRUE(RunScript("registerPush()", &script_result));
-  EXPECT_EQ(std::string(kPushMessagingEndpoint) + " - 1-0", script_result);
+  TryToRegisterSuccessfully("1-0" /* expected_push_registration_id */);
 
   PushMessagingApplicationId app_id(https_server()->GetURL(""), 0L);
   EXPECT_EQ(app_id.ToString(), gcm_service()->last_registered_app_id());
   EXPECT_EQ("1234567890", 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.
 
@@ skipping 63 matching lines @@
 
   ASSERT_TRUE(RunScript("registerPush()", &script_result));
   EXPECT_EQ("AbortError - Registration failed - permission denied",
             script_result);
 
   ASSERT_TRUE(RunScript("hasPermission()", &script_result));
   EXPECT_EQ("permission status - denied", script_result);
 }
 
 }  // namespace gcm