[Background Sync Cleanup] Remove mention of oneshot

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 <stdint.h>
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 39 matching lines @@
                               const std::string& argument) {
   return base::StringPrintf("%s('%s');", function.c_str(), argument.c_str());
 }
 
 std::string BuildExpectedResult(const std::string& tag,
                                 const std::string& action) {
   return base::StringPrintf("%s%s %s", kSuccessfulOperationPrefix, tag.c_str(),
                             action.c_str());
 }
 
-void OneShotPendingCallback(
+void RegistrationPendingCallback(
     const base::Closure& quit,
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     bool* result_out,
     bool result) {
   *result_out = result;
   task_runner->PostTask(FROM_HERE, quit);
 }
 
-void OneShotPendingDidGetSyncRegistration(
+void RegistrationPendingDidGetSyncRegistration(
     const base::Callback<void(bool)>& callback,
     BackgroundSyncStatus error_type,
     scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle) {
   ASSERT_EQ(BACKGROUND_SYNC_STATUS_OK, error_type);
   callback.Run(registration_handle->sync_state() ==
                BackgroundSyncState::PENDING);
 }
 
-void OneShotPendingDidGetSWRegistration(
+void RegistrationPendingDidGetSWRegistration(
     const scoped_refptr<BackgroundSyncContext> sync_context,
     const std::string& tag,
     const base::Callback<void(bool)>& callback,
     ServiceWorkerStatusCode status,
     const scoped_refptr<ServiceWorkerRegistration>& registration) {
   ASSERT_EQ(SERVICE_WORKER_OK, status);
   int64_t service_worker_id = registration->id();
   BackgroundSyncManager* sync_manager = sync_context->background_sync_manager();
   sync_manager->GetRegistration(
       service_worker_id, tag,
-      base::Bind(&OneShotPendingDidGetSyncRegistration, callback));
+      base::Bind(&RegistrationPendingDidGetSyncRegistration, callback));
 }
 
-void OneShotPendingOnIOThread(
+void RegistrationPendingOnIOThread(
     const scoped_refptr<BackgroundSyncContext> sync_context,
     const scoped_refptr<ServiceWorkerContextWrapper> sw_context,
     const std::string& tag,
     const GURL& url,
     const base::Callback<void(bool)>& callback) {
   sw_context->FindReadyRegistrationForDocument(
-      url, base::Bind(&OneShotPendingDidGetSWRegistration, sync_context, tag,
-                      callback));
+      url, base::Bind(&RegistrationPendingDidGetSWRegistration, sync_context,
+                      tag, callback));
 }
 
 void SetMaxSyncAttemptsOnIOThread(
     const scoped_refptr<BackgroundSyncContext>& sync_context,
     int max_sync_attempts) {
   BackgroundSyncManager* background_sync_manager =
       sync_context->background_sync_manager();
   background_sync_manager->SetMaxSyncAttemptsForTesting(max_sync_attempts);
 }
 
@@ skipping 51 matching lines @@
 
   bool LoadTestPage(const std::string& path) {
     return NavigateToURL(shell_, https_server_->GetURL(path));
   }
 
   bool RunScript(const std::string& script, std::string* result) {
     return content::ExecuteScriptAndExtractString(web_contents(), script,
                                                   result);
   }
 
-  // Returns true if the one-shot sync with tag is currently pending. Fails
+  // Returns true if the registration with tag |tag| is currently pending. Fails
   // (assertion failure) if the tag isn't registered.
-  bool OneShotPending(const std::string& tag);
+  bool RegistrationPending(const std::string& tag);
 
   // Sets the BackgroundSyncManager's max sync attempts per registration.
   void SetMaxSyncAttempts(int max_sync_attempts);
 
   void ClearStoragePartitionData();
 
   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 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 Register(const std::string& tag);
+  bool RegisterFromServiceWorker(const std::string& tag);
+  bool HasTag(const std::string& tag);
+  bool HasTagFromServiceWorker(const std::string& tag);
+  bool MatchTags(const std::string& script_result,
+                 const std::vector<std::string>& expected_tags);
+  bool GetTags(const std::vector<std::string>& expected_tags);
+  bool GetTagsFromServiceWorker(const std::vector<std::string>& expected_tags);
+  bool CompleteDelayedSyncEvent();
+  bool RejectDelayedSyncEvent();
 
   net::EmbeddedTestServer* https_server() { return https_server_.get(); }
 
  private:
   scoped_ptr<net::EmbeddedTestServer> https_server_;
   Shell* shell_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundSyncBrowserTest);
 };
 
