Convert //google_apis from scoped_ptr to std::unique_ptr

google_apis/gcm/engine/gcm_store_impl.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 "google_apis/gcm/engine/gcm_store_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 167 matching lines @@
   return leveldb::Slice(s.begin(), s.size());
 }
 
 }  // namespace
 
 class GCMStoreImpl::Backend
     : public base::RefCountedThreadSafe<GCMStoreImpl::Backend> {
  public:
   Backend(const base::FilePath& path,
           scoped_refptr<base::SequencedTaskRunner> foreground_runner,
-          scoped_ptr<Encryptor> encryptor);
+          std::unique_ptr<Encryptor> encryptor);
 
   // Blocking implementations of GCMStoreImpl methods.
   void Load(StoreOpenMode open_mode, const LoadCallback& callback);
   void Close();
   void Destroy(const UpdateCallback& callback);
   void SetDeviceCredentials(uint64_t device_android_id,
                             uint64_t device_security_token,
                             const UpdateCallback& callback);
   void AddRegistration(const std::string& serialized_key,
                        const std::string& serialized_value,
@@ skipping 56 matching lines @@
                            std::set<std::string>* accounts);
   bool LoadGServicesSettings(std::map<std::string, std::string>* settings,
                              std::string* digest);
   bool LoadAccountMappingInfo(AccountMappings* account_mappings);
   bool LoadLastTokenFetchTime(base::Time* last_token_fetch_time);
   bool LoadHeartbeatIntervals(std::map<std::string, int>* heartbeat_intervals);
   bool LoadInstanceIDData(std::map<std::string, std::string>* instance_id_data);
 
   const base::FilePath path_;
   scoped_refptr<base::SequencedTaskRunner> foreground_task_runner_;
-  scoped_ptr<Encryptor> encryptor_;
+  std::unique_ptr<Encryptor> encryptor_;
 
