Remove ScopedVector from content/browser/.

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 <memory>
 #include <utility>
+#include <vector>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.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"
@@ skipping 179 matching lines @@
       BackgroundSyncStatus status,
       std::unique_ptr<BackgroundSyncRegistration> registration) {
     *was_called = true;
     callback_status_ = status;
     callback_registration_ = std::move(registration);
   }
 
   void StatusAndRegistrationsCallback(
       bool* was_called,
       BackgroundSyncStatus status,
-      std::unique_ptr<ScopedVector<BackgroundSyncRegistration>> registrations) {
+      std::unique_ptr<std::vector<std::unique_ptr<BackgroundSyncRegistration>>>
+          registrations) {
     *was_called = true;
     callback_status_ = status;
     callback_registrations_ = std::move(registrations);
   }
 
   void StatusCallback(bool* was_called, BackgroundSyncStatus status) {
     *was_called = true;
     callback_status_ = status;
   }
 
@@ skipping 80 matching lines @@
                    base::Unretained(this), &was_called));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
 
     if (callback_status_ == BACKGROUND_SYNC_STATUS_OK) {
       for (auto iter = callback_registrations_->begin();
            iter < callback_registrations_->end(); ++iter) {
         if ((*iter)->options()->tag == registration_options.tag) {
           // Transfer the matching registration out of the vector into
           // callback_registration_ for testing.
-          callback_registration_.reset(*iter);
-          callback_registrations_->weak_erase(iter);
+          callback_registration_ = std::move(*iter);
+          callback_registrations_->erase(iter);
           return true;
         }
       }
     }
     return false;
   }
 
   bool GetRegistrations() {
     return GetRegistrationsWithServiceWorkerId(sw_registration_id_1_);
   }
@@ skipping 95 matching lines @@
   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;
   std::unique_ptr<BackgroundSyncRegistration> callback_registration_;
-  std::unique_ptr<ScopedVector<BackgroundSyncRegistration>>
+  std::unique_ptr<std::vector<std::unique_ptr<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_));
 }
 
@@ skipping 873 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(blink::mojom::BackgroundSyncEventLastChance::IS_LAST_CHANCE,
             test_background_sync_manager_->last_chance());
 }
 
 }  // namespace content