-bool BackgroundSyncBrowserTest::OneShotPending(const std::string& tag) {
+bool BackgroundSyncBrowserTest::RegistrationPending(const std::string& tag) {
   bool is_pending;
   base::RunLoop run_loop;
 
   StoragePartition* storage = GetStorage();
   BackgroundSyncContext* sync_context = storage->GetBackgroundSyncContext();
   ServiceWorkerContextWrapper* service_worker_context =
       static_cast<ServiceWorkerContextWrapper*>(
           storage->GetServiceWorkerContext());
 
   base::Callback<void(bool)> callback =
-      base::Bind(&OneShotPendingCallback, run_loop.QuitClosure(),
+      base::Bind(&RegistrationPendingCallback, run_loop.QuitClosure(),
                  base::ThreadTaskRunnerHandle::Get(), &is_pending);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&OneShotPendingOnIOThread, make_scoped_refptr(sync_context),
+      base::Bind(&RegistrationPendingOnIOThread,
+                 make_scoped_refptr(sync_context),
                  make_scoped_refptr(service_worker_context), tag,
                  https_server_->GetURL(kDefaultTestURL), callback));
 
   run_loop.Run();
 
   return is_pending;
 }
 
 void BackgroundSyncBrowserTest::SetMaxSyncAttempts(int max_sync_attempts) {
   base::RunLoop run_loop;
@@ skipping 42 matching lines @@
   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) {
+bool BackgroundSyncBrowserTest::Register(const std::string& tag) {
   std::string script_result;
-  EXPECT_TRUE(
-      RunScript(BuildScriptString("registerOneShot", tag), &script_result));
+  EXPECT_TRUE(RunScript(BuildScriptString("register", tag), &script_result));
   return script_result == BuildExpectedResult(tag, "registered");
 }
 
-bool BackgroundSyncBrowserTest::RegisterOneShotFromServiceWorker(
+bool BackgroundSyncBrowserTest::RegisterFromServiceWorker(
     const std::string& tag) {
   std::string script_result;
-  EXPECT_TRUE(
-      RunScript(BuildScriptString("registerOneShotFromServiceWorker", tag),
-                &script_result));
+  EXPECT_TRUE(RunScript(BuildScriptString("registerFromServiceWorker", tag),
+                        &script_result));
   return script_result == BuildExpectedResult(tag, "register sent to SW");
 }
 
-bool BackgroundSyncBrowserTest::GetRegistrationOneShot(const std::string& tag) {
+bool BackgroundSyncBrowserTest::HasTag(const std::string& tag) {
   std::string script_result;
-  EXPECT_TRUE(RunScript(BuildScriptString("getRegistrationOneShot", tag),
-                        &script_result));
+  EXPECT_TRUE(RunScript(BuildScriptString("hasTag", tag), &script_result));
   return script_result == BuildExpectedResult(tag, "found");
 }
 
-bool BackgroundSyncBrowserTest::GetRegistrationOneShotFromServiceWorker(
+bool BackgroundSyncBrowserTest::HasTagFromServiceWorker(
     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");
+  EXPECT_TRUE(RunScript(BuildScriptString("hasTagFromServiceWorker", tag),
+                        &script_result));
+  EXPECT_TRUE(script_result == "ok - hasTag sent to SW");
 
   return PopConsole(BuildExpectedResult(tag, "found"));
 }
 
-bool BackgroundSyncBrowserTest::MatchRegistrations(
+bool BackgroundSyncBrowserTest::MatchTags(
     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(
+bool BackgroundSyncBrowserTest::GetTags(
     const std::vector<std::string>& expected_tags) {
   std::string script_result;
-  EXPECT_TRUE(RunScript("getRegistrationsOneShot()", &script_result));
+  EXPECT_TRUE(RunScript("getTags()", &script_result));
 
-  return MatchRegistrations(script_result, expected_tags);
+  return MatchTags(script_result, expected_tags);
 }
 
-bool BackgroundSyncBrowserTest::GetRegistrationsOneShotFromServiceWorker(
+bool BackgroundSyncBrowserTest::GetTagsFromServiceWorker(
     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");
+  EXPECT_TRUE(RunScript("getTagsFromServiceWorker()", &script_result));
+  EXPECT_TRUE(script_result == "ok - getTags sent to SW");
 
-  return MatchRegistrations(PopConsoleString(), expected_tags);
+  return MatchTags(PopConsoleString(), expected_tags);
 }
 
-bool BackgroundSyncBrowserTest::CompleteDelayedOneShot() {
+bool BackgroundSyncBrowserTest::CompleteDelayedSyncEvent() {
   std::string script_result;
-  EXPECT_TRUE(RunScript("completeDelayedOneShot()", &script_result));
+  EXPECT_TRUE(RunScript("completeDelayedSyncEvent()", &script_result));
   return script_result == BuildExpectedResult("delay", "completing");
 }
 
-bool BackgroundSyncBrowserTest::RejectDelayedOneShot() {
+bool BackgroundSyncBrowserTest::RejectDelayedSyncEvent() {
   std::string script_result;
-  EXPECT_TRUE(RunScript("rejectDelayedOneShot()", &script_result));
+  EXPECT_TRUE(RunScript("rejectDelayedSyncEvent()", &script_result));
   return script_result == BuildExpectedResult("delay", "rejecting");
 }
 
-IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, OneShotFiresControlled) {
+IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest,
+                       RegisterFromControlledDocument) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
-  EXPECT_TRUE(RegisterOneShot("foo"));
+  EXPECT_TRUE(Register("foo"));
   EXPECT_TRUE(PopConsole("foo fired"));
-  EXPECT_FALSE(GetRegistrationOneShot("foo"));
+  EXPECT_FALSE(HasTag("foo"));
 }
 
-IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, OneShotFiresUncontrolled) {
+IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest,
+                       RegisterFromUncontrolledDocument) {
   EXPECT_TRUE(RegisterServiceWorker());
 
-  EXPECT_TRUE(RegisterOneShot("foo"));
+  EXPECT_TRUE(Register("foo"));
   EXPECT_TRUE(PopConsole("foo fired"));
-  EXPECT_FALSE(GetRegistrationOneShot("foo"));
+  EXPECT_FALSE(HasTag("foo"));
 }
 
 // Verify that Register works in a service worker
-IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest,
-                       OneShotFromServiceWorkerFires) {
+IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, RegisterFromServiceWorker) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
-  EXPECT_TRUE(RegisterOneShotFromServiceWorker("foo_sw"));
+  EXPECT_TRUE(RegisterFromServiceWorker("foo_sw"));
   EXPECT_TRUE(PopConsole("ok - foo_sw registered in SW"));
   EXPECT_TRUE(PopConsole("foo_sw fired"));
-  EXPECT_FALSE(GetRegistrationOneShot("foo_sw"));
+  EXPECT_FALSE(HasTag("foo_sw"));
 }
 
-IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, OneShotDelaysForNetwork) {
+IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest,
+                       RegistrationDelaysForNetwork) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   // Prevent firing by going offline.
   background_sync_test_util::SetOnline(web_contents(), false);
-  EXPECT_TRUE(RegisterOneShot("foo"));
-  EXPECT_TRUE(GetRegistrationOneShot("foo"));
-  EXPECT_TRUE(OneShotPending("foo"));
+  EXPECT_TRUE(Register("foo"));
+  EXPECT_TRUE(HasTag("foo"));
+  EXPECT_TRUE(RegistrationPending("foo"));
 
   // Resume firing by going online.
   background_sync_test_util::SetOnline(web_contents(), true);
   EXPECT_TRUE(PopConsole("foo fired"));
-  EXPECT_FALSE(GetRegistrationOneShot("foo"));
+  EXPECT_FALSE(HasTag("foo"));
 }
 
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, WaitUntil) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   background_sync_test_util::SetOnline(web_contents(), true);
-  EXPECT_TRUE(RegisterOneShot("delay"));
+  EXPECT_TRUE(Register("delay"));
 
   // Verify that it is firing.
-  EXPECT_TRUE(GetRegistrationOneShot("delay"));
-  EXPECT_FALSE(OneShotPending("delay"));
+  EXPECT_TRUE(HasTag("delay"));
+  EXPECT_FALSE(RegistrationPending("delay"));
 
   // Complete the task.
-  EXPECT_TRUE(CompleteDelayedOneShot());
+  EXPECT_TRUE(CompleteDelayedSyncEvent());
   EXPECT_TRUE(PopConsole("ok - delay completed"));
 
   // Verify that it finished firing.
-  EXPECT_FALSE(GetRegistrationOneShot("delay"));
+  EXPECT_FALSE(HasTag("delay"));
 }
 
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, WaitUntilReject) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   background_sync_test_util::SetOnline(web_contents(), true);
-  EXPECT_TRUE(RegisterOneShot("delay"));
+  EXPECT_TRUE(Register("delay"));
 
   // Verify that it is firing.
-  EXPECT_TRUE(GetRegistrationOneShot("delay"));
-  EXPECT_FALSE(OneShotPending("delay"));
+  EXPECT_TRUE(HasTag("delay"));
+  EXPECT_FALSE(RegistrationPending("delay"));
 
   // Complete the task.
-  EXPECT_TRUE(RejectDelayedOneShot());
+  EXPECT_TRUE(RejectDelayedSyncEvent());
   EXPECT_TRUE(PopConsole("ok - delay rejected"));
-  EXPECT_FALSE(GetRegistrationOneShot("delay"));
+  EXPECT_FALSE(HasTag("delay"));
 }
 
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, Incognito) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   background_sync_test_util::SetOnline(web_contents(), false);
-  EXPECT_TRUE(RegisterOneShot("normal"));
-  EXPECT_TRUE(OneShotPending("normal"));
+  EXPECT_TRUE(Register("normal"));
+  EXPECT_TRUE(RegistrationPending("normal"));
 
   // Go incognito and verify that incognito doesn't see the registration.
   SetIncognitoMode(true);
 
   // Tell the new network observer that we're offline (it initializes from
   // NetworkChangeNotifier::GetCurrentConnectionType() which is not mocked out
   // in this test).
   background_sync_test_util::SetOnline(web_contents(), false);
 
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));
   EXPECT_TRUE(RegisterServiceWorker());
 
