Convert //remoting to use std::unique_ptr

remoting/host/pairing_registry_delegate_linux.cc

 // Copyright 2013 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/host/pairing_registry_delegate_linux.h"
 
 #include "base/bind.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/files/important_file_writer.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "remoting/host/branding.h"
 
 namespace {
 
 // The pairing registry path relative to the configuration directory.
 const char kRegistryDirectory[] = "paired-clients";
 
 const char kPairingFilenameFormat[] = "%s.json";
 const char kPairingFilenamePattern[] = "*.json";
 
 }  // namespace
 
 namespace remoting {
 
 using protocol::PairingRegistry;
 
 PairingRegistryDelegateLinux::PairingRegistryDelegateLinux() {
 }
 
 PairingRegistryDelegateLinux::~PairingRegistryDelegateLinux() {
 }
 
-scoped_ptr<base::ListValue> PairingRegistryDelegateLinux::LoadAll() {
-  scoped_ptr<base::ListValue> pairings(new base::ListValue());
+std::unique_ptr<base::ListValue> PairingRegistryDelegateLinux::LoadAll() {
+  std::unique_ptr<base::ListValue> pairings(new base::ListValue());
 
   // Enumerate all pairing files in the pairing registry.
   base::FilePath registry_path = GetRegistryPath();
   base::FileEnumerator enumerator(registry_path, false,
                                   base::FileEnumerator::FILES,
                                   kPairingFilenamePattern);
   for (base::FilePath pairing_file = enumerator.Next(); !pairing_file.empty();
        pairing_file = enumerator.Next()) {
     // Read the JSON containing pairing data.
     JSONFileValueDeserializer deserializer(pairing_file);
     int error_code;
     std::string error_message;
-    scoped_ptr<base::Value> pairing_json =
+    std::unique_ptr<base::Value> pairing_json =
         deserializer.Deserialize(&error_code, &error_message);
     if (!pairing_json) {
       LOG(WARNING) << "Failed to load '" << pairing_file.value() << "' ("
                    << error_code << ").";
       continue;
     }
 
     pairings->Append(pairing_json.release());
   }
 
@@ skipping 18 matching lines @@
 
 PairingRegistry::Pairing PairingRegistryDelegateLinux::Load(
     const std::string& client_id) {
   base::FilePath registry_path = GetRegistryPath();
   base::FilePath pairing_file = registry_path.Append(
       base::StringPrintf(kPairingFilenameFormat, client_id.c_str()));
 
   JSONFileValueDeserializer deserializer(pairing_file);
   int error_code;
   std::string error_message;
-  scoped_ptr<base::Value> pairing =
+  std::unique_ptr<base::Value> pairing =
       deserializer.Deserialize(&error_code, &error_message);
   if (!pairing) {
     LOG(WARNING) << "Failed to load pairing information: " << error_message
                  << " (" << error_code << ").";
     return PairingRegistry::Pairing();
   }
 
   base::DictionaryValue* pairing_dictionary;
   if (!pairing->GetAsDictionary(&pairing_dictionary)) {
     LOG(WARNING) << "Failed to parse pairing information: not a dictionary.";
@@ skipping 46 matching lines @@
 
   base::FilePath config_dir = remoting::GetConfigDir();
   return config_dir.Append(kRegistryDirectory);
 }
 
 void PairingRegistryDelegateLinux::SetRegistryPathForTesting(
     const base::FilePath& registry_path) {
   registry_path_for_testing_ = registry_path;
 }
 
-
-scoped_ptr<PairingRegistry::Delegate> CreatePairingRegistryDelegate() {
-  return make_scoped_ptr(new PairingRegistryDelegateLinux());
+std::unique_ptr<PairingRegistry::Delegate> CreatePairingRegistryDelegate() {
+  return base::WrapUnique(new PairingRegistryDelegateLinux());
 }
 
 }  // namespace remoting