Convert //chromecast from scoped_ptr to std::unique_ptr

chromecast/crash/linux/synchronized_minidump_manager.cc

 // Copyright 2015 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 "chromecast/crash/linux/synchronized_minidump_manager.h"
 
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <time.h>
 #include <unistd.h>
+
 #include <utility>
 
 #include "base/files/dir_reader_posix.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "chromecast/base/path_utils.h"
 #include "chromecast/base/serializers.h"
 #include "chromecast/crash/linux/dump_info.h"
 
 // if |cond| is false, returns |retval|.
 #define RCHECK(cond, retval) \
   do {                       \
     if (!(cond)) {           \
@@ skipping 222 matching lines @@
   DCHECK_GE(lockfile_fd_, 0);
   DCHECK(!dumps_);
   DCHECK(!metadata_);
 
   std::string lockfile;
   RCHECK(ReadFileToString(base::FilePath(lockfile_path_), &lockfile), -1);
 
   std::vector<std::string> lines = base::SplitString(
       lockfile, "\n", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
 
-  scoped_ptr<base::ListValue> dumps = make_scoped_ptr(new base::ListValue());
+  std::unique_ptr<base::ListValue> dumps =
+      base::WrapUnique(new base::ListValue());
 
   // Validate dumps
   for (const std::string& line : lines) {
     if (line.size() == 0)
       continue;
-    scoped_ptr<base::Value> dump_info = DeserializeFromJson(line);
+    std::unique_ptr<base::Value> dump_info = DeserializeFromJson(line);
     DumpInfo info(dump_info.get());
     RCHECK(info.valid(), -1);
     dumps->Append(std::move(dump_info));
   }
 
-  scoped_ptr<base::Value> metadata =
+  std::unique_ptr<base::Value> metadata =
       DeserializeJsonFromFile(base::FilePath(metadata_path_));
   RCHECK(ValidateMetadata(metadata.get()), -1);
 
   dumps_ = std::move(dumps);
   metadata_ = std::move(metadata);
   return 0;
 }
 
 int SynchronizedMinidumpManager::WriteFiles(const base::ListValue* dumps,
                                             const base::Value* metadata) {
   DCHECK(dumps);
   DCHECK(metadata);
   std::string lockfile;
 
   for (const base::Value* elem : *dumps) {
-    scoped_ptr<std::string> dump_info = SerializeToJson(*elem);
+    std::unique_ptr<std::string> dump_info = SerializeToJson(*elem);
     RCHECK(dump_info, -1);
     lockfile += *dump_info;
     lockfile += "\n";  // Add line seperatators
   }
 
   if (WriteFile(base::FilePath(lockfile_path_),
                 lockfile.c_str(),
                 lockfile.size()) < 0) {
     return -1;
   }
 
   return SerializeJsonToFile(base::FilePath(metadata_path_), *metadata) ? 0
                                                                         : -1;
 }
 
 int SynchronizedMinidumpManager::InitializeFiles() {
-  scoped_ptr<base::DictionaryValue> metadata =
-      make_scoped_ptr(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> metadata =
+      base::WrapUnique(new base::DictionaryValue());
 
   base::DictionaryValue* ratelimit_fields = new base::DictionaryValue();
-  metadata->Set(kLockfileRatelimitKey, make_scoped_ptr(ratelimit_fields));
+  metadata->Set(kLockfileRatelimitKey, base::WrapUnique(ratelimit_fields));
   ratelimit_fields->SetString(kLockfileRatelimitPeriodStartKey, "0");
   ratelimit_fields->SetInteger(kLockfileRatelimitPeriodDumpsKey, 0);
 
-  scoped_ptr<base::ListValue> dumps = make_scoped_ptr(new base::ListValue());
+  std::unique_ptr<base::ListValue> dumps =
+      base::WrapUnique(new base::ListValue());
 
   return WriteFiles(dumps.get(), metadata.get());
 }
 
 int SynchronizedMinidumpManager::AddEntryToLockFile(const DumpInfo& dump_info) {
   DCHECK_LE(0, lockfile_fd_);
   DCHECK(dumps_);
 
   // Make sure dump_info is valid.
   if (!dump_info.valid()) {
@@ skipping 97 matching lines @@
 
     const std::string file_path = dump_path_.Append(reader.name()).value();
     if (file_path != lockfile_path_ && file_path != metadata_path_)
       return true;
   }
 
   return false;
 }
 
 }  // namespace chromecast