-  scoped_ptr<leveldb::DB> db_;
+  std::unique_ptr<leveldb::DB> db_;
 };
 
 GCMStoreImpl::Backend::Backend(
     const base::FilePath& path,
     scoped_refptr<base::SequencedTaskRunner> foreground_task_runner,
-    scoped_ptr<Encryptor> encryptor)
+    std::unique_ptr<Encryptor> encryptor)
     : path_(path),
       foreground_task_runner_(foreground_task_runner),
       encryptor_(std::move(encryptor)) {}
 
 GCMStoreImpl::Backend::~Backend() {}
 
 LoadStatus GCMStoreImpl::Backend::OpenStoreAndLoadData(StoreOpenMode open_mode,
                                                        LoadResult* result) {
   LoadStatus load_status;
   if (db_.get()) {
@@ skipping 50 matching lines @@
   if (!LoadHeartbeatIntervals(&result->heartbeat_intervals))
     return LOADING_HEARTBEAT_INTERVALS_FAILED;
   if (!LoadInstanceIDData(&result->instance_id_data))
     return LOADING_INSTANCE_ID_DATA_FAILED;
 
   return LOADING_SUCCEEDED;
 }
 
 void GCMStoreImpl::Backend::Load(StoreOpenMode open_mode,
                                  const LoadCallback& callback) {
-  scoped_ptr<LoadResult> result(new LoadResult());
+  std::unique_ptr<LoadResult> result(new LoadResult());
   LoadStatus load_status = OpenStoreAndLoadData(open_mode, result.get());
   UMA_HISTOGRAM_ENUMERATION("GCM.LoadStatus", load_status, LOAD_STATUS_COUNT);
   if (load_status != LOADING_SUCCEEDED) {
     result->Reset();
     result->store_does_not_exist = (load_status == STORE_DOES_NOT_EXIST);
     foreground_task_runner_->PostTask(FROM_HERE,
                                       base::Bind(callback,
                                                  base::Passed(&result)));
     return;
   }
@@ skipping 332 matching lines @@
 
 void GCMStoreImpl::Backend::SetGServicesSettings(
     const std::map<std::string, std::string>& settings,
     const std::string& settings_digest,
     const UpdateCallback& callback) {
   leveldb::WriteBatch write_batch;
 
   // Remove all existing settings.
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;
-  scoped_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
+  std::unique_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
   for (iter->Seek(MakeSlice(kGServiceSettingKeyStart));
        iter->Valid() && iter->key().ToString() < kGServiceSettingKeyEnd;
        iter->Next()) {
     write_batch.Delete(iter->key());
   }
 
   // Add the new settings.
   for (std::map<std::string, std::string>::const_iterator iter =
            settings.begin();
        iter != settings.end(); ++iter) {
@@ skipping 224 matching lines @@
 
   LOG(ERROR) << "Error reading credentials from store.";
   return false;
 }
 
 bool GCMStoreImpl::Backend::LoadRegistrations(
     std::map<std::string, std::string>* registrations) {
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;
 
-  scoped_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
+  std::unique_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
   for (iter->Seek(MakeSlice(kRegistrationKeyStart));
        iter->Valid() && iter->key().ToString() < kRegistrationKeyEnd;
        iter->Next()) {
     leveldb::Slice s = iter->value();
     if (s.size() <= 1) {
       LOG(ERROR) << "Error reading registration with key " << s.ToString();
       return false;
     }
     std::string app_id = ParseRegistrationKey(iter->key().ToString());
     DVLOG(1) << "Found registration with app id " << app_id;
     (*registrations)[app_id] = iter->value().ToString();
   }
 
   return true;
 }
 
 bool GCMStoreImpl::Backend::LoadIncomingMessages(
     std::vector<std::string>* incoming_messages) {
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;
 
-  scoped_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
+  std::unique_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
   for (iter->Seek(MakeSlice(kIncomingMsgKeyStart));
        iter->Valid() && iter->key().ToString() < kIncomingMsgKeyEnd;
        iter->Next()) {
     leveldb::Slice s = iter->value();
     if (s.empty()) {
       LOG(ERROR) << "Error reading incoming message with key "
                  << iter->key().ToString();
       return false;
     }
     DVLOG(1) << "Found incoming message with id " << s.ToString();
     incoming_messages->push_back(s.ToString());
   }
 
   return true;
 }
 
 bool GCMStoreImpl::Backend::LoadOutgoingMessages(
     OutgoingMessageMap* outgoing_messages) {
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;
 
-  scoped_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
+  std::unique_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
   for (iter->Seek(MakeSlice(kOutgoingMsgKeyStart));
        iter->Valid() && iter->key().ToString() < kOutgoingMsgKeyEnd;
        iter->Next()) {
     leveldb::Slice s = iter->value();
     if (s.size() <= 1) {
       LOG(ERROR) << "Error reading incoming message with key " << s.ToString();
       return false;
     }
     uint8_t tag = iter->value().data()[0];
     std::string id = ParseOutgoingKey(iter->key().ToString());
-    scoped_ptr<google::protobuf::MessageLite> message(
+    std::unique_ptr<google::protobuf::MessageLite> message(
         BuildProtobufFromTag(tag));
     if (!message.get() ||
         !message->ParseFromString(iter->value().ToString().substr(1))) {
       LOG(ERROR) << "Failed to parse outgoing message with id " << id
                  << " and tag " << tag;
       return false;
     }
     DVLOG(1) << "Found outgoing message with id " << id << " of type "
              << base::UintToString(tag);
     (*outgoing_messages)[id] = make_linked_ptr(message.release());
@@ skipping 34 matching lines @@
   return true;
 }
 
 bool GCMStoreImpl::Backend::LoadGServicesSettings(
     std::map<std::string, std::string>* settings,
     std::string* digest) {
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;
 
   // Load all of the GServices settings.
-  scoped_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
+  std::unique_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
   for (iter->Seek(MakeSlice(kGServiceSettingKeyStart));
        iter->Valid() && iter->key().ToString() < kGServiceSettingKeyEnd;
        iter->Next()) {
     std::string value = iter->value().ToString();
     if (value.empty()) {
       LOG(ERROR) << "Error reading GService Settings " << value;
       return false;
     }
     std::string id = ParseGServiceSettingKey(iter->key().ToString());
     (*settings)[id] = value;
     DVLOG(1) << "Found G Service setting with key: " << id
              << ", and value: " << value;
   }
 
   // Load the settings digest. It's ok if it is empty.
   db_->Get(read_options, MakeSlice(kGServiceSettingsDigestKey), digest);
 
   return true;
 }
 
 bool GCMStoreImpl::Backend::LoadAccountMappingInfo(
     AccountMappings* account_mappings) {
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;
 
-  scoped_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
+  std::unique_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
   for (iter->Seek(MakeSlice(kAccountKeyStart));
        iter->Valid() && iter->key().ToString() < kAccountKeyEnd;
        iter->Next()) {
     AccountMapping account_mapping;
     account_mapping.account_id = ParseAccountKey(iter->key().ToString());
     if (!account_mapping.ParseFromString(iter->value().ToString())) {
       DVLOG(1) << "Failed to parse account info with ID: "
                << account_mapping.account_id;
       return false;
     }
@@ skipping 23 matching lines @@
   *last_token_fetch_time = base::Time::FromInternalValue(time_internal);
 
   return true;
 }
 
 bool GCMStoreImpl::Backend::LoadHeartbeatIntervals(
     std::map<std::string, int>* heartbeat_intervals) {
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;
 
-  scoped_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
+  std::unique_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
   for (iter->Seek(MakeSlice(kHeartbeatKeyStart));
        iter->Valid() && iter->key().ToString() < kHeartbeatKeyEnd;
        iter->Next()) {
     std::string scope = ParseHeartbeatKey(iter->key().ToString());
     int interval_ms;
     if (!base::StringToInt(iter->value().ToString(), &interval_ms)) {
       DVLOG(1) << "Failed to parse heartbeat interval info with scope: "
                << scope;
       return false;
     }
     DVLOG(1) << "Found heartbeat interval with scope: " << scope
              << " interval: " << interval_ms << "ms.";
     (*heartbeat_intervals)[scope] = interval_ms;
   }
 
   return true;
 }
 
 bool GCMStoreImpl::Backend::LoadInstanceIDData(
     std::map<std::string, std::string>* instance_id_data) {
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;
 
-  scoped_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
+  std::unique_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
   for (iter->Seek(MakeSlice(kInstanceIDKeyStart));
        iter->Valid() && iter->key().ToString() < kInstanceIDKeyEnd;
        iter->Next()) {
     leveldb::Slice s = iter->value();
     if (s.size() <= 1) {
       LOG(ERROR) << "Error reading IID data with key " << s.ToString();
       return false;
     }
     std::string app_id = ParseInstanceIDKey(iter->key().ToString());
     DVLOG(1) << "Found IID data with app id " << app_id;
     (*instance_id_data)[app_id] = s.ToString();
   }
 
   return true;
 }
 
 GCMStoreImpl::GCMStoreImpl(
     const base::FilePath& path,
     scoped_refptr<base::SequencedTaskRunner> blocking_task_runner,
-    scoped_ptr<Encryptor> encryptor)
+    std::unique_ptr<Encryptor> encryptor)
     : backend_(new Backend(path,
                            base::ThreadTaskRunnerHandle::Get(),
                            std::move(encryptor))),
       blocking_task_runner_(blocking_task_runner),
       weak_ptr_factory_(this) {}
 
 GCMStoreImpl::~GCMStoreImpl() {}
 
 void GCMStoreImpl::Load(StoreOpenMode open_mode, const LoadCallback& callback) {
   blocking_task_runner_->PostTask(
@@ skipping 240 matching lines @@
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMStoreImpl::Backend::SetValue,
                  backend_,
                  key,
                  value,
                  callback));
 }
 
 void GCMStoreImpl::LoadContinuation(const LoadCallback& callback,
-                                    scoped_ptr<LoadResult> result) {
+                                    std::unique_ptr<LoadResult> result) {
   // TODO(pkasting): Remove ScopedTracker below once crbug.com/477117 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "477117 GCMStoreImpl::LoadContinuation"));
   if (!result->success) {
     callback.Run(std::move(result));
     return;
   }
   int num_throttled_apps = 0;
   for (OutgoingMessageMap::const_iterator
@@ skipping 36 matching lines @@
            removed_message_counts.begin();
        iter != removed_message_counts.end(); ++iter) {
     DCHECK_NE(app_message_counts_.count(iter->first), 0U);
     app_message_counts_[iter->first] -= iter->second;
     DCHECK_GE(app_message_counts_[iter->first], 0);
   }
   callback.Run(true);
 }
 
 }  // namespace gcm