Convert //components/[f-n]* from scoped_ptr to std::unique_ptr

components/filesystem/public/cpp/prefs/filesystem_json_pref_store.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/filesystem/public/cpp/prefs/filesystem_json_pref_store.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 15 matching lines @@
 #include "mojo/common/common_type_converters.h"
 
 namespace filesystem {
 
 // Result returned from internal read tasks.
 struct FilesystemJsonPrefStore::ReadResult {
  public:
   ReadResult();
   ~ReadResult();
 
-  scoped_ptr<base::Value> value;
+  std::unique_ptr<base::Value> value;
   PrefReadError error;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ReadResult);
 };
 
 FilesystemJsonPrefStore::ReadResult::ReadResult()
     : error(PersistentPrefStore::PREF_READ_ERROR_NONE) {}
 
 FilesystemJsonPrefStore::ReadResult::~ReadResult() {}
 
 namespace {
 
 PersistentPrefStore::PrefReadError HandleReadErrors(const base::Value* value) {
   if (!value->IsType(base::Value::TYPE_DICTIONARY))
     return PersistentPrefStore::PREF_READ_ERROR_JSON_TYPE;
   return PersistentPrefStore::PREF_READ_ERROR_NONE;
 }
 
 }  // namespace
 
 FilesystemJsonPrefStore::FilesystemJsonPrefStore(
     const std::string& pref_filename,
     filesystem::FileSystemPtr filesystem,
-    scoped_ptr<PrefFilter> pref_filter)
+    std::unique_ptr<PrefFilter> pref_filter)
     : path_(pref_filename),
       binding_(this),
       filesystem_(std::move(filesystem)),
       prefs_(new base::DictionaryValue()),
       read_only_(false),
       pref_filter_(std::move(pref_filter)),
       initialized_(false),
       filtering_in_progress_(false),
       pending_lossy_write_(false),
       read_error_(PREF_READ_ERROR_NONE) {
@@ skipping 38 matching lines @@
 }
 
 bool FilesystemJsonPrefStore::GetMutableValue(const std::string& key,
                                               base::Value** result) {
   DCHECK(CalledOnValidThread());
 
   return prefs_->Get(key, result);
 }
 
 void FilesystemJsonPrefStore::SetValue(const std::string& key,
-                                       scoped_ptr<base::Value> value,
+                                       std::unique_ptr<base::Value> value,
                                        uint32_t flags) {
   DCHECK(CalledOnValidThread());
 
   DCHECK(value);
   base::Value* old_value = nullptr;
   prefs_->Get(key, &old_value);
   if (!old_value || !value->Equals(old_value)) {
     prefs_->Set(key, std::move(value));
     ReportValueChanged(key, flags);
   }
 }
 
-void FilesystemJsonPrefStore::SetValueSilently(const std::string& key,
-                                               scoped_ptr<base::Value> value,
-                                               uint32_t flags) {
+void FilesystemJsonPrefStore::SetValueSilently(
+    const std::string& key,
+    std::unique_ptr<base::Value> value,
+    uint32_t flags) {
   DCHECK(CalledOnValidThread());
 
   DCHECK(value);
   base::Value* old_value = nullptr;
   prefs_->Get(key, &old_value);
   if (!old_value || !value->Equals(old_value)) {
     prefs_->Set(key, std::move(value));
     ScheduleWrite(flags);
   }
 }
@@ skipping 82 matching lines @@
   if (pref_filter_)
     pref_filter_->FilterUpdate(key);
 
   FOR_EACH_OBSERVER(PrefStore::Observer, observers_, OnPrefValueChanged(key));
 
   ScheduleWrite(flags);
 }
 
 void FilesystemJsonPrefStore::OnFileSystemShutdown() {}
 
-void FilesystemJsonPrefStore::OnFileRead(scoped_ptr<ReadResult> read_result) {
+void FilesystemJsonPrefStore::OnFileRead(
+    std::unique_ptr<ReadResult> read_result) {
   DCHECK(CalledOnValidThread());
 
   DCHECK(read_result);
 
-  scoped_ptr<base::DictionaryValue> unfiltered_prefs(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> unfiltered_prefs(
+      new base::DictionaryValue);
 
   read_error_ = read_result->error;
 
   switch (read_error_) {
     case PREF_READ_ERROR_ACCESS_DENIED:
     case PREF_READ_ERROR_FILE_OTHER:
     case PREF_READ_ERROR_FILE_LOCKED:
     case PREF_READ_ERROR_JSON_TYPE:
     case PREF_READ_ERROR_FILE_NOT_SPECIFIED:
       read_only_ = true;
@@ skipping 28 matching lines @@
     FinalizeFileRead(std::move(unfiltered_prefs), false);
   }
 }
 
 FilesystemJsonPrefStore::~FilesystemJsonPrefStore() {
   // TODO(erg): Now that writing is asynchronous, we can't really async write
   // prefs at shutdown. See comment in CommitPendingWrite().
 }
 
 void FilesystemJsonPrefStore::FinalizeFileRead(
-    scoped_ptr<base::DictionaryValue> prefs,
+    std::unique_ptr<base::DictionaryValue> prefs,
     bool schedule_write) {
   DCHECK(CalledOnValidThread());
 
   filtering_in_progress_ = false;
 
   prefs_ = std::move(prefs);
 
   initialized_ = true;
 
   if (schedule_write)
@@ skipping 81 matching lines @@
 
 void FilesystemJsonPrefStore::OnPreferencesReadStart() {
   directory_->ReadEntireFile(
       path_,
       Bind(&FilesystemJsonPrefStore::OnPreferencesFileRead, AsWeakPtr()));
 }
 
 void FilesystemJsonPrefStore::OnPreferencesFileRead(
     FileError err,
     mojo::Array<uint8_t> contents) {
-  scoped_ptr<FilesystemJsonPrefStore::ReadResult> read_result(
+  std::unique_ptr<FilesystemJsonPrefStore::ReadResult> read_result(
       new FilesystemJsonPrefStore::ReadResult);
   // TODO(erg): Needs even better error handling.
   switch (err) {
     case FileError::IN_USE:
     case FileError::ACCESS_DENIED:
     case FileError::NOT_A_FILE: {
       read_only_ = true;
       break;
     }
     case FileError::FAILED:
@@ skipping 10 matching lines @@
           reinterpret_cast<char*>(&contents.front()), contents.size()));
       read_result->value = deserializer.Deserialize(&error_code, &error_msg);
       read_result->error = HandleReadErrors(read_result->value.get());
     }
   }
 
   OnFileRead(std::move(read_result));
 }
 
 }  // namespace filesystem