Remove most ScopedVector usage from c/b/extensions.

chrome/browser/extensions/api/storage/syncable_settings_storage.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 "chrome/browser/extensions/api/storage/syncable_settings_storage.h"
 
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/extensions/api/storage/settings_sync_processor.h"
 #include "chrome/browser/extensions/api/storage/settings_sync_util.h"
 #include "components/sync/api/sync_data.h"
 #include "components/sync/protocol/extension_setting_specifics.pb.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/api/storage/settings_namespace.h"
 
 using content::BrowserThread;
 
@@ skipping 193 matching lines @@
   std::unique_ptr<SettingSyncDataList> changes(new SettingSyncDataList());
 
   for (base::DictionaryValue::Iterator it(*local_state); !it.IsAtEnd();
        it.Advance()) {
     std::unique_ptr<base::Value> sync_value;
     if (sync_state->RemoveWithoutPathExpansion(it.key(), &sync_value)) {
       if (sync_value->Equals(&it.value())) {
         // Sync and local values are the same, no changes to send.
       } else {
         // Sync value is different, update local setting with new value.
-        changes->push_back(new SettingSyncData(
+        changes->push_back(base::MakeUnique<SettingSyncData>(
             syncer::SyncChange::ACTION_UPDATE, extension_id_, it.key(),
             std::move(sync_value)));
       }
     } else {
       // Not synced, delete local setting.
-      changes->push_back(new SettingSyncData(
+      changes->push_back(base::MakeUnique<SettingSyncData>(
           syncer::SyncChange::ACTION_DELETE, extension_id_, it.key(),
           std::unique_ptr<base::Value>(new base::DictionaryValue())));
     }
   }
 
   // Add all new settings to local settings.
   while (!sync_state->empty()) {
     // It's not possible to iterate over a DictionaryValue and modify it at the
     // same time, so hack around that restriction.
     std::string key = base::DictionaryValue::Iterator(*sync_state).key();
     std::unique_ptr<base::Value> value;
     CHECK(sync_state->RemoveWithoutPathExpansion(key, &value));
-    changes->push_back(new SettingSyncData(
+    changes->push_back(base::MakeUnique<SettingSyncData>(
         syncer::SyncChange::ACTION_ADD, extension_id_, key, std::move(value)));
   }
 
   if (changes->empty())
     return syncer::SyncError();
   return ProcessSyncChanges(std::move(changes));
 }
 
 void SyncableSettingsStorage::StopSyncing() {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   sync_processor_.reset();
 }
 
 syncer::SyncError SyncableSettingsStorage::ProcessSyncChanges(
     std::unique_ptr<SettingSyncDataList> sync_changes) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DCHECK(!sync_changes->empty()) << "No sync changes for " << extension_id_;
 
   if (!sync_processor_.get()) {
     return syncer::SyncError(
         FROM_HERE,
         syncer::SyncError::DATATYPE_ERROR,
         std::string("Sync is inactive for ") + extension_id_,
         syncer::UNSPECIFIED);
   }
 
   std::vector<syncer::SyncError> errors;
   ValueStoreChangeList changes;
 
-  for (SettingSyncDataList::iterator it = sync_changes->begin();
-       it != sync_changes->end(); ++it) {
-    DCHECK_EQ(extension_id_, (*it)->extension_id());
-    const std::string& key = (*it)->key();
-    std::unique_ptr<base::Value> change_value = (*it)->PassValue();
+  for (const std::unique_ptr<SettingSyncData>& sync_change : *sync_changes) {
+    DCHECK_EQ(extension_id_, sync_change->extension_id());
+    const std::string& key = sync_change->key();
+    std::unique_ptr<base::Value> change_value = sync_change->PassValue();
 
     std::unique_ptr<base::Value> current_value;
     {
       ReadResult maybe_settings = Get(key);
       if (!maybe_settings->status().ok()) {
         errors.push_back(syncer::SyncError(
             FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
             base::StringPrintf("Error getting current sync state for %s/%s: %s",
                                extension_id_.c_str(), key.c_str(),
                                maybe_settings->status().message.c_str()),
             sync_processor_->type()));
         continue;
       }
       maybe_settings->settings().RemoveWithoutPathExpansion(key,
                                                             &current_value);
     }
 
     syncer::SyncError error;
 
-    switch ((*it)->change_type()) {
+    switch (sync_change->change_type()) {
       case syncer::SyncChange::ACTION_ADD:
         if (!current_value.get()) {
           error = OnSyncAdd(key, std::move(change_value), &changes);
         } else {
           // Already a value; hopefully a local change has beaten sync in a
           // race and change's not a bug, so pretend change's an update.
           LOG(WARNING) << "Got add from sync for existing setting " <<
               extension_id_ << "/" << key;
           error = OnSyncUpdate(key, std::move(current_value),
                                std::move(change_value), &changes);
@@ skipping 91 matching lines @@
         FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
         base::StringPrintf("Error pushing sync remove to local settings: %s",
                            result->status().message.c_str()),
         sync_processor_->type());
   }
   changes->push_back(ValueStoreChange(key, std::move(old_value), nullptr));
   return syncer::SyncError();
 }
 
 }  // namespace extensions