-  EXPECT_FALSE(GetRegistrationOneShot("normal"));
+  EXPECT_FALSE(HasTag("normal"));
 
-  EXPECT_TRUE(RegisterOneShot("incognito"));
-  EXPECT_TRUE(OneShotPending("incognito"));
+  EXPECT_TRUE(Register("incognito"));
+  EXPECT_TRUE(RegistrationPending("incognito"));
 
   // Switch back and make sure the registration is still there.
   SetIncognitoMode(false);
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Should be controlled.
 
-  EXPECT_TRUE(GetRegistrationOneShot("normal"));
-  EXPECT_FALSE(GetRegistrationOneShot("incognito"));
+  EXPECT_TRUE(HasTag("normal"));
+  EXPECT_FALSE(HasTag("incognito"));
 }
 
-IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, GetRegistrations) {
+IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, GetTags) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   std::vector<std::string> registered_tags;
-  EXPECT_TRUE(GetRegistrationsOneShot(registered_tags));
+  EXPECT_TRUE(GetTags(registered_tags));
 
   background_sync_test_util::SetOnline(web_contents(), false);
   registered_tags.push_back("foo");
   registered_tags.push_back("bar");
 
   for (const std::string& tag : registered_tags)
-    EXPECT_TRUE(RegisterOneShot(tag));
+    EXPECT_TRUE(Register(tag));
 
