Convert //components/proximity_auth from scoped_ptr to std::unique_ptr

components/proximity_auth/messenger_impl.cc

 // Copyright 2014 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 "components/proximity_auth/messenger_impl.h"
 
 #include <utility>
 
 #include "base/base64url.h"
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "components/proximity_auth/connection.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "components/proximity_auth/messenger_observer.h"
 #include "components/proximity_auth/remote_status_update.h"
 #include "components/proximity_auth/secure_context.h"
 #include "components/proximity_auth/wire_message.h"
 
 namespace proximity_auth {
@@ skipping 36 matching lines @@
 // wrapper that should only be called when the |message| is known to specify its
 // message type, i.e. this should not be called for untrusted input.
 std::string GetMessageType(const base::DictionaryValue& message) {
   std::string type;
   message.GetString(kTypeKey, &type);
   return type;
 }
 
 }  // namespace
 
-MessengerImpl::MessengerImpl(scoped_ptr<Connection> connection,
-                             scoped_ptr<SecureContext> secure_context)
+MessengerImpl::MessengerImpl(std::unique_ptr<Connection> connection,
+                             std::unique_ptr<SecureContext> secure_context)
     : connection_(std::move(connection)),
       secure_context_(std::move(secure_context)),
       weak_ptr_factory_(this) {
   DCHECK(connection_->IsConnected());
   connection_->AddObserver(this);
 
   // TODO(tengs): We need CryptAuth to report if the phone runs iOS or Android,
   // rather than relying on this heuristic.
   if (connection_->remote_device().bluetooth_type == RemoteDevice::BLUETOOTH_LE)
     PollScreenStateForIOS();
@@ skipping 87 matching lines @@
 
   pending_message_.reset(new PendingMessage(queued_messages_.front()));
   queued_messages_.pop_front();
 
   secure_context_->Encode(pending_message_->json_message,
                           base::Bind(&MessengerImpl::OnMessageEncoded,
                                      weak_ptr_factory_.GetWeakPtr()));
 }
 
 void MessengerImpl::OnMessageEncoded(const std::string& encoded_message) {
-  connection_->SendMessage(make_scoped_ptr(new WireMessage(encoded_message)));
+  connection_->SendMessage(base::WrapUnique(new WireMessage(encoded_message)));
 }
 
 void MessengerImpl::OnMessageDecoded(const std::string& decoded_message) {
   // TODO(tengs): Unify the iOS status update protocol with the existing Android
   // protocol, so we don't have this special case.
   if (decoded_message == kScreenUnlocked || decoded_message == kScreenLocked) {
     RemoteStatusUpdate update;
     update.user_presence =
         (decoded_message == kScreenUnlocked ? USER_PRESENT : USER_ABSENT);
     update.secure_screen_lock_state = SECURE_SCREEN_LOCK_ENABLED;
     update.trust_agent_state = TRUST_AGENT_ENABLED;
     FOR_EACH_OBSERVER(MessengerObserver, observers_,
                       OnRemoteStatusUpdate(update));
     pending_message_.reset();
     ProcessMessageQueue();
     return;
   }
 
   // The decoded message should be a JSON string.
-  scoped_ptr<base::Value> message_value =
+  std::unique_ptr<base::Value> message_value =
       base::JSONReader::Read(decoded_message);
   if (!message_value || !message_value->IsType(base::Value::TYPE_DICTIONARY)) {
     PA_LOG(ERROR) << "Unable to parse message as JSON:\n" << decoded_message;
     return;
   }
 
   base::DictionaryValue* message;
   bool success = message_value->GetAsDictionary(&message);
   DCHECK(success);
 
@@ skipping 38 matching lines @@
     HandleUnlockResponseMessage(*message);
   else
     NOTREACHED();  // There are no other message types that expect a response.
 
   pending_message_.reset();
   ProcessMessageQueue();
 }
 
 void MessengerImpl::HandleRemoteStatusUpdateMessage(
     const base::DictionaryValue& message) {
-  scoped_ptr<RemoteStatusUpdate> status_update =
+  std::unique_ptr<RemoteStatusUpdate> status_update =
       RemoteStatusUpdate::Deserialize(message);
   if (!status_update) {
     PA_LOG(ERROR) << "Unexpected remote status update: " << message;
     return;
   }
 
   FOR_EACH_OBSERVER(MessengerObserver, observers_,
                     OnRemoteStatusUpdate(*status_update));
 }
 
@@ skipping 82 matching lines @@
   } else {
     PA_LOG(ERROR) << "Message of unknown type '" << pending_message_->type
                   << "' sent.";
   }
 
   pending_message_.reset();
   ProcessMessageQueue();
 }
 
 }  // namespace proximity_auth