Convert //remoting to use std::unique_ptr

remoting/test/refresh_token_store.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 "remoting/test/refresh_token_store.h"
 
 #include "base/files/file_util.h"
 #include "base/files/important_file_writer.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/values.h"
 
 namespace {
 const base::FilePath::CharType kTokenFileName[] =
     FILE_PATH_LITERAL("refresh_tokens.json");
 const base::FilePath::CharType kRemotingFolder[] =
     FILE_PATH_LITERAL("remoting");
 const base::FilePath::CharType kRefreshTokenStoreFolder[] =
     FILE_PATH_LITERAL("token_store");
 }  // namespace
@@ skipping 41 matching lines @@
   base::FilePath refresh_token_file_path(GetPathForRefreshTokenFile());
   DCHECK(!refresh_token_file_path.empty());
   VLOG(1) << "Reading token from: " << refresh_token_file_path.value();
 
   std::string file_contents;
   if (!base::ReadFileToString(refresh_token_file_path, &file_contents)) {
     VLOG(1) << "Couldn't read token file: " << refresh_token_file_path.value();
     return std::string();
   }
 
-  scoped_ptr<base::Value> token_data(base::JSONReader::Read(file_contents));
+  std::unique_ptr<base::Value> token_data(
+      base::JSONReader::Read(file_contents));
   base::DictionaryValue* tokens = nullptr;
   if (!token_data || !token_data->GetAsDictionary(&tokens)) {
     LOG(ERROR) << "Refresh token file contents were not valid JSON, "
                << "could not retrieve token.";
     return std::string();
   }
 
   std::string refresh_token;
   if (!tokens->GetStringWithoutPathExpansion(user_name_, &refresh_token)) {
     // This may not be an error as the file could exist but contain refresh
@@ skipping 21 matching lines @@
   }
 
   std::string file_contents("{}");
   if (base::PathExists(file_path)) {
     if (!base::ReadFileToString(file_path, &file_contents)) {
       LOG(ERROR) << "Invalid token file: " << file_path.value();
       return false;
     }
   }
 
-  scoped_ptr<base::Value> token_data(base::JSONReader::Read(file_contents));
+  std::unique_ptr<base::Value> token_data(
+      base::JSONReader::Read(file_contents));
   base::DictionaryValue* tokens = nullptr;
   if (!token_data || !token_data->GetAsDictionary(&tokens)) {
     LOG(ERROR) << "Invalid refresh token file format, could not store token.";
     return false;
   }
 
   std::string json_string;
   tokens->SetStringWithoutPathExpansion(user_name_, refresh_token);
   if (!base::JSONWriter::Write(*token_data, &json_string)) {
     LOG(ERROR) << "Couldn't convert JSON data to string";
@@ skipping 24 matching lines @@
   }
 
   // If no file has been specified, then we will use a default file name.
   if (refresh_token_file_path.Extension().empty()) {
     refresh_token_file_path = refresh_token_file_path.Append(kTokenFileName);
   }
 
   return refresh_token_file_path;
 }
 
-scoped_ptr<RefreshTokenStore> RefreshTokenStore::OnDisk(
+std::unique_ptr<RefreshTokenStore> RefreshTokenStore::OnDisk(
     const std::string& user_name,
     const base::FilePath& refresh_token_file_path) {
-  return make_scoped_ptr<RefreshTokenStore>(
+  return base::WrapUnique<RefreshTokenStore>(
       new RefreshTokenStoreOnDisk(user_name, refresh_token_file_path));
 }
 
 }  // namespace test
 }  // namespace remoting