Use mojo to connect to BackgroundSyncManager object

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 144 matching lines @@
   // run on the IO thread.
   void SetOnline(bool online);
   void SetOnlineOnIOThread(
       const scoped_refptr<BackgroundSyncContext>& sync_context,
       bool online);
 
   // Returns true if the one-shot sync with tag is currently pending. Fails
   // (assertion failure) if the tag isn't registered.
   bool OneShotPending(const std::string& tag);
 
+  std::string PopConsoleString();
   bool PopConsole(const std::string& expected_msg);
   bool RegisterServiceWorker();
   bool RegisterOneShot(const std::string& tag);
+  bool RegisterOneShotFromServiceWorker(const std::string& tag);
   bool UnregisterOneShot(const std::string& tag);
   bool UnregisterOneShotTwice(const std::string& tag);
   bool GetRegistrationOneShot(const std::string& tag);
+  bool GetRegistrationOneShotFromServiceWorker(const std::string& tag);
+  bool MatchRegistrations(const std::string& script_result,
+                          const std::vector<std::string>& expected_tags);
   bool GetRegistrationsOneShot(const std::vector<std::string>& expected_tags);
+  bool GetRegistrationsOneShotFromServiceWorker(
+      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;
 
@@ skipping 44 matching lines @@
       BrowserThread::IO, FROM_HERE,
       base::Bind(&OneShotPendingOnIOThread, make_scoped_refptr(sync_context),
                  make_scoped_refptr(service_worker_context), tag,
                  https_server_->GetURL(kDefaultTestURL), callback));
 
   run_loop.Run();
 
   return is_pending;
 }
 
-bool BackgroundSyncBrowserTest::PopConsole(const std::string& expected_msg) {
+std::string BackgroundSyncBrowserTest::PopConsoleString() {
   std::string script_result;
   EXPECT_TRUE(RunScript("resultQueue.pop()", &script_result));
+  return script_result;
+}
+
+bool BackgroundSyncBrowserTest::PopConsole(const std::string& expected_msg) {
+  std::string script_result = PopConsoleString();
   return script_result == expected_msg;
 }
 
 bool BackgroundSyncBrowserTest::RegisterServiceWorker() {
   std::string script_result;
   EXPECT_TRUE(RunScript("registerServiceWorker()", &script_result));
   return script_result == BuildExpectedResult("service worker", "registered");
 }
 
 bool BackgroundSyncBrowserTest::RegisterOneShot(const std::string& tag) {
   std::string script_result;
   EXPECT_TRUE(
       RunScript(BuildScriptString("registerOneShot", tag), &script_result));
   return script_result == BuildExpectedResult(tag, "registered");
 }
 
+bool BackgroundSyncBrowserTest::RegisterOneShotFromServiceWorker(
+    const std::string& tag) {
+  std::string script_result;
+  EXPECT_TRUE(
+      RunScript(BuildScriptString("registerOneShotFromServiceWorker", tag),
+                &script_result));
+  return script_result == BuildExpectedResult(tag, "register sent to SW");
+}
+
 bool BackgroundSyncBrowserTest::UnregisterOneShot(const std::string& tag) {
   std::string script_result;
   EXPECT_TRUE(
       RunScript(BuildScriptString("unregisterOneShot", tag), &script_result));
   return script_result == BuildExpectedResult(tag, "unregistered");
 }
 
 bool BackgroundSyncBrowserTest::UnregisterOneShotTwice(const std::string& tag) {
   std::string script_result;
   EXPECT_TRUE(RunScript(BuildScriptString("unregisterOneShotTwice", tag),
                         &script_result));
   return script_result ==
          BuildExpectedResult(tag, "failed to unregister twice");
 }
 
 bool BackgroundSyncBrowserTest::GetRegistrationOneShot(const std::string& tag) {
   std::string script_result;
   EXPECT_TRUE(RunScript(BuildScriptString("getRegistrationOneShot", tag),
                         &script_result));
   return script_result == BuildExpectedResult(tag, "found");
 }
 
+bool BackgroundSyncBrowserTest::GetRegistrationOneShotFromServiceWorker(
+    const std::string& tag) {
+  std::string script_result;
+  EXPECT_TRUE(RunScript(
+      BuildScriptString("getRegistrationOneShotFromServiceWorker", tag),
+      &script_result));
+  EXPECT_TRUE(script_result == "ok - getRegistration sent to SW");
+
+  return PopConsole(BuildExpectedResult(tag, "found"));
+}
+
+bool BackgroundSyncBrowserTest::MatchRegistrations(
+    const std::string& script_result,
+    const std::vector<std::string>& expected_tags) {
+  EXPECT_TRUE(base::StartsWith(script_result, kSuccessfulOperationPrefix,
+                               base::CompareCase::INSENSITIVE_ASCII));
+  std::string tag_string =
+      script_result.substr(strlen(kSuccessfulOperationPrefix));
+  std::vector<std::string> result_tags = base::SplitString(
+      tag_string, ",", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
+
+  return std::set<std::string>(expected_tags.begin(), expected_tags.end()) ==
+         std::set<std::string>(result_tags.begin(), result_tags.end());
+}
+
 bool BackgroundSyncBrowserTest::GetRegistrationsOneShot(
     const std::vector<std::string>& expected_tags) {
   std::string script_result;
   EXPECT_TRUE(RunScript("getRegistrationsOneShot()", &script_result));
 
-  EXPECT_TRUE(base::StartsWith(script_result, kSuccessfulOperationPrefix,
-                               base::CompareCase::INSENSITIVE_ASCII));
-  script_result = script_result.substr(strlen(kSuccessfulOperationPrefix));
-  std::vector<std::string> result_tags = base::SplitString(
-      script_result, ",", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
+  return MatchRegistrations(script_result, expected_tags);
+}
 
-  return std::set<std::string>(expected_tags.begin(), expected_tags.end()) ==
-         std::set<std::string>(result_tags.begin(), result_tags.end());
+bool BackgroundSyncBrowserTest::GetRegistrationsOneShotFromServiceWorker(
+    const std::vector<std::string>& expected_tags) {
+  std::string script_result;
+  EXPECT_TRUE(
+      RunScript("getRegistrationsOneShotFromServiceWorker()", &script_result));
+  EXPECT_TRUE(script_result == "ok - getRegistrations sent to SW");
+
+  return MatchRegistrations(PopConsoleString(), expected_tags);
 }
 
 bool BackgroundSyncBrowserTest::CompleteDelayedOneShot() {
   std::string script_result;
   EXPECT_TRUE(RunScript("completeDelayedOneShot()", &script_result));
   return script_result == BuildExpectedResult("delay", "completing");
 }
 
 bool BackgroundSyncBrowserTest::RejectDelayedOneShot() {
   std::string script_result;
@@ skipping 24 matching lines @@
 
 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"));
 }
 
+// Verify that Register works in a service worker
+IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest,
+                       OneShotFromServiceWorkerFires) {
+  EXPECT_TRUE(RegisterServiceWorker());
+  EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
+
+  EXPECT_TRUE(RegisterOneShotFromServiceWorker("foo_sw"));
+  EXPECT_TRUE(PopConsole("ok - foo_sw registered in SW"));
+  EXPECT_TRUE(PopConsole("foo_sw fired"));
+  EXPECT_FALSE(GetRegistrationOneShot("foo_sw"));
+}
+
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, OneShotDelaysForNetwork) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   // Prevent firing by going offline.
   SetOnline(false);
   EXPECT_TRUE(RegisterOneShot("foo"));
   EXPECT_TRUE(GetRegistrationOneShot("foo"));
   EXPECT_TRUE(OneShotPending("foo"));
 
@@ skipping 84 matching lines @@
   SetOnline(false);
   registered_tags.push_back("foo");
   registered_tags.push_back("bar");
 
   for (const std::string& tag : registered_tags)
     EXPECT_TRUE(RegisterOneShot(tag));
 
   EXPECT_TRUE(GetRegistrationsOneShot(registered_tags));
 }
 
