[BackgroundSync] Add browser side support for SyncRegistration.done

content/browser/background_sync/background_sync_browsertest.cc

 // 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.
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/strings/string_split.h"
@@ skipping 145 matching lines @@
 
   bool PopConsole(const std::string& expected_msg);
   bool RegisterServiceWorker();
   bool RegisterOneShot(const std::string& tag);
   bool UnregisterOneShot(const std::string& tag);
   bool UnregisterOneShotTwice(const std::string& tag);
   bool GetRegistrationOneShot(const std::string& tag);
   bool GetRegistrationsOneShot(const std::vector<std::string>& expected_tags);
   bool CompleteDelayedOneShot();
   bool RejectDelayedOneShot();
+  bool NotifyWhenDoneOneShot(const std::string& tag);
+  bool NotifyWhenDoneImmediateOneShot(const std::string& expected_msg);
+  bool StoreRegistrationOneShot(const std::string& tag);
 
  private:
   scoped_ptr<net::SpawnedTestServer> https_server_;
   Shell* shell_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundSyncBrowserTest);
 };
 
 void BackgroundSyncBrowserTest::SetOnline(bool online) {
   if (online) {
@@ skipping 93 matching lines @@
   EXPECT_TRUE(RunScript("completeDelayedOneShot()", &script_result));
   return script_result == BuildExpectedResult("delay", "completing");
 }
 
 bool BackgroundSyncBrowserTest::RejectDelayedOneShot() {
   std::string script_result;
   EXPECT_TRUE(RunScript("rejectDelayedOneShot()", &script_result));
   return script_result == BuildExpectedResult("delay", "rejecting");
 }
 
+bool BackgroundSyncBrowserTest::NotifyWhenDoneOneShot(const std::string& tag) {
+  EXPECT_TRUE(content::ExecuteScript(
+      shell_->web_contents(), BuildScriptString("notifyWhenDoneOneShot", tag)));
+  return PopConsole(BuildExpectedResult(tag, "done"));
+}
+
+bool BackgroundSyncBrowserTest::NotifyWhenDoneImmediateOneShot(
+    const std::string& expected_msg) {
+  std::string script_result;
+  EXPECT_TRUE(RunScript("notifyWhenDoneImmediateOneShot()", &script_result));
+  return script_result == expected_msg;
+}
+
+bool BackgroundSyncBrowserTest::StoreRegistrationOneShot(
+    const std::string& tag) {
+  std::string script_result;
+  EXPECT_TRUE(
+      RunScript(BuildScriptString("storeRegistration", tag), &script_result));
+  return script_result == BuildExpectedResult(tag, "stored");
+}
+
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, OneShotFires) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   EXPECT_TRUE(RegisterOneShot("foo"));
   EXPECT_TRUE(PopConsole("foo fired"));
   EXPECT_FALSE(GetRegistrationOneShot("foo"));
 }
 
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, OneShotDelaysForNetwork) {
@@ skipping 125 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, UnregisterMidSync) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   EXPECT_TRUE(RegisterOneShot("unregister"));
   EXPECT_TRUE(PopConsole("ok - unregister completed"));
 }
 
+IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, CallDoneBeforeSyncSucceeds) {
+  EXPECT_TRUE(RegisterServiceWorker());
+  EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
+
+  SetOnline(false);
+  EXPECT_TRUE(RegisterOneShot("foo"));
+  EXPECT_TRUE(NotifyWhenDoneOneShot("foo"));
+
+  SetOnline(true);
+  // The ordering of PopConsole messages tells us that the event fired
+  // before done resolved.
+  EXPECT_TRUE(PopConsole("foo fired"));
+  EXPECT_TRUE(PopConsole("foo done result: true"));
+}
+
+IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, CallDoneBeforeSyncFails) {
+  EXPECT_TRUE(RegisterServiceWorker());
+  EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
+
+  SetOnline(true);
+  EXPECT_TRUE(RegisterOneShot("delay"));
+  EXPECT_FALSE(OneShotPending("delay"));
+  EXPECT_TRUE(NotifyWhenDoneOneShot("delay"));
+
+  EXPECT_TRUE(RejectDelayedOneShot());
+  // The ordering of PopConsole messages tells us that the event fired
+  // before done resolved.
+  EXPECT_TRUE(PopConsole("ok - delay rejected"));
+  EXPECT_TRUE(PopConsole("delay done result: false"));
+}
+
+IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, CallDoneAfterSyncSuceeds) {
+  EXPECT_TRUE(RegisterServiceWorker());
+  EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
+
+  SetOnline(false);
+  EXPECT_TRUE(RegisterOneShot("foo"));
+  EXPECT_TRUE(StoreRegistrationOneShot("foo"));
+
+  SetOnline(true);
+  EXPECT_TRUE(PopConsole("foo fired"));
+  EXPECT_FALSE(GetRegistrationOneShot("foo"));
+  EXPECT_TRUE(NotifyWhenDoneImmediateOneShot("ok - foo result: true"));
+}
+
+IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest,
+                       CallDoneAfterSyncUnregistered) {
+  EXPECT_TRUE(RegisterServiceWorker());
+  EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
+
+  SetOnline(false);
+  EXPECT_TRUE(RegisterOneShot("foo"));
+  EXPECT_TRUE(StoreRegistrationOneShot("foo"));
+  EXPECT_TRUE(UnregisterOneShot("foo"));
+  EXPECT_FALSE(GetRegistrationOneShot("foo"));
+  EXPECT_TRUE(NotifyWhenDoneImmediateOneShot("ok - foo result: false"));
+}
+
+IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, CallDoneAfterSyncFails) {
+  EXPECT_TRUE(RegisterServiceWorker());
+  EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
+
+  SetOnline(true);
+  EXPECT_TRUE(RegisterOneShot("delay"));
+  EXPECT_FALSE(OneShotPending("delay"));
+  EXPECT_TRUE(StoreRegistrationOneShot("delay"));
+
+  EXPECT_TRUE(RejectDelayedOneShot());
+  EXPECT_TRUE(PopConsole("ok - delay rejected"));
+  EXPECT_TRUE(NotifyWhenDoneImmediateOneShot("ok - delay result: false"));
+}
+
 }  // namespace
 
 }  // namespace content