[BackgroundSync] Remove BackgroundSyncRegistrationHandle

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"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/mock_entropy_provider.h"
 #include "base/test/simple_test_clock.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/background_sync/background_sync_network_observer.h"
-#include "content/browser/background_sync/background_sync_registration_handle.h"
 #include "content/browser/background_sync/background_sync_status.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_storage.h"
 #include "content/browser/storage_partition_impl.h"
 #include "content/public/browser/background_sync_parameters.h"
 #include "content/public/test/background_sync_test_util.h"
 #include "content/public/test/test_browser_context.h"
@@ skipping 161 matching lines @@
     continuation_ =
         base::Bind(&TestBackgroundSyncManager::GetDataFromBackendContinue,
                    base::Unretained(this), key, callback);
     if (delay_backend_)
       return;
 
     Continue();
   }
 
   void DispatchSyncEvent(
-      BackgroundSyncRegistrationHandle::HandleId handle_id,
+      const std::string& tag,
       const scoped_refptr<ServiceWorkerVersion>& active_version,
       BackgroundSyncEventLastChance last_chance,
       const ServiceWorkerVersion::StatusCallback& callback) override {
     ASSERT_FALSE(dispatch_sync_callback_.is_null());
     last_chance_ = last_chance;
     dispatch_sync_callback_.Run(active_version, callback);
   }
 
   void ScheduleDelayedTask(const base::Closure& callback,
                            base::TimeDelta delay) override {
@@ skipping 99 matching lines @@
           test_background_sync_manager_->GetNetworkObserverForTesting();
       network_observer->NotifyManagerIfNetworkChangedForTesting(
           connection_type);
       base::RunLoop().RunUntilIdle();
     }
   }
 
   void StatusAndRegistrationCallback(
       bool* was_called,
       BackgroundSyncStatus status,
-      scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle) {
+      scoped_ptr<BackgroundSyncRegistration> registration) {
     *was_called = true;
     callback_status_ = status;
-    callback_registration_handle_ = std::move(registration_handle);
+    callback_registration_ = std::move(registration);
   }
 
   void StatusAndRegistrationsCallback(
       bool* was_called,
       BackgroundSyncStatus status,
-      scoped_ptr<ScopedVector<BackgroundSyncRegistrationHandle>>
-          registration_handles) {
+      scoped_ptr<ScopedVector<BackgroundSyncRegistration>> registrations) {
     *was_called = true;
     callback_status_ = status;
-    callback_registration_handles_ = std::move(registration_handles);
+    callback_registrations_ = std::move(registrations);
   }
 
   void StatusCallback(bool* was_called, BackgroundSyncStatus status) {
     *was_called = true;
     callback_status_ = status;
   }
 
  protected:
   void CreateBackgroundSyncManager() {
-    ClearRegistrationHandles();
-
     test_background_sync_manager_ =
         new TestBackgroundSyncManager(helper_->context_wrapper());
     background_sync_manager_.reset(test_background_sync_manager_);
 
     test_clock_ = new base::SimpleTestClock();
     background_sync_manager_->set_clock(make_scoped_ptr(test_clock_));
 
     // Many tests do not expect the sync event to fire immediately after
     // register (and cleanup up the sync registrations).  Tests can control when
     // the sync event fires by manipulating the network state as needed.
     // NOTE: The setup of the network connection must happen after the
     //       BackgroundSyncManager has been created.
     SetNetwork(net::NetworkChangeNotifier::CONNECTION_NONE);
   }
 
   void InitBackgroundSyncManager() {
     test_background_sync_manager_->DoInit();
     base::RunLoop().RunUntilIdle();
   }
 
-  // Clear the registrations so that the BackgroundSyncManager can release them.
-  void ClearRegistrationHandles() {
-    callback_registration_handle_.reset();
-    callback_registration_handles_.reset();
-  }
-
   void SetupBackgroundSyncManager() {
     CreateBackgroundSyncManager();
     InitBackgroundSyncManager();
   }
 
   void SetupCorruptBackgroundSyncManager() {
     CreateBackgroundSyncManager();
     test_background_sync_manager_->set_corrupt_backend(true);
     InitBackgroundSyncManager();
   }
 
   void SetupDelayedBackgroundSyncManager() {
     CreateBackgroundSyncManager();
     test_background_sync_manager_->set_delay_backend(true);
     InitBackgroundSyncManager();
   }
 
   void DeleteBackgroundSyncManager() {
-    ClearRegistrationHandles();
     background_sync_manager_.reset();
     test_background_sync_manager_ = nullptr;
     test_clock_ = nullptr;
   }
 
   bool Register(const BackgroundSyncRegistrationOptions& sync_options) {
     return RegisterWithServiceWorkerId(sw_registration_id_1_, sync_options);
   }
 
   bool RegisterWithServiceWorkerId(
@@ skipping 33 matching lines @@
       const BackgroundSyncRegistrationOptions& registration_options) {
     bool was_called = false;
     background_sync_manager_->GetRegistrations(
         sw_registration_id,
         base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationsCallback,
                    base::Unretained(this), &was_called));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
 
     if (callback_status_ == BACKGROUND_SYNC_STATUS_OK) {
-      for (auto iter = callback_registration_handles_->begin();
-           iter < callback_registration_handles_->end(); ++iter) {
+      for (auto iter = callback_registrations_->begin();
+           iter < callback_registrations_->end(); ++iter) {
         if ((*iter)->options()->tag == registration_options.tag) {
-          // Transfer the matching registration handle out of the vector into
-          // callback_registration_handle_ for testing.
-          callback_registration_handle_.reset(*iter);
-          callback_registration_handles_->weak_erase(iter);
+          // Transfer the matching registration out of the vector into
+          // callback_registration_ for testing.
+          callback_registration_.reset(*iter);
+          callback_registrations_->weak_erase(iter);
           return true;
         }
       }
     }
     return false;
   }
 
   bool GetRegistrations() {
     return GetRegistrationsWithServiceWorkerId(sw_registration_id_1_);
   }