+// Verify that GetRegistrations works in a service worker
+IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest,
+                       GetRegistrationsFromServiceWorker) {
+  EXPECT_TRUE(RegisterServiceWorker());
+  EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
+
+  std::vector<std::string> registered_tags;
+  EXPECT_TRUE(GetRegistrationsOneShot(registered_tags));
+
+  SetOnline(false);
+  registered_tags.push_back("foo_sw");
+  registered_tags.push_back("bar_sw");
+
+  for (const std::string& tag : registered_tags) {
+    EXPECT_TRUE(RegisterOneShotFromServiceWorker(tag));
+    EXPECT_TRUE(PopConsole(BuildExpectedResult(tag, "registered in SW")));
+  }
+
+  EXPECT_TRUE(GetRegistrationsOneShotFromServiceWorker(registered_tags));
+}
+
+// Verify that GetRegistration works in a service worker
+IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest,
+                       GetRegistrationFromServiceWorker) {
+  EXPECT_TRUE(RegisterServiceWorker());
+  EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
+
+  std::vector<std::string> registered_tags;
+  EXPECT_TRUE(GetRegistrationsOneShot(registered_tags));
+
+  SetOnline(false);
+
+  EXPECT_TRUE(RegisterOneShotFromServiceWorker("foo_sw"));
+  EXPECT_TRUE(PopConsole("ok - foo_sw registered in SW"));
+  EXPECT_TRUE(GetRegistrationOneShotFromServiceWorker("foo_sw"));
+}
+
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, Unregister) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   SetOnline(false);
   EXPECT_TRUE(RegisterOneShot("foo"));
   EXPECT_TRUE(UnregisterOneShot("foo"));
   EXPECT_FALSE(GetRegistrationOneShot("foo"));
 }
 
@@ skipping 81 matching lines @@
   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 content