Convert //sync from scoped_ptr to std::unique_ptr

sync/test/fake_server/fake_server.cc

 // Copyright 2014 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 "sync/test/fake_server/fake_server.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
+#include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/guid.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_status_code.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/test/fake_server/bookmark_entity.h"
@@ skipping 31 matching lines @@
 static const char kSyncedBookmarksFolderName[] = "Synced Bookmarks";
 
 // A filter used during GetUpdates calls to determine what information to
 // send back to the client. There is a 1:1 correspondence between any given
 // GetUpdates call and an UpdateSieve instance.
 class UpdateSieve {
  public:
   ~UpdateSieve() { }
 
   // Factory method for creating an UpdateSieve.
-  static scoped_ptr<UpdateSieve> Create(
+  static std::unique_ptr<UpdateSieve> Create(
       const sync_pb::GetUpdatesMessage& get_updates_message);
 
   // Sets the progress markers in |get_updates_response| given the progress
   // markers from the original GetUpdatesMessage and |new_version| (the latest
   // version in the entries sent back).
   void UpdateProgressMarkers(
       int64_t new_version,
       sync_pb::GetUpdatesResponse* get_updates_response) const {
     ModelTypeToVersionMap::const_iterator it;
     for (it = request_from_version_.begin(); it != request_from_version_.end();
@@ skipping 36 matching lines @@
       : request_from_version_(request_from_version),
         min_version_(min_version) {}
 
   // Maps data type IDs to the latest version seen for that type.
   const ModelTypeToVersionMap request_from_version_;
 
   // The minimum version seen among all data types.
   const int min_version_;
 };
 
-scoped_ptr<UpdateSieve> UpdateSieve::Create(
+std::unique_ptr<UpdateSieve> UpdateSieve::Create(
     const sync_pb::GetUpdatesMessage& get_updates_message) {
   CHECK_GT(get_updates_message.from_progress_marker_size(), 0)
       << "A GetUpdates request must have at least one progress marker.";
 
   UpdateSieve::ModelTypeToVersionMap request_from_version;
   int64_t min_version = std::numeric_limits<int64_t>::max();
   for (int i = 0; i < get_updates_message.from_progress_marker_size(); i++) {
     sync_pb::DataTypeProgressMarker marker =
         get_updates_message.from_progress_marker(i);
 
     int64_t version = 0;
     // Let the version remain zero if there is no token or an empty token (the
     // first request for this type).
     if (marker.has_token() && !marker.token().empty()) {
       bool parsed = base::StringToInt64(marker.token(), &version);
       CHECK(parsed) << "Unable to parse progress marker token.";
     }
 
     ModelType model_type = syncer::GetModelTypeFromSpecificsFieldNumber(
         marker.data_type_id());
     request_from_version[model_type] = version;
 
     if (version < min_version)
       min_version = version;
   }
 
-  return scoped_ptr<UpdateSieve>(
+  return std::unique_ptr<UpdateSieve>(
       new UpdateSieve(request_from_version, min_version));
 }
 
 // Returns whether |entity| is deleted or permanent.
 bool IsDeletedOrPermanent(const FakeServerEntity& entity) {
   return entity.IsDeleted() || entity.IsPermanent();
 }
 
 }  // namespace
 
@@ skipping 13 matching lines @@
 void FakeServer::Init() {
   keystore_keys_.push_back(kDefaultKeystoreKey);
 
   const bool create_result = CreateDefaultPermanentItems();
   DCHECK(create_result) << "Permanent items were not created successfully.";
 }
 
 bool FakeServer::CreatePermanentBookmarkFolder(const std::string& server_tag,
                                                const std::string& name) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  scoped_ptr<FakeServerEntity> entity =
+  std::unique_ptr<FakeServerEntity> entity =
       PermanentEntity::Create(syncer::BOOKMARKS, server_tag, name,
                               ModelTypeToRootTag(syncer::BOOKMARKS));
   if (!entity)
     return false;
 
   SaveEntity(std::move(entity));
   return true;
 }
 
 bool FakeServer::CreateDefaultPermanentItems() {
   // Permanent folders are always required for Bookmarks (hierarchical
   // structure) and Nigori (data stored in permanent root folder).
   ModelTypeSet permanent_folder_types =
       ModelTypeSet(syncer::BOOKMARKS, syncer::NIGORI);
 
   for (ModelTypeSet::Iterator it = permanent_folder_types.First(); it.Good();
        it.Inc()) {
     ModelType model_type = it.Get();
 
-    scoped_ptr<FakeServerEntity> top_level_entity =
+    std::unique_ptr<FakeServerEntity> top_level_entity =
         PermanentEntity::CreateTopLevel(model_type);
     if (!top_level_entity) {
       return false;
     }
     SaveEntity(std::move(top_level_entity));
 
     if (model_type == syncer::BOOKMARKS) {
       if (!CreatePermanentBookmarkFolder(kBookmarkBarFolderServerTag,
                                          kBookmarkBarFolderName))
         return false;
       if (!CreatePermanentBookmarkFolder(kOtherBookmarksFolderServerTag,
                                          kOtherBookmarksFolderName))
         return false;
     }
   }
 
   return true;
 }
 
 void FakeServer::UpdateEntityVersion(FakeServerEntity* entity) {
   entity->SetVersion(++version_);
 }
 
-void FakeServer::SaveEntity(scoped_ptr<FakeServerEntity> entity) {
+void FakeServer::SaveEntity(std::unique_ptr<FakeServerEntity> entity) {
   UpdateEntityVersion(entity.get());
   entities_[entity->GetId()] = std::move(entity);
 }
 
 void FakeServer::HandleCommand(const string& request,
                                const base::Closure& completion_closure,
                                int* error_code,
                                int* response_code,
                                std::string* response) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 96 matching lines @@
   return true;
 }
 
 bool FakeServer::HandleGetUpdatesRequest(
     const sync_pb::GetUpdatesMessage& get_updates,
     sync_pb::GetUpdatesResponse* response) {
   // TODO(pvalenzuela): Implement batching instead of sending all information
   // at once.
   response->set_changes_remaining(0);
 
-  scoped_ptr<UpdateSieve> sieve = UpdateSieve::Create(get_updates);
+  std::unique_ptr<UpdateSieve> sieve = UpdateSieve::Create(get_updates);
 
   // This folder is called "Synced Bookmarks" by sync and is renamed
   // "Mobile Bookmarks" by the mobile client UIs.
   if (get_updates.create_mobile_bookmarks_folder() &&
       !CreatePermanentBookmarkFolder(kSyncedBookmarksFolderServerTag,
                                      kSyncedBookmarksFolderName)) {
     return false;
   }
 
   bool send_encryption_keys_based_on_nigori = false;
@@ skipping 30 matching lines @@
 
 string FakeServer::CommitEntity(
     const sync_pb::SyncEntity& client_entity,
     sync_pb::CommitResponse_EntryResponse* entry_response,
     const string& client_guid,
     const string& parent_id) {
   if (client_entity.version() == 0 && client_entity.deleted()) {
     return string();
   }
 
-  scoped_ptr<FakeServerEntity> entity;
+  std::unique_ptr<FakeServerEntity> entity;
   if (client_entity.deleted()) {
     entity = TombstoneEntity::Create(client_entity.id_string());
     DeleteChildren(client_entity.id_string());
   } else if (GetModelType(client_entity) == syncer::NIGORI) {
     // NIGORI is the only permanent item type that should be updated by the
     // client.
     EntityMap::const_iterator iter = entities_.find(client_entity.id_string());
     CHECK(iter != entities_.end());
     entity = PermanentEntity::CreateUpdatedNigoriEntity(client_entity,
                                                         *iter->second);
@@ skipping 103 matching lines @@
     EntityMap::const_iterator iter = entities_.find(entity_id);
     CHECK(iter != entities_.end());
     committed_model_types.Put(iter->second->GetModelType());
   }
 
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnCommit(invalidator_client_id, committed_model_types));
   return true;
 }
 
-scoped_ptr<base::DictionaryValue> FakeServer::GetEntitiesAsDictionaryValue() {
+std::unique_ptr<base::DictionaryValue>
+FakeServer::GetEntitiesAsDictionaryValue() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  scoped_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> dictionary(
+      new base::DictionaryValue());
 
   // Initialize an empty ListValue for all ModelTypes.
   ModelTypeSet all_types = ModelTypeSet::All();
   for (ModelTypeSet::Iterator it = all_types.First(); it.Good(); it.Inc()) {
     dictionary->Set(ModelTypeToString(it.Get()), new base::ListValue());
   }
 
   for (EntityMap::const_iterator it = entities_.begin(); it != entities_.end();
        ++it) {
     const FakeServerEntity& entity = *it->second;
     if (IsDeletedOrPermanent(entity)) {
       // Tombstones are ignored as they don't represent current data. Folders
       // are also ignored as current verification infrastructure does not
       // consider them.
       continue;
     }
     base::ListValue* list_value;
     if (!dictionary->GetList(ModelTypeToString(entity.GetModelType()),
                              &list_value)) {
-      return scoped_ptr<base::DictionaryValue>();
+      return std::unique_ptr<base::DictionaryValue>();
     }
     // TODO(pvalenzuela): Store more data for each entity so additional
     // verification can be performed. One example of additional verification
     // is checking the correctness of the bookmark hierarchy.
     list_value->Append(new base::StringValue(entity.GetName()));
   }
 
   return dictionary;
 }
 
 std::vector<sync_pb::SyncEntity> FakeServer::GetSyncEntitiesByModelType(
     ModelType model_type) {
   std::vector<sync_pb::SyncEntity> sync_entities;
   DCHECK(thread_checker_.CalledOnValidThread());
   for (EntityMap::const_iterator it = entities_.begin(); it != entities_.end();
        ++it) {
     const FakeServerEntity& entity = *it->second;
     if (!IsDeletedOrPermanent(entity) && entity.GetModelType() == model_type) {
       sync_pb::SyncEntity sync_entity;
       entity.SerializeAsProto(&sync_entity);
       sync_entities.push_back(sync_entity);
     }
   }
   return sync_entities;
 }
 
-void FakeServer::InjectEntity(scoped_ptr<FakeServerEntity> entity) {
+void FakeServer::InjectEntity(std::unique_ptr<FakeServerEntity> entity) {
   DCHECK(thread_checker_.CalledOnValidThread());
   SaveEntity(std::move(entity));
 }
 
 bool FakeServer::ModifyEntitySpecifics(
     const std::string& id,
     const sync_pb::EntitySpecifics& updated_specifics) {
   EntityMap::const_iterator iter = entities_.find(id);
   if (iter == entities_.end() ||
       iter->second->GetModelType() !=
@@ skipping 141 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 std::string FakeServer::GetStoreBirthday() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return base::Int64ToString(store_birthday_);
 }
 
 }  // namespace fake_server