@@ skipping 94 matching lines @@
   int64_t sw_registration_id_1_;
   int64_t sw_registration_id_2_;
   scoped_refptr<ServiceWorkerRegistration> sw_registration_1_;
   scoped_refptr<ServiceWorkerRegistration> sw_registration_2_;
 
   BackgroundSyncRegistrationOptions sync_options_1_;
   BackgroundSyncRegistrationOptions sync_options_2_;
 
   // Callback values.
   BackgroundSyncStatus callback_status_ = BACKGROUND_SYNC_STATUS_OK;
-  scoped_ptr<BackgroundSyncRegistrationHandle> callback_registration_handle_;
-  scoped_ptr<ScopedVector<BackgroundSyncRegistrationHandle>>
-      callback_registration_handles_;
+  scoped_ptr<BackgroundSyncRegistration> callback_registration_;
+  scoped_ptr<ScopedVector<BackgroundSyncRegistration>> callback_registrations_;
   ServiceWorkerStatusCode callback_sw_status_code_ = SERVICE_WORKER_OK;
   int sync_events_called_ = 0;
   ServiceWorkerVersion::StatusCallback sync_fired_callback_;
 };
 
 TEST_F(BackgroundSyncManagerTest, Register) {
   EXPECT_TRUE(Register(sync_options_1_));
 }
 
 TEST_F(BackgroundSyncManagerTest, RegistractionIntact) {
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_STREQ(sync_options_1_.tag.c_str(),
-               callback_registration_handle_->options()->tag.c_str());
-  EXPECT_TRUE(callback_registration_handle_->IsValid());
+               callback_registration_->options()->tag.c_str());
+  EXPECT_TRUE(callback_registration_->IsValid());
 }
 
 TEST_F(BackgroundSyncManagerTest, RegisterWithoutLiveSWRegistration) {
   sw_registration_1_ = nullptr;
   EXPECT_FALSE(Register(sync_options_1_));
   EXPECT_EQ(BACKGROUND_SYNC_STATUS_NO_SERVICE_WORKER, callback_status_);
 }
 
 TEST_F(BackgroundSyncManagerTest, RegisterWithoutActiveSWRegistration) {
   sw_registration_1_->UnsetVersion(sw_registration_1_->active_version());
   EXPECT_FALSE(Register(sync_options_1_));
   EXPECT_EQ(BACKGROUND_SYNC_STATUS_NO_SERVICE_WORKER, callback_status_);
 }
 
 TEST_F(BackgroundSyncManagerTest, RegisterBadBackend) {
   test_background_sync_manager_->set_corrupt_backend(true);
   EXPECT_FALSE(Register(sync_options_1_));
   test_background_sync_manager_->set_corrupt_backend(false);
   EXPECT_FALSE(Register(sync_options_1_));
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 }
 
