Remove most ScopedVector usage from c/b/extensions.

chrome/browser/extensions/api/storage/settings_sync_unittest.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 <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
-#include "base/memory/linked_ptr.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/api/storage/settings_sync_util.h"
 #include "chrome/browser/extensions/api/storage/sync_value_store_cache.h"
 #include "chrome/browser/extensions/api/storage/syncable_settings_storage.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/sync/api/sync_change_processor.h"
@@ skipping 22 matching lines @@
 namespace util = settings_test_util;
 
 namespace {
 
 // To save typing ValueStore::DEFAULTS everywhere.
 const ValueStore::WriteOptions DEFAULTS = ValueStore::DEFAULTS;
 
 // More saving typing. Maps extension IDs to a list of sync changes for that
 // extension.
 using SettingSyncDataMultimap =
-    std::map<std::string, linked_ptr<SettingSyncDataList>>;
+    std::map<std::string, std::unique_ptr<SettingSyncDataList>>;
 
 // Gets the pretty-printed JSON for a value.
 static std::string GetJson(const base::Value& value) {
   std::string json;
   base::JSONWriter::WriteWithOptions(
       value, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
   return json;
 }
 
 // Returns whether two Values are equal.
@@ skipping 45 matching lines @@
       const syncer::SyncChangeList& change_list) override {
     if (fail_all_requests_) {
       return syncer::SyncError(
           FROM_HERE,
           syncer::SyncError::DATATYPE_ERROR,
           "MockSyncChangeProcessor: configured to fail",
           change_list[0].sync_data().GetDataType());
     }
     for (syncer::SyncChangeList::const_iterator it = change_list.begin();
         it != change_list.end(); ++it) {
-      changes_.push_back(new SettingSyncData(*it));
+      changes_.push_back(base::MakeUnique<SettingSyncData>(*it));
     }
     return syncer::SyncError();
   }
 
   syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const override {
     return syncer::SyncDataList();
   }
 
   // Mock methods.
 
   const SettingSyncDataList& changes() { return changes_; }
 
   void ClearChanges() {
     changes_.clear();
   }
 
   void set_fail_all_requests(bool fail_all_requests) {
     fail_all_requests_ = fail_all_requests;
   }
 
   // Returns the only change for a given extension setting.  If there is not
   // exactly 1 change for that key, a test assertion will fail.
   SettingSyncData* GetOnlyChange(const std::string& extension_id,
                                  const std::string& key) {
     std::vector<SettingSyncData*> matching_changes;
-    for (SettingSyncDataList::iterator it = changes_.begin();
-        it != changes_.end(); ++it) {
-      if ((*it)->extension_id() == extension_id && (*it)->key() == key) {
-        matching_changes.push_back(*it);
-      }
+    for (const std::unique_ptr<SettingSyncData>& change : changes_) {
+      if (change->extension_id() == extension_id && change->key() == key)
+        matching_changes.push_back(change.get());
     }
     if (matching_changes.empty()) {
       ADD_FAILURE() << "No matching changes for " << extension_id << "/" <<
           key << " (out of " << changes_.size() << ")";
       return nullptr;
     }
     if (matching_changes.size() != 1u) {
       ADD_FAILURE() << matching_changes.size() << " matching changes for " <<
            extension_id << "/" << key << " (out of " << changes_.size() << ")";
     }
@@ skipping 69 matching lines @@
   }
 
   // Gets all the sync data from the SyncableService for a sync type as a map
   // from extension id to its sync data.
   SettingSyncDataMultimap GetAllSyncData(syncer::ModelType model_type) {
     syncer::SyncDataList as_list =
         GetSyncableService(model_type)->GetAllSyncData(model_type);
     SettingSyncDataMultimap as_map;
     for (syncer::SyncDataList::iterator it = as_list.begin();
         it != as_list.end(); ++it) {
-      SettingSyncData* sync_data = new SettingSyncData(*it);
-      linked_ptr<SettingSyncDataList>& list_for_extension =
+      std::unique_ptr<SettingSyncData> sync_data(new SettingSyncData(*it));
+      std::unique_ptr<SettingSyncDataList>& list_for_extension =
           as_map[sync_data->extension_id()];
-      if (!list_for_extension.get())
+      if (!list_for_extension)
         list_for_extension.reset(new SettingSyncDataList());
-      list_for_extension->push_back(sync_data);
+      list_for_extension->push_back(std::move(sync_data));
     }
     return as_map;
   }
 
   // This class uses it's TestingValueStore in such a way that it always mints
   // new TestingValueStore instances.
   TestingValueStore* GetExisting(const ExtensionId& extension_id) {
     return static_cast<TestingValueStore*>(
         storage_factory_->GetExisting(extension_id));
   }
@@ skipping 1084 matching lines @@
         new base::StringValue("value"));
     EXPECT_TRUE(base::Value::Equals(&expected_data, &data->settings()));
   }
 
   // Test dots in keys going to sync.
   {
     std::unique_ptr<base::Value> string_value(new base::StringValue("spot"));
     storage->Set(DEFAULTS, "key.with.spot", *string_value);
 
     ASSERT_EQ(1u, sync_processor_->changes().size());
-    SettingSyncData* sync_data = sync_processor_->changes()[0];
+    SettingSyncData* sync_data = sync_processor_->changes()[0].get();
     EXPECT_EQ(syncer::SyncChange::ACTION_ADD, sync_data->change_type());
     EXPECT_EQ("ext", sync_data->extension_id());
     EXPECT_EQ("key.with.spot", sync_data->key());
     EXPECT_TRUE(sync_data->value().Equals(string_value.get()));
   }
 }
 
 // In other (frontend) tests, we assume that the result of GetStorage
 // is a pointer to the a Storage owned by a Frontend object, but for
 // the unlimitedStorage case, this might not be true. So, write the
@@ skipping 47 matching lines @@
                             settings_namespace::SYNC,
                             base::Bind(&UnlimitedSyncStorageTestCallback));
   frontend_->RunWithStorage(extension,
                             settings_namespace::LOCAL,
                             base::Bind(&UnlimitedLocalStorageTestCallback));
 
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace extensions