-  EXPECT_TRUE(GetRegistrationsOneShot(registered_tags));
+  EXPECT_TRUE(GetTags(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));
+  EXPECT_TRUE(GetTags(registered_tags));
 
   background_sync_test_util::SetOnline(web_contents(), 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(RegisterFromServiceWorker(tag));
     EXPECT_TRUE(PopConsole(BuildExpectedResult(tag, "registered in SW")));
   }
 
-  EXPECT_TRUE(GetRegistrationsOneShotFromServiceWorker(registered_tags));
+  EXPECT_TRUE(GetTagsFromServiceWorker(registered_tags));
 }
 
 // Verify that GetRegistration works in a service worker
-IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest,
-                       GetRegistrationFromServiceWorker) {
+IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, HasTagFromServiceWorker) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   std::vector<std::string> registered_tags;
-  EXPECT_TRUE(GetRegistrationsOneShot(registered_tags));
+  EXPECT_TRUE(GetTags(registered_tags));
 
   background_sync_test_util::SetOnline(web_contents(), false);
 
-  EXPECT_TRUE(RegisterOneShotFromServiceWorker("foo_sw"));
+  EXPECT_TRUE(RegisterFromServiceWorker("foo_sw"));
   EXPECT_TRUE(PopConsole("ok - foo_sw registered in SW"));
