Convert //remoting to use std::unique_ptr

remoting/host/security_key/security_key_message.cc

 // Copyright 2016 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/security_key/security_key_message.h"
 
 #include <cstdint>
+#include <memory>
 #include <string>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 
 namespace {
 
 // Limit remote security key messages to 256KB.
 const uint32_t kMaxSecurityKeyMessageByteCount = 256 * 1024;
 
 }  // namespace
 
 namespace remoting {
 
@@ skipping 24 matching lines @@
     case static_cast<int>(RemoteSecurityKeyMessageType::UNKNOWN_ERROR):
     case static_cast<int>(RemoteSecurityKeyMessageType::INVALID):
       return static_cast<RemoteSecurityKeyMessageType>(value);
 
     default:
       LOG(ERROR) << "Unknown message type passed in: " << value;
       return RemoteSecurityKeyMessageType::INVALID;
   }
 }
 
-scoped_ptr<SecurityKeyMessage> SecurityKeyMessage::CreateMessageForTest(
+std::unique_ptr<SecurityKeyMessage> SecurityKeyMessage::CreateMessageForTest(
     RemoteSecurityKeyMessageType type,
     const std::string& payload) {
-  scoped_ptr<SecurityKeyMessage> message(new SecurityKeyMessage());
+  std::unique_ptr<SecurityKeyMessage> message(new SecurityKeyMessage());
   message->type_ = type;
   message->payload_ = payload;
 
   return message;
 }
 
 bool SecurityKeyMessage::ParseMessage(const std::string& message_data) {
   if (!IsValidMessageSize(message_data.size())) {
     return false;
   }
 
   // The first char of the message is the message type.
   type_ = MessageTypeFromValue(message_data[0]);
   if (type_ == RemoteSecurityKeyMessageType::INVALID) {
     return false;
   }
 
   payload_.clear();
   if (message_data.size() > kMessageTypeSizeBytes) {
     payload_ = message_data.substr(1);
   }
 
   return true;
 }
 
-}  // namespace remoting
+}  // namespace remoting