[Background Sync Cleanup] Remove mention of oneshot

content/browser/background_sync/background_sync_service_impl_unittest.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 "content/browser/background_sync/background_sync_service_impl.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 173 matching lines @@
         mojo::GetProxy(&service_ptr_);
     // Create a new BackgroundSyncServiceImpl bound to the dummy channel
     background_sync_context_->CreateService(std::move(service_request));
     base::RunLoop().RunUntilIdle();
 
     service_impl_ = *background_sync_context_->services_.begin();
     ASSERT_TRUE(service_impl_);
   }
 
   // Helpers for testing BackgroundSyncServiceImpl methods
-  void RegisterOneShot(
-      SyncRegistrationPtr sync,
-      const BackgroundSyncService::RegisterCallback& callback) {
+  void Register(SyncRegistrationPtr sync,
+                const BackgroundSyncService::RegisterCallback& callback) {
     service_impl_->Register(std::move(sync), sw_registration_id_,
                             false /* requested_from_service_worker */,
                             callback);
     base::RunLoop().RunUntilIdle();
   }
 
-  void UnregisterOneShot(
-      int32_t handle_id,
-      const BackgroundSyncService::UnregisterCallback& callback) {
+  void Unregister(int32_t handle_id,
+                  const BackgroundSyncService::UnregisterCallback& callback) {
     service_impl_->Unregister(
         handle_id, sw_registration_id_, callback);
     base::RunLoop().RunUntilIdle();
   }
 
-  void GetRegistrationOneShot(
+  void GetRegistration(
       const mojo::String& tag,
       const BackgroundSyncService::RegisterCallback& callback) {
     service_impl_->GetRegistration(tag, sw_registration_id_, callback);
     base::RunLoop().RunUntilIdle();
   }
 
-  void GetRegistrationsOneShot(
+  void GetRegistrations(
       const BackgroundSyncService::GetRegistrationsCallback& callback) {
     service_impl_->GetRegistrations(sw_registration_id_, callback);
     base::RunLoop().RunUntilIdle();
   }
 
   void NotifyWhenDone(
       int32_t handle_id,
       const BackgroundSyncService::NotifyWhenFinishedCallback& callback) {
     service_impl_->NotifyWhenFinished(handle_id, callback);
     base::RunLoop().RunUntilIdle();
@@ skipping 11 matching lines @@
       service_impl_;  // Owned by background_sync_context_
   SyncRegistrationPtr default_sync_registration_;
 };
 
 // Tests
 
 TEST_F(BackgroundSyncServiceImplTest, Register) {
   bool called = false;
   BackgroundSyncError error;
   SyncRegistrationPtr reg;
-  RegisterOneShot(
-      default_sync_registration_.Clone(),
-      base::Bind(&ErrorAndRegistrationCallback, &called, &error, &reg));
+  Register(default_sync_registration_.Clone(),
+           base::Bind(&ErrorAndRegistrationCallback, &called, &error, &reg));
   EXPECT_TRUE(called);
   EXPECT_EQ(BackgroundSyncError::NONE, error);
   EXPECT_EQ("", reg->tag);
 }
 
 TEST_F(BackgroundSyncServiceImplTest, Unregister) {
   bool unregister_called = false;
   BackgroundSyncError unregister_error;
   SyncRegistrationPtr reg;
-  UnregisterOneShot(
-      default_sync_registration_->handle_id,
-      base::Bind(&ErrorCallback, &unregister_called, &unregister_error));
+  Unregister(default_sync_registration_->handle_id,
+             base::Bind(&ErrorCallback, &unregister_called, &unregister_error));
   EXPECT_TRUE(unregister_called);
   EXPECT_EQ(BackgroundSyncError::NOT_ALLOWED, unregister_error);
 }
 
 TEST_F(BackgroundSyncServiceImplTest, UnregisterWithRegisteredSync) {
   bool register_called = false;
   bool unregister_called = false;
   BackgroundSyncError register_error;
   BackgroundSyncError unregister_error;
   SyncRegistrationPtr reg;
-  RegisterOneShot(default_sync_registration_.Clone(),
-                  base::Bind(&ErrorAndRegistrationCallback, &register_called,
-                             &register_error, &reg));
+  Register(default_sync_registration_.Clone(),
+           base::Bind(&ErrorAndRegistrationCallback, &register_called,
+                      &register_error, &reg));
   EXPECT_TRUE(register_called);
   EXPECT_EQ(BackgroundSyncError::NONE, register_error);
-  UnregisterOneShot(
-      reg->handle_id,
-      base::Bind(&ErrorCallback, &unregister_called, &unregister_error));
+  Unregister(reg->handle_id,
+             base::Bind(&ErrorCallback, &unregister_called, &unregister_error));
   EXPECT_TRUE(unregister_called);
   EXPECT_EQ(BackgroundSyncError::NONE, unregister_error);
 }
 
 TEST_F(BackgroundSyncServiceImplTest, GetRegistration) {
   bool called = false;
   BackgroundSyncError error;
   SyncRegistrationPtr reg;
-  GetRegistrationOneShot(
+  GetRegistration(
       "", base::Bind(&ErrorAndRegistrationCallback, &called, &error, &reg));
   EXPECT_TRUE(called);
   EXPECT_EQ(BackgroundSyncError::NOT_FOUND, error);
 }
 
 TEST_F(BackgroundSyncServiceImplTest, GetRegistrationWithRegisteredSync) {
   bool register_called = false;
   bool getregistration_called = false;
   BackgroundSyncError register_error;
   BackgroundSyncError getregistration_error;
   SyncRegistrationPtr register_reg;
   SyncRegistrationPtr getregistration_reg;
-  RegisterOneShot(default_sync_registration_.Clone(),
-                  base::Bind(&ErrorAndRegistrationCallback, &register_called,
-                             &register_error, &register_reg));
+  Register(default_sync_registration_.Clone(),
+           base::Bind(&ErrorAndRegistrationCallback, &register_called,
+                      &register_error, &register_reg));
   EXPECT_TRUE(register_called);
   EXPECT_EQ(BackgroundSyncError::NONE, register_error);
-  GetRegistrationOneShot(
+  GetRegistration(
       register_reg->tag,
       base::Bind(&ErrorAndRegistrationCallback, &getregistration_called,
                  &getregistration_error, &getregistration_reg));
   EXPECT_TRUE(getregistration_called);
   EXPECT_EQ(BackgroundSyncError::NONE, getregistration_error);
 }
 
 TEST_F(BackgroundSyncServiceImplTest, GetRegistrations) {
   bool called = false;
   BackgroundSyncError error;
   unsigned long array_size = 0UL;
-  GetRegistrationsOneShot(base::Bind(&ErrorAndRegistrationListCallback, &called,
-                                     &error, &array_size));
+  GetRegistrations(base::Bind(&ErrorAndRegistrationListCallback, &called,
+                              &error, &array_size));
   EXPECT_TRUE(called);
   EXPECT_EQ(BackgroundSyncError::NONE, error);
   EXPECT_EQ(0UL, array_size);
 }
 
 TEST_F(BackgroundSyncServiceImplTest, GetRegistrationsWithRegisteredSync) {
   bool register_called = false;
   bool getregistrations_called = false;
   BackgroundSyncError register_error;
   BackgroundSyncError getregistrations_error;
   SyncRegistrationPtr register_reg;
   unsigned long array_size = 0UL;
-  RegisterOneShot(default_sync_registration_.Clone(),
-                  base::Bind(&ErrorAndRegistrationCallback, &register_called,
-                             &register_error, &register_reg));
+  Register(default_sync_registration_.Clone(),
+           base::Bind(&ErrorAndRegistrationCallback, &register_called,
+                      &register_error, &register_reg));
   EXPECT_TRUE(register_called);
   EXPECT_EQ(BackgroundSyncError::NONE, register_error);
-  GetRegistrationsOneShot(base::Bind(&ErrorAndRegistrationListCallback,
-                                     &getregistrations_called,
-                                     &getregistrations_error, &array_size));
+  GetRegistrations(base::Bind(&ErrorAndRegistrationListCallback,
+                              &getregistrations_called, &getregistrations_error,
+                              &array_size));
   EXPECT_TRUE(getregistrations_called);
   EXPECT_EQ(BackgroundSyncError::NONE, getregistrations_error);
   EXPECT_EQ(1UL, array_size);
 }
 
 TEST_F(BackgroundSyncServiceImplTest, NotifyWhenFinished) {
   // Register a sync event.
   bool register_called = false;
   BackgroundSyncError register_error;
   SyncRegistrationPtr reg;
-  RegisterOneShot(default_sync_registration_.Clone(),
-                  base::Bind(&ErrorAndRegistrationCallback, &register_called,
-                             &register_error, &reg));
+  Register(default_sync_registration_.Clone(),
+           base::Bind(&ErrorAndRegistrationCallback, &register_called,
+                      &register_error, &reg));
   EXPECT_TRUE(register_called);
   EXPECT_EQ(BackgroundSyncError::NONE, register_error);
 
   // Unregister it.
   bool unregister_called = false;
   BackgroundSyncError unregister_error;
-  UnregisterOneShot(
-      reg->handle_id,
-      base::Bind(&ErrorCallback, &unregister_called, &unregister_error));
+  Unregister(reg->handle_id,
+             base::Bind(&ErrorCallback, &unregister_called, &unregister_error));
   EXPECT_TRUE(unregister_called);
   EXPECT_EQ(BackgroundSyncError::NONE, unregister_error);
 
   // Call NotifyWhenDone and verify that it calls back with unregistered.
   bool notify_done_called = false;
   BackgroundSyncError notify_done_error = BackgroundSyncError::NONE;
   BackgroundSyncState notify_done_sync_state = BackgroundSyncState::SUCCESS;
 
   NotifyWhenDone(reg->handle_id,
                  base::Bind(&ErrorAndStateCallback, &notify_done_called,
                             &notify_done_error, &notify_done_sync_state));
   EXPECT_TRUE(notify_done_called);
   EXPECT_EQ(BackgroundSyncError::NONE, notify_done_error);
   EXPECT_EQ(BackgroundSyncState::UNREGISTERED, notify_done_sync_state);
 }
 
 }  // namespace content