[Background Sync Cleanup] Remove mention of oneshot

content/browser/background_sync/background_sync_manager_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_manager.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/files/scoped_temp_dir.h"
@@ skipping 49 matching lines @@
   EXPECT_EQ(SERVICE_WORKER_OK, status) << ServiceWorkerStatusToString(status);
   *out_registration = registration;
 }
 
 void UnregisterServiceWorkerCallback(bool* called,
                                      ServiceWorkerStatusCode code) {
   EXPECT_EQ(SERVICE_WORKER_OK, code);
   *called = true;
 }
 
-void OneShotSuccessfulCallback(
+void DispatchSyncSuccessfulCallback(
     int* count,
     const scoped_refptr<ServiceWorkerVersion>& active_version,
     const ServiceWorkerVersion::StatusCallback& callback) {
   *count += 1;
   callback.Run(SERVICE_WORKER_OK);
 }
 
-void OneShotFailedCallback(
+void DispatchSyncFailedCallback(
     int* count,
     const scoped_refptr<ServiceWorkerVersion>& active_version,
     const ServiceWorkerVersion::StatusCallback& callback) {
   *count += 1;
   callback.Run(SERVICE_WORKER_ERROR_FAILED);
 }
 
-void OneShotDelayedCallback(
+void DispatchSyncDelayedCallback(
     int* count,
     ServiceWorkerVersion::StatusCallback* out_callback,
     const scoped_refptr<ServiceWorkerVersion>& active_version,
     const ServiceWorkerVersion::StatusCallback& callback) {
   *count += 1;
   *out_callback = callback;
 }
 
 void NotifyWhenFinishedCallback(bool* was_called,
                                 BackgroundSyncStatus* out_status,
@@ skipping 44 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(TestBackgroundSyncController);
 };
 
 }  // namespace
 
 // A BackgroundSyncManager that can simulate delaying and corrupting the backend
 // storage and service worker onsync events.
 class TestBackgroundSyncManager : public BackgroundSyncManager {
  public:
-  using OneShotCallback =
+  using DispatchSyncCallback =
       base::Callback<void(const scoped_refptr<ServiceWorkerVersion>&,
                           const ServiceWorkerVersion::StatusCallback&)>;
 
   explicit TestBackgroundSyncManager(
       const scoped_refptr<ServiceWorkerContextWrapper>& service_worker_context)
       : BackgroundSyncManager(service_worker_context) {
   }
 
   void DoInit() { Init(); }
 
@@ skipping 19 matching lines @@
     continuation_.Run();
     continuation_.Reset();
   }
 
   void ClearDelayedTask() { delayed_task_.Reset(); }
 
   void set_corrupt_backend(bool corrupt_backend) {
     corrupt_backend_ = corrupt_backend;
   }
   void set_delay_backend(bool delay_backend) { delay_backend_ = delay_backend; }
-  void set_one_shot_callback(const OneShotCallback& callback) {
-    one_shot_callback_ = callback;
+  void set_dispatch_sync_callback(const DispatchSyncCallback& callback) {
+    dispatch_sync_callback_ = callback;
   }
 
   base::Closure delayed_task() const { return delayed_task_; }
   base::TimeDelta delayed_task_delta() const { return delayed_task_delta_; }
 
   BackgroundSyncEventLastChance last_chance() const { return last_chance_; }
 
   void set_has_main_frame_provider_host(bool value) {
     has_main_frame_provider_host_ = value;
   }
@@ skipping 39 matching lines @@
     }
     continuation_ =
         base::Bind(&TestBackgroundSyncManager::GetDataFromBackendContinue,
                    base::Unretained(this), key, callback);
     if (delay_backend_)
       return;
 
     Continue();
   }
 
-  void FireOneShotSync(
+  void DispatchSyncEvent(
       BackgroundSyncRegistrationHandle::HandleId handle_id,
       const scoped_refptr<ServiceWorkerVersion>& active_version,
       BackgroundSyncEventLastChance last_chance,
       const ServiceWorkerVersion::StatusCallback& callback) override {
-    ASSERT_FALSE(one_shot_callback_.is_null());
+    ASSERT_FALSE(dispatch_sync_callback_.is_null());
     last_chance_ = last_chance;
-    one_shot_callback_.Run(active_version, callback);
+    dispatch_sync_callback_.Run(active_version, callback);
   }
 
   void ScheduleDelayedTask(const base::Closure& callback,
                            base::TimeDelta delay) override {
     delayed_task_ = callback;
     delayed_task_delta_ = delay;
   }
 
   void HasMainFrameProviderHost(const GURL& origin,
                                 const BoolCallback& callback) override {
     callback.Run(has_main_frame_provider_host_);
   }
 
  private:
   bool corrupt_backend_ = false;
   bool delay_backend_ = false;
   bool has_main_frame_provider_host_ = true;
   BackgroundSyncEventLastChance last_chance_ =
       BackgroundSyncEventLastChance::IS_NOT_LAST_CHANCE;
   base::Closure continuation_;
-  OneShotCallback one_shot_callback_;
+  DispatchSyncCallback dispatch_sync_callback_;
   base::Closure delayed_task_;
   base::TimeDelta delayed_task_delta_;
 };
 
 class BackgroundSyncManagerTest : public testing::Test {
  public:
   BackgroundSyncManagerTest()
       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
         network_change_notifier_(net::NetworkChangeNotifier::CreateMock()) {
     sync_options_1_.tag = "foo";
@@ skipping 285 matching lines @@
     EXPECT_TRUE(called);
   }
 
   GURL PatternForSWId(int64_t sw_id) {
     EXPECT_TRUE(sw_id == sw_registration_id_1_ ||
                 sw_id == sw_registration_id_2_);
     return sw_id == sw_registration_id_1_ ? GURL(kPattern1) : GURL(kPattern2);
   }
 
   void SetupForSyncEvent(
-      const TestBackgroundSyncManager::OneShotCallback& callback) {
-    test_background_sync_manager_->set_one_shot_callback(callback);
+      const TestBackgroundSyncManager::DispatchSyncCallback& callback) {
+    test_background_sync_manager_->set_dispatch_sync_callback(callback);
     SetNetwork(net::NetworkChangeNotifier::CONNECTION_WIFI);
   }
 
   void InitSyncEventTest() {
     SetupForSyncEvent(
-        base::Bind(OneShotSuccessfulCallback, &sync_events_called_));
+        base::Bind(DispatchSyncSuccessfulCallback, &sync_events_called_));
   }
 
   void InitFailedSyncEventTest() {
-    SetupForSyncEvent(base::Bind(OneShotFailedCallback, &sync_events_called_));
+    SetupForSyncEvent(
+        base::Bind(DispatchSyncFailedCallback, &sync_events_called_));
   }
 
   void InitDelayedSyncEventTest() {
-    SetupForSyncEvent(base::Bind(OneShotDelayedCallback, &sync_events_called_,
-                                 &sync_fired_callback_));
+    SetupForSyncEvent(base::Bind(DispatchSyncDelayedCallback,
+                                 &sync_events_called_, &sync_fired_callback_));
   }
 
   void RegisterAndVerifySyncEventDelayed(
       const BackgroundSyncRegistrationOptions& sync_options) {
     int sync_events_called = sync_events_called_;
     EXPECT_TRUE(sync_fired_callback_.is_null());
 
     EXPECT_TRUE(Register(sync_options));
 
     EXPECT_EQ(sync_events_called + 1, sync_events_called_);
@@ skipping 414 matching lines @@
 TEST_F(BackgroundSyncManagerTest, EmptyTagSupported) {
   sync_options_1_.tag = "a";
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_TRUE(GetRegistration(sync_options_1_));
   EXPECT_TRUE(
       sync_options_1_.Equals(*callback_registration_handle_->options()));
   EXPECT_TRUE(Unregister(callback_registration_handle_.get()));
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 }
 
-TEST_F(BackgroundSyncManagerTest, OneShotFiresOnRegistration) {
+TEST_F(BackgroundSyncManagerTest, FiresOnRegistration) {
   InitSyncEventTest();
 
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_EQ(1, sync_events_called_);
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 }
 
 TEST_F(BackgroundSyncManagerTest, NotifyWhenFinishedAfterEventSuccess) {
   InitSyncEventTest();
 
@@ skipping 304 matching lines @@
   EXPECT_FALSE(Register(sync_options_2_));
   EXPECT_FALSE(callback_finished_called_);
   test_background_sync_manager_->set_corrupt_backend(false);
 
   // Successfully complete the firing event.
   sync_fired_callback_.Run(SERVICE_WORKER_OK);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(BackgroundSyncState::SUCCESS, FinishedState());
 }
 
-TEST_F(BackgroundSyncManagerTest, OneShotFiresOnNetworkChange) {
+TEST_F(BackgroundSyncManagerTest, FiresOnNetworkChange) {
   InitSyncEventTest();
 
   SetNetwork(net::NetworkChangeNotifier::CONNECTION_NONE);
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_EQ(0, sync_events_called_);
   EXPECT_TRUE(GetRegistration(sync_options_1_));
 
   SetNetwork(net::NetworkChangeNotifier::CONNECTION_WIFI);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, sync_events_called_);
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 }
 
-TEST_F(BackgroundSyncManagerTest, MultipleOneShotsFireOnNetworkChange) {
+TEST_F(BackgroundSyncManagerTest, MultipleRegistrationsFireOnNetworkChange) {
   InitSyncEventTest();
 
   SetNetwork(net::NetworkChangeNotifier::CONNECTION_NONE);
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_TRUE(Register(sync_options_2_));
   EXPECT_EQ(0, sync_events_called_);
   EXPECT_TRUE(GetRegistration(sync_options_1_));
   EXPECT_TRUE(GetRegistration(sync_options_2_));
 
   SetNetwork(net::NetworkChangeNotifier::CONNECTION_WIFI);
 
   EXPECT_EQ(2, sync_events_called_);
   EXPECT_FALSE(GetRegistration(sync_options_1_));
   EXPECT_FALSE(GetRegistration(sync_options_2_));
 }
 
-TEST_F(BackgroundSyncManagerTest, OneShotFiresOnManagerRestart) {
+TEST_F(BackgroundSyncManagerTest, FiresOnManagerRestart) {
   InitSyncEventTest();
 
   // Initially the event won't run because there is no network.
   SetNetwork(net::NetworkChangeNotifier::CONNECTION_NONE);
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_EQ(0, sync_events_called_);
   EXPECT_TRUE(GetRegistration(sync_options_1_));
 
   // Simulate closing the browser.
   DeleteBackgroundSyncManager();
 
   // The next time the manager is started, the network is good.
   SetNetwork(net::NetworkChangeNotifier::CONNECTION_WIFI);
   SetupBackgroundSyncManager();
   InitSyncEventTest();
 
   // The event should have fired.
   EXPECT_EQ(1, sync_events_called_);
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 }
 
-TEST_F(BackgroundSyncManagerTest, FailedOneShotShouldBeRemoved) {
+TEST_F(BackgroundSyncManagerTest, FailedRegistrationShouldBeRemoved) {
   InitFailedSyncEventTest();
 
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_EQ(1, sync_events_called_);
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 }
 
-TEST_F(BackgroundSyncManagerTest, FailedOneShotReregisteredAndFires) {
+TEST_F(BackgroundSyncManagerTest, FailedRegistrationReregisteredAndFires) {
   InitFailedSyncEventTest();
 
   // The initial sync event fails.
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_EQ(1, sync_events_called_);
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 
   InitSyncEventTest();
 
   // Reregistering should cause the sync event to fire again, this time
   // succeeding.
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_EQ(2, sync_events_called_);
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 }
 
-TEST_F(BackgroundSyncManagerTest, DelayOneShotMidSync) {
+TEST_F(BackgroundSyncManagerTest, DelayMidSync) {
   InitDelayedSyncEventTest();
 
   RegisterAndVerifySyncEventDelayed(sync_options_1_);
 
   // Finish firing the event and verify that the registration is removed.
   sync_fired_callback_.Run(SERVICE_WORKER_OK);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, sync_events_called_);
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 }
 
 TEST_F(BackgroundSyncManagerTest, OverwriteRegistrationMidSync) {
   InitDelayedSyncEventTest();
 
   sync_options_1_.network_state = NETWORK_STATE_ANY;
   SetNetwork(net::NetworkChangeNotifier::CONNECTION_NONE);
 
   RegisterAndVerifySyncEventDelayed(sync_options_1_);
 
   // Don't delay the next sync.
-  test_background_sync_manager_->set_one_shot_callback(
-      base::Bind(OneShotSuccessfulCallback, &sync_events_called_));
+  test_background_sync_manager_->set_dispatch_sync_callback(
+      base::Bind(DispatchSyncSuccessfulCallback, &sync_events_called_));
 
   // Register a different sync event with the same tag, overwriting the first.
   sync_options_1_.network_state = NETWORK_STATE_ONLINE;
   EXPECT_TRUE(Register(sync_options_1_));
 
   // The new sync event won't run as the network requirements aren't met.
   EXPECT_EQ(1, sync_events_called_);
   EXPECT_TRUE(GetRegistration(sync_options_1_));
 
   // Finish the first event, note that the second is still registered.
   sync_fired_callback_.Run(SERVICE_WORKER_OK);
   EXPECT_EQ(1, sync_events_called_);
   EXPECT_TRUE(GetRegistration(sync_options_1_));
 
   // Change the network and the second should run.
   SetNetwork(net::NetworkChangeNotifier::CONNECTION_WIFI);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(2, sync_events_called_);
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 }
 
-TEST_F(BackgroundSyncManagerTest, UnregisterOneShotMidSync) {
+TEST_F(BackgroundSyncManagerTest, UnregisterMidSync) {
   InitDelayedSyncEventTest();
 
   RegisterAndVerifySyncEventDelayed(sync_options_1_);
 
   EXPECT_TRUE(Unregister(callback_registration_handle_.get()));
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 
   sync_fired_callback_.Run(SERVICE_WORKER_OK);
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 }
@@ skipping 359 matching lines @@
   // Run it again.
   test_clock_->Advance(test_background_sync_manager_->delayed_task_delta());
   test_background_sync_manager_->delayed_task().Run();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(GetRegistration(sync_options_1_));
   EXPECT_EQ(BackgroundSyncEventLastChance::IS_LAST_CHANCE,
             test_background_sync_manager_->last_chance());
 }
 
 }  // namespace content