Remove stl_util's STLElementDeleter from sync.

components/sync/driver/glue/sync_backend_host_core.cc

 // Copyright 2013 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 "components/sync/driver/glue/sync_backend_host_core.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #include "components/invalidation/public/invalidation_util.h"
 #include "components/invalidation/public/object_id_invalidation_map.h"
 #include "components/sync/core/http_post_provider_factory.h"
 #include "components/sync/core/internal_components_factory.h"
 #include "components/sync/core/sync_manager.h"
 #include "components/sync/core/sync_manager_factory.h"
 #include "components/sync/device_info/local_device_info_provider_impl.h"
 #include "components/sync/driver/glue/sync_backend_registrar.h"
@@ skipping 300 matching lines @@
 }
 
 void SyncBackendHostCore::OnMigrationRequested(syncer::ModelTypeSet types) {
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   host_.Call(FROM_HERE,
              &SyncBackendHostImpl::HandleMigrationRequestedOnFrontendLoop,
              types);
 }
 
 void SyncBackendHostCore::OnProtocolEvent(const syncer::ProtocolEvent& event) {
-  // TODO(rlarocque): Find a way to pass event_clone as a scoped_ptr.
   if (forward_protocol_events_) {
     std::unique_ptr<syncer::ProtocolEvent> event_clone(event.Clone());
     host_.Call(FROM_HERE,
                &SyncBackendHostImpl::HandleProtocolEventOnFrontendLoop,
-               event_clone.release());
+               base::Passed(std::move(event_clone)));
   }
 }
 
 void SyncBackendHostCore::DoOnInvalidatorStateChange(
     syncer::InvalidatorState state) {
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   sync_manager_->SetInvalidatorEnabled(state == syncer::INVALIDATIONS_ENABLED);
 }
 
 void SyncBackendHostCore::DoOnIncomingInvalidation(
@@ skipping 261 matching lines @@
              retry_callback);
 }
 
 void SyncBackendHostCore::SendBufferedProtocolEventsAndEnableForwarding() {
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   forward_protocol_events_ = true;
 
   if (sync_manager_) {
     // Grab our own copy of the buffered events.
     // The buffer is not modified by this operation.
-    std::vector<syncer::ProtocolEvent*> buffered_events;
-    sync_manager_->GetBufferedProtocolEvents().release(&buffered_events);
+    std::vector<std::unique_ptr<syncer::ProtocolEvent>> buffered_events =
+        sync_manager_->GetBufferedProtocolEvents();
 
     // Send them all over the fence to the host.
-    for (std::vector<syncer::ProtocolEvent*>::iterator it =
-             buffered_events.begin();
-         it != buffered_events.end(); ++it) {
-      // TODO(rlarocque): Make it explicit that host_ takes ownership.
+    for (auto& event : buffered_events) {
       host_.Call(FROM_HERE,
-                 &SyncBackendHostImpl::HandleProtocolEventOnFrontendLoop, *it);
+                 &SyncBackendHostImpl::HandleProtocolEventOnFrontendLoop,
+                 base::Passed(std::move(event)));
     }
   }
 }
 
 void SyncBackendHostCore::DisableProtocolEventForwarding() {
   forward_protocol_events_ = false;
 }
 
 void SyncBackendHostCore::EnableDirectoryTypeDebugInfoForwarding() {
   DCHECK(sync_manager_);
@@ skipping 22 matching lines @@
   if (base::DirectoryExists(sync_data_folder_path_)) {
     if (!base::DeleteFile(sync_data_folder_path_, true))
       SLOG(DFATAL) << "Could not delete the Sync Data folder.";
   }
 }
 
 void SyncBackendHostCore::GetAllNodesForTypes(
     syncer::ModelTypeSet types,
     scoped_refptr<base::SequencedTaskRunner> task_runner,
     base::Callback<void(const std::vector<syncer::ModelType>& type,
-                        ScopedVector<base::ListValue>)> callback) {
+                        std::vector<std::unique_ptr<base::ListValue>>)>
+        callback) {
   std::vector<syncer::ModelType> types_vector;
-  ScopedVector<base::ListValue> node_lists;
+  std::vector<std::unique_ptr<base::ListValue>> node_lists;
 
   syncer::ModelSafeRoutingInfo routes;
   registrar_->GetModelSafeRoutingInfo(&routes);
   syncer::ModelTypeSet enabled_types = GetRoutingInfoTypes(routes);
 
   for (syncer::ModelTypeSet::Iterator it = types.First(); it.Good(); it.Inc()) {
     types_vector.push_back(it.Get());
     if (!enabled_types.Has(it.Get())) {
-      node_lists.push_back(new base::ListValue());
+      node_lists.push_back(base::MakeUnique<base::ListValue>());
     } else {
-      node_lists.push_back(
-          sync_manager_->GetAllNodesForType(it.Get()).release());
+      node_lists.push_back(sync_manager_->GetAllNodesForType(it.Get()));
     }
   }
 
   task_runner->PostTask(
       FROM_HERE, base::Bind(callback, types_vector, base::Passed(&node_lists)));
 }
 
 void SyncBackendHostCore::StartSavingChanges() {
   // We may already be shut down.
   if (!sync_loop_)
@@ skipping 27 matching lines @@
 }
 
 void SyncBackendHostCore::ClearServerDataDone(
     const base::Closure& frontend_callback) {
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   host_.Call(FROM_HERE, &SyncBackendHostImpl::ClearServerDataDoneOnFrontendLoop,
              frontend_callback);
 }
 
 }  // namespace browser_sync