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

components/proximity_auth/connection_unittest.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/connection.h"
 
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "components/proximity_auth/connection_observer.h"
 #include "components/proximity_auth/remote_device.h"
 #include "components/proximity_auth/wire_message.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::DoAll;
 using testing::NiceMock;
 using testing::Return;
@@ skipping 11 matching lines @@
   MOCK_METHOD1(SetPaused, void(bool paused));
   MOCK_METHOD0(Connect, void());
   MOCK_METHOD0(Disconnect, void());
   MOCK_METHOD0(CancelConnectionAttempt, void());
   MOCK_METHOD1(SendMessageImplProxy, void(WireMessage* message));
   MOCK_METHOD1(DeserializeWireMessageProxy,
                WireMessage*(bool* is_incomplete_message));
 
   // Gmock only supports copyable types, so create simple wrapper methods for
   // ease of mocking.
-  void SendMessageImpl(scoped_ptr<WireMessage> message) override {
+  void SendMessageImpl(std::unique_ptr<WireMessage> message) override {
     SendMessageImplProxy(message.get());
   }
 
-  scoped_ptr<WireMessage> DeserializeWireMessage(
+  std::unique_ptr<WireMessage> DeserializeWireMessage(
       bool* is_incomplete_message) override {
-    return make_scoped_ptr(DeserializeWireMessageProxy(is_incomplete_message));
+    return base::WrapUnique(DeserializeWireMessageProxy(is_incomplete_message));
   }
 
   using Connection::status;
   using Connection::SetStatus;
   using Connection::OnDidSendMessage;
   using Connection::OnBytesReceived;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockConnection);
 };
@@ skipping 42 matching lines @@
 
   connection.SetStatus(Connection::IN_PROGRESS);
   EXPECT_FALSE(connection.IsConnected());
 }
 
 TEST(ProximityAuthConnectionTest, SendMessage_FailsWhenNotConnected) {
   StrictMock<MockConnection> connection;
   connection.SetStatus(Connection::IN_PROGRESS);
 
   EXPECT_CALL(connection, SendMessageImplProxy(_)).Times(0);
-  connection.SendMessage(scoped_ptr<WireMessage>());
+  connection.SendMessage(std::unique_ptr<WireMessage>());
 }
 
 TEST(ProximityAuthConnectionTest,
      SendMessage_FailsWhenAnotherMessageSendIsInProgress) {
   NiceMock<MockConnection> connection;
   connection.SetStatus(Connection::CONNECTED);
-  connection.SendMessage(scoped_ptr<WireMessage>());
+  connection.SendMessage(std::unique_ptr<WireMessage>());
 
   EXPECT_CALL(connection, SendMessageImplProxy(_)).Times(0);
-  connection.SendMessage(scoped_ptr<WireMessage>());
+  connection.SendMessage(std::unique_ptr<WireMessage>());
 }
 
 TEST(ProximityAuthConnectionTest, SendMessage_SucceedsWhenConnected) {
   StrictMock<MockConnection> connection;
   connection.SetStatus(Connection::CONNECTED);
 
   EXPECT_CALL(connection, SendMessageImplProxy(_));
-  connection.SendMessage(scoped_ptr<WireMessage>());
+  connection.SendMessage(std::unique_ptr<WireMessage>());
 }
 
 TEST(ProximityAuthConnectionTest,
      SendMessage_SucceedsAfterPreviousMessageSendCompletes) {
   NiceMock<MockConnection> connection;
   connection.SetStatus(Connection::CONNECTED);
-  connection.SendMessage(scoped_ptr<WireMessage>());
+  connection.SendMessage(std::unique_ptr<WireMessage>());
   connection.OnDidSendMessage(TestWireMessage(), true /* success */);
 
   EXPECT_CALL(connection, SendMessageImplProxy(_));
-  connection.SendMessage(scoped_ptr<WireMessage>());
+  connection.SendMessage(std::unique_ptr<WireMessage>());
 }
 
 TEST(ProximityAuthConnectionTest, SetStatus_NotifiesObserversOfStatusChange) {
   StrictMock<MockConnection> connection;
   EXPECT_EQ(Connection::DISCONNECTED, connection.status());
 
   StrictMock<MockConnectionObserver> observer;
   connection.AddObserver(&observer);
 
   EXPECT_CALL(observer,
@@ skipping 11 matching lines @@
   connection.AddObserver(&observer);
 
   EXPECT_CALL(observer, OnConnectionStatusChanged(_, _, _)).Times(0);
   connection.SetStatus(Connection::DISCONNECTED);
 }
 
 TEST(ProximityAuthConnectionTest,
      OnDidSendMessage_NotifiesObserversIfMessageSendInProgress) {
   NiceMock<MockConnection> connection;
   connection.SetStatus(Connection::CONNECTED);
-  connection.SendMessage(scoped_ptr<WireMessage>());
+  connection.SendMessage(std::unique_ptr<WireMessage>());
 
   StrictMock<MockConnectionObserver> observer;
   connection.AddObserver(&observer);
 
   EXPECT_CALL(observer, OnSendCompleted(Ref(connection), _, true));
   connection.OnDidSendMessage(TestWireMessage(), true /* success */);
 }
 
 TEST(ProximityAuthConnectionTest,
      OnDidSendMessage_DoesntNotifyObserversIfNoMessageSendInProgress) {
@@ skipping 58 matching lines @@
   connection.AddObserver(&observer);
 
   ON_CALL(connection, DeserializeWireMessageProxy(_))
       .WillByDefault(DoAll(SetArgPointee<0>(false),
                            Return(static_cast<WireMessage*>(NULL))));
   EXPECT_CALL(observer, OnMessageReceived(_, _)).Times(0);
   connection.OnBytesReceived(std::string());
 }
 
 }  // namespace proximity_auth