-  EXPECT_TRUE(GetRegistrationOneShotFromServiceWorker("foo_sw"));
+  EXPECT_TRUE(HasTagFromServiceWorker("foo_sw"));
 }
 
 // Verify that a background sync registration is deleted when site data is
 // cleared.
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest,
                        SyncRegistrationDeletedWhenClearingSiteData) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   // Prevent firing by going offline.
   background_sync_test_util::SetOnline(web_contents(), false);
-  EXPECT_TRUE(RegisterOneShot("foo"));
-  EXPECT_TRUE(GetRegistrationOneShot("foo"));
-  EXPECT_TRUE(OneShotPending("foo"));
+  EXPECT_TRUE(Register("foo"));
+  EXPECT_TRUE(HasTag("foo"));
+  EXPECT_TRUE(RegistrationPending("foo"));
 
   // Simulate a user clearing site data (including Service Workers, crucially),
   // by clearing data from the storage partition.
   ClearStoragePartitionData();
 
-  EXPECT_FALSE(GetRegistrationOneShot("foo"));
+  EXPECT_FALSE(HasTag("foo"));
 }
 
 // Verify that a background sync registration, from a service worker, is deleted
 // when site data is cleared.
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest,
                        SyncRegistrationFromSWDeletedWhenClearingSiteData) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   std::vector<std::string> registered_tags;
-  EXPECT_TRUE(GetRegistrationsOneShot(registered_tags));
+  EXPECT_TRUE(GetTags(registered_tags));
 
   background_sync_test_util::SetOnline(web_contents(), false);
 
-  EXPECT_TRUE(RegisterOneShotFromServiceWorker("foo_sw"));
+  EXPECT_TRUE(RegisterFromServiceWorker("foo_sw"));
   EXPECT_TRUE(PopConsole("ok - foo_sw registered in SW"));
-  EXPECT_TRUE(GetRegistrationOneShotFromServiceWorker("foo_sw"));
+  EXPECT_TRUE(HasTagFromServiceWorker("foo_sw"));
 
   // Simulate a user clearing site data (including Service Workers, crucially),
   // by clearing data from the storage partition.
   ClearStoragePartitionData();
 
-  EXPECT_FALSE(GetRegistrationOneShotFromServiceWorker("foo"));
+  EXPECT_FALSE(HasTagFromServiceWorker("foo"));
 }
 
 // Verify that multiple background sync registrations are deleted when site
 // data is cleared.
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest,
                        SyncRegistrationsDeletedWhenClearingSiteData) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   std::vector<std::string> registered_tags;
-  EXPECT_TRUE(GetRegistrationsOneShot(registered_tags));
+  EXPECT_TRUE(GetTags(registered_tags));
 
   background_sync_test_util::SetOnline(web_contents(), false);
   registered_tags.push_back("foo");
   registered_tags.push_back("bar");
 
   for (const std::string& tag : registered_tags)
