Remove ScopedVector from content/browser/.

content/browser/background_sync/background_sync_manager.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 <utility>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
@@ skipping 198 matching lines @@
 void BackgroundSyncManager::GetRegistrations(
     int64_t sw_registration_id,
     const StatusAndRegistrationsCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (disabled_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(
             callback, BACKGROUND_SYNC_STATUS_STORAGE_ERROR,
-            base::Passed(
-                std::unique_ptr<ScopedVector<BackgroundSyncRegistration>>(
-                    new ScopedVector<BackgroundSyncRegistration>()))));
+            base::Passed(base::MakeUnique<std::vector<
+                             std::unique_ptr<BackgroundSyncRegistration>>>())));
     return;
   }
 
   op_scheduler_.ScheduleOperation(
       base::Bind(&BackgroundSyncManager::GetRegistrationsImpl,
                  weak_ptr_factory_.GetWeakPtr(), sw_registration_id,
                  op_scheduler_.WrapCallbackToRunNext(callback)));
 }
 
 void BackgroundSyncManager::OnRegistrationDeleted(int64_t sw_registration_id,
@@ skipping 550 matching lines @@
     const GURL& origin,
     const BoolCallback& callback) {
   service_worker_context_->HasMainFrameProviderHost(origin, callback);
 }
 
 void BackgroundSyncManager::GetRegistrationsImpl(
     int64_t sw_registration_id,
     const StatusAndRegistrationsCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  std::unique_ptr<ScopedVector<BackgroundSyncRegistration>> out_registrations(
-      new ScopedVector<BackgroundSyncRegistration>());
+  auto out_registrations = base::MakeUnique<
+      std::vector<std::unique_ptr<BackgroundSyncRegistration>>>();
 
   if (disabled_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, BACKGROUND_SYNC_STATUS_STORAGE_ERROR,
-                              base::Passed(std::move(out_registrations))));
+                              base::Passed(&out_registrations)));
     return;
   }
 
   SWIdToRegistrationsMap::iterator it =
       active_registrations_.find(sw_registration_id);
 
   if (it != active_registrations_.end()) {
     const BackgroundSyncRegistrations& registrations = it->second;
     for (const auto& tag_and_registration : registrations.registration_map) {
       const BackgroundSyncRegistration& registration =
           tag_and_registration.second;
-      BackgroundSyncRegistration* out_registration =
-          new BackgroundSyncRegistration(registration);
-      out_registrations->push_back(out_registration);
+      out_registrations->push_back(
+          base::MakeUnique<BackgroundSyncRegistration>(registration));
     }
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, BACKGROUND_SYNC_STATUS_OK,
-                            base::Passed(std::move(out_registrations))));
+                            base::Passed(&out_registrations)));
 }
 
 bool BackgroundSyncManager::AreOptionConditionsMet(
     const BackgroundSyncRegistrationOptions& options) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return network_observer_->NetworkSufficient(options.network_state);
 }
 
 bool BackgroundSyncManager::IsRegistrationReadyToFire(
     const BackgroundSyncRegistration& registration) {
@@ skipping 341 matching lines @@
   parameters_->max_sync_attempts = max_attempts;
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
 }
 
 base::Closure BackgroundSyncManager::MakeEmptyCompletion() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return op_scheduler_.WrapCallbackToRunNext(base::Bind(&base::DoNothing));
 }
 
 }  // namespace content