Remove ListValue::Append(raw ptr) on Win

remoting/host/pairing_registry_delegate_win.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_win.h"
 
 #include <utility>
 
 #include "base/json/json_string_value_serializer.h"
 #include "base/logging.h"
@@ skipping 50 matching lines @@
     LOG(ERROR) << "Failed to parse '" << value_name << "': " << error_message
                << " (" << error_code << ").";
     return nullptr;
   }
 
   if (!value->IsType(base::Value::Type::DICTIONARY)) {
     LOG(ERROR) << "Failed to parse '" << value_name << "': not a dictionary.";
     return nullptr;
   }
 
-  return base::WrapUnique(static_cast<base::DictionaryValue*>(value.release()));
+  return base::DictionaryValue::From(std::move(value));
 }
 
 // Serializes |value| into a JSON string and writes it as value |value_name|
 // under |key|.
 bool WriteValue(base::win::RegKey& key,
                 const wchar_t* value_name,
                 std::unique_ptr<base::DictionaryValue> value) {
   std::string value_json_utf8;
   JSONStringValueSerializer serializer(&value_json_utf8);
   if (!serializer.Serialize(*value)) {
@@ skipping 50 matching lines @@
     std::wstring value_name;
     LONG result = unprivileged_.GetValueNameAt(index, &value_name);
     if (result != ERROR_SUCCESS) {
       SetLastError(result);
       PLOG(ERROR) << "Cannot get the name of value " << index;
       continue;
     }
 
     PairingRegistry::Pairing pairing = Load(base::WideToUTF8(value_name));
     if (pairing.is_valid())
-      pairings->Append(pairing.ToValue().release());
+      pairings->Append(pairing.ToValue());
   }
 
   return pairings;
 }
 
 bool PairingRegistryDelegateWin::DeleteAll() {
   if (!privileged_.Valid()) {
     LOG(ERROR) << "Cannot delete pairings: the delegate is read-only.";
     return false;
   }
@@ skipping 61 matching lines @@
   }
 
   // Convert pairing to JSON.
   std::unique_ptr<base::DictionaryValue> pairing_json = pairing.ToValue();
 
   // Extract the shared secret to a separate dictionary.
   std::unique_ptr<base::Value> secret_key;
   CHECK(pairing_json->Remove(PairingRegistry::kSharedSecretKey, &secret_key));
   std::unique_ptr<base::DictionaryValue> secret_json(
       new base::DictionaryValue());
-  secret_json->Set(PairingRegistry::kSharedSecretKey, secret_key.release());
+  secret_json->Set(PairingRegistry::kSharedSecretKey, std::move(secret_key));
 
   // presubmit: allow wstring
   std::wstring value_name = base::UTF8ToWide(pairing.client_id());
 
   // Write pairing to the registry.
   if (!WriteValue(privileged_, value_name.c_str(), std::move(secret_json)) ||
       !WriteValue(unprivileged_, value_name.c_str(), std::move(pairing_json))) {
     return false;
   }
 
@@ skipping 28 matching lines @@
   }
 
   return true;
 }
 
 std::unique_ptr<PairingRegistry::Delegate> CreatePairingRegistryDelegate() {
   return base::MakeUnique<PairingRegistryDelegateWin>();
 }
 
 }  // namespace remoting