-    EXPECT_TRUE(RegisterOneShot(tag));
+    EXPECT_TRUE(Register(tag));
 
-  EXPECT_TRUE(GetRegistrationsOneShot(registered_tags));
+  EXPECT_TRUE(GetTags(registered_tags));
 
   for (const std::string& tag : registered_tags)
-    EXPECT_TRUE(OneShotPending(tag));
+    EXPECT_TRUE(RegistrationPending(tag));
 
   // Simulate a user clearing site data (including Service Workers, crucially),
   // by clearing data from the storage partition.
   ClearStoragePartitionData();
 
   for (const std::string& tag : registered_tags)
-    EXPECT_FALSE(GetRegistrationOneShot(tag));
+    EXPECT_FALSE(HasTag(tag));
 }
 
 // Verify that a sync event that is currently firing is deleted when site
 // data is cleared.
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest,
                        FiringSyncEventDeletedWhenClearingSiteData) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   background_sync_test_util::SetOnline(web_contents(), true);
-  EXPECT_TRUE(RegisterOneShot("delay"));
+  EXPECT_TRUE(Register("delay"));
 
   // Verify that it is firing.
-  EXPECT_TRUE(GetRegistrationOneShot("delay"));
-  EXPECT_FALSE(OneShotPending("delay"));
+  EXPECT_TRUE(HasTag("delay"));
+  EXPECT_FALSE(RegistrationPending("delay"));
 
   // Simulate a user clearing site data (including Service Workers, crucially),
   // by clearing data from the storage partition.
   ClearStoragePartitionData();
 
   // Verify that it was deleted.
-  EXPECT_FALSE(GetRegistrationOneShot("delay"));
+  EXPECT_FALSE(HasTag("delay"));
 }
 
 // Disabled due to flakiness. See https://crbug.com/578952.
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, DISABLED_VerifyRetry) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   SetMaxSyncAttempts(2);
 
-  EXPECT_TRUE(RegisterOneShot("delay"));
-  EXPECT_TRUE(RejectDelayedOneShot());
+  EXPECT_TRUE(Register("delay"));
+  EXPECT_TRUE(RejectDelayedSyncEvent());
   EXPECT_TRUE(PopConsole("ok - delay rejected"));
 
-  // Verify that the oneshot is still around and waiting to try again.
-  EXPECT_TRUE(OneShotPending("delay"));
+  // Verify that the registration is still around and waiting to try again.
+  EXPECT_TRUE(RegistrationPending("delay"));
 }
 
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, RegisterFromNonMainFrame) {
   std::string script_result;
   GURL url = https_server()->GetURL(kEmptyURL);
-  EXPECT_TRUE(
-      RunScript(BuildScriptString("registerOneShotFromLocalFrame", url.spec()),
-                &script_result));
+  EXPECT_TRUE(RunScript(BuildScriptString("registerFromLocalFrame", url.spec()),
+                        &script_result));
   EXPECT_EQ(BuildExpectedResult("iframe", "failed to register sync"),
             script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest,
                        RegisterFromServiceWorkerWithoutMainFrameHost) {
   // Start a second https server to use as a second origin.
   net::EmbeddedTestServer alt_server(net::EmbeddedTestServer::TYPE_HTTPS);
   alt_server.ServeFilesFromSourceDirectory("content/test/data");
   ASSERT_TRUE(alt_server.Start());
 
   std::string script_result;
   GURL url = alt_server.GetURL(kRegisterSyncURL);
-  EXPECT_TRUE(
-      RunScript(BuildScriptString("registerOneShotFromCrossOriginServiceWorker",
-                                  url.spec()),
-                &script_result));
+  EXPECT_TRUE(RunScript(
+      BuildScriptString("registerFromCrossOriginServiceWorker", url.spec()),
+      &script_result));
   EXPECT_EQ(BuildExpectedResult("worker", "failed to register sync"),
             script_result);
 }
 
 }  // namespace content