Remove stl_util's STLElementDeleter from sync.

components/browser_sync/browser/profile_sync_service.cc

 // Copyright (c) 2012 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/browser_sync/browser/profile_sync_service.h"
 
 #include <stddef.h>
 
 #include <cstddef>
 #include <map>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/feature_list.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
@@ skipping 2161 matching lines @@
 
 class GetAllNodesRequestHelper
     : public base::RefCountedThreadSafe<GetAllNodesRequestHelper> {
  public:
   GetAllNodesRequestHelper(
       syncer::ModelTypeSet requested_types,
       const base::Callback<void(std::unique_ptr<base::ListValue>)>& callback);
 
   void OnReceivedNodesForTypes(
       const std::vector<syncer::ModelType>& types,
-      ScopedVector<base::ListValue> scoped_node_lists);
+      std::vector<std::unique_ptr<base::ListValue>> scoped_node_lists);
 
  private:
   friend class base::RefCountedThreadSafe<GetAllNodesRequestHelper>;
   virtual ~GetAllNodesRequestHelper();
 
   std::unique_ptr<base::ListValue> result_accumulator_;
 
   syncer::ModelTypeSet awaiting_types_;
   base::Callback<void(std::unique_ptr<base::ListValue>)> callback_;
 };
@@ skipping 10 matching lines @@
     DLOG(WARNING)
         << "GetAllNodesRequest deleted before request was fulfilled.  "
         << "Missing types are: " << ModelTypeSetToString(awaiting_types_);
   }
 }
 
 // Called when the set of nodes for a type or set of types has been returned.
 //
 // The nodes for several types can be returned at the same time by specifying
 // their types in the |types| array, and putting their results at the
-// correspnding indices in the |scoped_node_lists|.
+// corresponding indices in the |node_lists|.
 void GetAllNodesRequestHelper::OnReceivedNodesForTypes(
     const std::vector<syncer::ModelType>& types,
-    ScopedVector<base::ListValue> scoped_node_lists) {
-  DCHECK_EQ(types.size(), scoped_node_lists.size());
-
-  // Take unsafe ownership of the node list.
-  std::vector<base::ListValue*> node_lists;
-  scoped_node_lists.release(&node_lists);
+    std::vector<std::unique_ptr<base::ListValue>> node_lists) {
+  DCHECK_EQ(types.size(), node_lists.size());
 
   for (size_t i = 0; i < node_lists.size() && i < types.size(); ++i) {
     const ModelType type = types[i];
-    base::ListValue* node_list = node_lists[i];
+    std::unique_ptr<base::Value> node_list = std::move(node_lists[i]);
 
     // Add these results to our list.
     std::unique_ptr<base::DictionaryValue> type_dict(
         new base::DictionaryValue());
     type_dict->SetString("type", ModelTypeToString(type));
-    type_dict->Set("nodes", node_list);
+    type_dict->Set("nodes", std::move(node_list));
     result_accumulator_->Append(std::move(type_dict));
 
     // Remember that this part of the request is satisfied.
     awaiting_types_.Remove(type);
   }
 
   if (awaiting_types_.Empty()) {
     callback_.Run(std::move(result_accumulator_));
     callback_.Reset();
   }
 }
 
 }  // namespace
 
 void ProfileSyncService::GetAllNodes(
     const base::Callback<void(std::unique_ptr<base::ListValue>)>& callback) {
   // TODO(stanisc): crbug.com/328606: Make this work for USS datatypes.
   ModelTypeSet all_types = GetRegisteredDataTypes();
   all_types.PutAll(syncer::ControlTypes());
   scoped_refptr<GetAllNodesRequestHelper> helper =
       new GetAllNodesRequestHelper(all_types, callback);
 
   if (!backend_initialized_) {
     // If there's no backend available to fulfill the request, handle it here.
-    ScopedVector<base::ListValue> empty_results;
+    std::vector<std::unique_ptr<base::ListValue>> empty_results;
     std::vector<ModelType> type_vector;
     for (ModelTypeSet::Iterator it = all_types.First(); it.Good(); it.Inc()) {
       type_vector.push_back(it.Get());
-      empty_results.push_back(new base::ListValue());
+      empty_results.push_back(base::MakeUnique<base::ListValue>());
     }
     helper->OnReceivedNodesForTypes(type_vector, std::move(empty_results));
   } else {
     backend_->GetAllNodesForTypes(
         all_types,
         base::Bind(&GetAllNodesRequestHelper::OnReceivedNodesForTypes, helper));
   }
 }
 
 bool ProfileSyncService::HasObserver(
@@ skipping 240 matching lines @@
   if (--outstanding_setup_in_progress_handles_ != 0)
     return;
 
   DCHECK(startup_controller_->IsSetupInProgress());
   startup_controller_->SetSetupInProgress(false);
 
   if (IsBackendInitialized())
     ReconfigureDatatypeManager();
   NotifyObservers();
 }