Convert //base to use std::unique_ptr

base/files/important_file_writer.cc

 // Copyright (c) 2011 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 "base/files/important_file_writer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string>
@@ skipping 37 matching lines @@
   TEMP_FILE_FAILURE_MAX
 };
 
 void LogFailure(const FilePath& path, TempFileFailure failure_code,
                 const std::string& message) {
   UMA_HISTOGRAM_ENUMERATION("ImportantFile.TempFileFailures", failure_code,
                             TEMP_FILE_FAILURE_MAX);
   DPLOG(WARNING) << "temp file failure: " << path.value() << " : " << message;
 }
 
-// Helper function to call WriteFileAtomically() with a scoped_ptr<std::string>.
+// Helper function to call WriteFileAtomically() with a
+// std::unique_ptr<std::string>.
 bool WriteScopedStringToFileAtomically(const FilePath& path,
-                                       scoped_ptr<std::string> data) {
+                                       std::unique_ptr<std::string> data) {
   return ImportantFileWriter::WriteFileAtomically(path, *data);
 }
 
 }  // namespace
 
 // static
 bool ImportantFileWriter::WriteFileAtomically(const FilePath& path,
                                               const std::string& data) {
 #if defined(OS_CHROMEOS)
   // On Chrome OS, chrome gets killed when it cannot finish shutdown quickly,
@@ skipping 79 matching lines @@
   // to be our serializer. It may not be safe to call back to the parent object
   // being destructed.
   DCHECK(!HasPendingWrite());
 }
 
 bool ImportantFileWriter::HasPendingWrite() const {
   DCHECK(CalledOnValidThread());
   return timer_.IsRunning();
 }
 
-void ImportantFileWriter::WriteNow(scoped_ptr<std::string> data) {
+void ImportantFileWriter::WriteNow(std::unique_ptr<std::string> data) {
   DCHECK(CalledOnValidThread());
   if (!IsValueInRangeForNumericType<int32_t>(data->length())) {
     NOTREACHED();
     return;
   }
 
   if (HasPendingWrite())
     timer_.Stop();
 
   auto task = Bind(&WriteScopedStringToFileAtomically, path_, Passed(&data));
@@ skipping 14 matching lines @@
   serializer_ = serializer;
 
   if (!timer_.IsRunning()) {
     timer_.Start(FROM_HERE, commit_interval_, this,
                  &ImportantFileWriter::DoScheduledWrite);
   }
 }
 
 void ImportantFileWriter::DoScheduledWrite() {
   DCHECK(serializer_);
-  scoped_ptr<std::string> data(new std::string);
+  std::unique_ptr<std::string> data(new std::string);
   if (serializer_->SerializeData(data.get())) {
     WriteNow(std::move(data));
   } else {
     DLOG(WARNING) << "failed to serialize data to be saved in "
                   << path_.value();
   }
   serializer_ = nullptr;
 }
 
 void ImportantFileWriter::RegisterOnNextSuccessfulWriteCallback(
@@ skipping 23 matching lines @@
 
 void ImportantFileWriter::ForwardSuccessfulWrite(bool result) {
   DCHECK(CalledOnValidThread());
   if (result && !on_next_successful_write_.is_null()) {
     on_next_successful_write_.Run();
     on_next_successful_write_.Reset();
   }
 }
 
 }  // namespace base