-TEST_F(BackgroundSyncManagerTest, DuplicateRegistrationHandle) {
-  EXPECT_TRUE(Register(sync_options_1_));
-  EXPECT_TRUE(
-      sync_options_1_.Equals(*callback_registration_handle_->options()));
-
-  scoped_ptr<BackgroundSyncRegistrationHandle> dup_handle =
-      background_sync_manager_->DuplicateRegistrationHandle(
-          callback_registration_handle_->handle_id());
-
-  EXPECT_TRUE(sync_options_1_.Equals(*dup_handle->options()));
-  EXPECT_NE(callback_registration_handle_->handle_id(),
-            dup_handle->handle_id());
-}
-
 TEST_F(BackgroundSyncManagerTest, TwoRegistrations) {
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_TRUE(Register(sync_options_2_));
 }
 
 TEST_F(BackgroundSyncManagerTest, GetRegistrationNonExisting) {
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 }
 
 TEST_F(BackgroundSyncManagerTest, GetRegistrationExisting) {
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_TRUE(GetRegistration(sync_options_1_));
   EXPECT_FALSE(GetRegistration(sync_options_2_));
 }
 
 TEST_F(BackgroundSyncManagerTest, GetRegistrationBadBackend) {
   EXPECT_TRUE(Register(sync_options_1_));
   test_background_sync_manager_->set_corrupt_backend(true);
   EXPECT_TRUE(GetRegistration(sync_options_1_));
   EXPECT_FALSE(Register(sync_options_2_));
   // Registration should have discovered the bad backend and disabled the
   // BackgroundSyncManager.
   EXPECT_FALSE(GetRegistration(sync_options_1_));
   test_background_sync_manager_->set_corrupt_backend(false);
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 }
 
 TEST_F(BackgroundSyncManagerTest, GetRegistrationsZero) {
   EXPECT_TRUE(GetRegistrations());
-  EXPECT_EQ(0u, callback_registration_handles_->size());
+  EXPECT_EQ(0u, callback_registrations_->size());
 }
 
 TEST_F(BackgroundSyncManagerTest, GetRegistrationsOne) {
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_TRUE(GetRegistrations());
 
-  EXPECT_EQ(1u, callback_registration_handles_->size());
-  sync_options_1_.Equals(*(*callback_registration_handles_)[0]->options());
+  EXPECT_EQ(1u, callback_registrations_->size());
+  sync_options_1_.Equals(*(*callback_registrations_)[0]->options());
 }
 
 TEST_F(BackgroundSyncManagerTest, GetRegistrationsTwo) {
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_TRUE(Register(sync_options_2_));
   EXPECT_TRUE(GetRegistrations());
 
-  EXPECT_EQ(2u, callback_registration_handles_->size());
-  sync_options_1_.Equals(*(*callback_registration_handles_)[0]->options());
-  sync_options_2_.Equals(*(*callback_registration_handles_)[1]->options());
+  EXPECT_EQ(2u, callback_registrations_->size());
+  sync_options_1_.Equals(*(*callback_registrations_)[0]->options());
+  sync_options_2_.Equals(*(*callback_registrations_)[1]->options());
 }
 
 TEST_F(BackgroundSyncManagerTest, GetRegistrationsBadBackend) {
   EXPECT_TRUE(Register(sync_options_1_));
   test_background_sync_manager_->set_corrupt_backend(true);
   EXPECT_TRUE(GetRegistrations());
   EXPECT_FALSE(Register(sync_options_2_));
   // Registration should have discovered the bad backend and disabled the
   // BackgroundSyncManager.
   EXPECT_FALSE(GetRegistrations());
@@ skipping 18 matching lines @@
   sync_options_1_.tag = std::string(MaxTagLength(), 'a');
   EXPECT_TRUE(Register(sync_options_1_));
 
   sync_options_2_.tag = std::string(MaxTagLength() + 1, 'b');
   EXPECT_FALSE(Register(sync_options_2_));
   EXPECT_EQ(BACKGROUND_SYNC_STATUS_NOT_ALLOWED, callback_status_);
 }
 
 TEST_F(BackgroundSyncManagerTest, RegistrationIncreasesId) {
   EXPECT_TRUE(Register(sync_options_1_));
-  scoped_ptr<BackgroundSyncRegistrationHandle> registered_handle =
-      std::move(callback_registration_handle_);
   BackgroundSyncRegistration::RegistrationId cur_id =
-      registered_handle->handle_id();
+      callback_registration_->id();
 
   EXPECT_TRUE(GetRegistration(sync_options_1_));
   EXPECT_TRUE(Register(sync_options_2_));
-  EXPECT_LT(cur_id, callback_registration_handle_->handle_id());
+  EXPECT_LT(cur_id, callback_registration_->id());
 }
 
 TEST_F(BackgroundSyncManagerTest, RebootRecovery) {
   EXPECT_TRUE(Register(sync_options_1_));
 
   SetupBackgroundSyncManager();
 
   EXPECT_TRUE(GetRegistration(sync_options_1_));
   EXPECT_FALSE(GetRegistration(sync_options_2_));
 }
@@ skipping 176 matching lines @@
   options.network_state = NETWORK_STATE_AVOID_CELLULAR;
 
   // Store the registration.
   EXPECT_TRUE(Register(options));
 
   // Simulate restarting the sync manager, forcing the next read to come from
   // disk.
   SetupBackgroundSyncManager();
 
   EXPECT_TRUE(GetRegistration(options));
-  EXPECT_TRUE(options.Equals(*callback_registration_handle_->options()));
+  EXPECT_TRUE(options.Equals(*callback_registration_->options()));
 }
 
 TEST_F(BackgroundSyncManagerTest, EmptyTagSupported) {
   sync_options_1_.tag = "";
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_TRUE(GetRegistration(sync_options_1_));
-  EXPECT_TRUE(
-      sync_options_1_.Equals(*callback_registration_handle_->options()));
+  EXPECT_TRUE(sync_options_1_.Equals(*callback_registration_->options()));
 }
 
 TEST_F(BackgroundSyncManagerTest, FiresOnRegistration) {
   InitSyncEventTest();
 
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_EQ(1, sync_events_called_);
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 }
 
@@ skipping 528 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