Modify U2F apdu classes to use unique pointers

device/u2f/u2f_hid_device_unittest.cc

 // Copyright 2017 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 <list>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/test/test_io_thread.h"
@@ skipping 11 matching lines @@
 #include "u2f_packet.h"
 
 namespace {
 
 #if defined(OS_MACOSX)
 const uint64_t kTestDeviceId = 42;
 #else
 const char* kTestDeviceId = "device";
 #endif
 
-void ResponseCallback(scoped_refptr<device::U2fApduResponse>* output,
+void ResponseCallback(std::unique_ptr<device::U2fApduResponse>* output,
                       bool success,
-                      scoped_refptr<device::U2fApduResponse> response) {
-  *output = response;
+                      std::unique_ptr<device::U2fApduResponse> response) {
+  *output = std::move(response);
 }
 
 class MockHidErrorConnection : public device::HidConnection {
  public:
   explicit MockHidErrorConnection(
       scoped_refptr<device::HidDeviceInfo> device_info)
       : device::HidConnection(device_info) {}
 
   void PlatformClose() override {}
 
@@ skipping 88 matching lines @@
 
 class TestDeviceCallback {
  public:
   TestDeviceCallback()
       : closure_(),
         callback_(base::Bind(&TestDeviceCallback::ReceivedCallback,
                              base::Unretained(this))),
         run_loop_() {}
   ~TestDeviceCallback() {}
 
-  void ReceivedCallback(bool success, scoped_refptr<U2fApduResponse> response) {
-    response_ = response;
+  void ReceivedCallback(bool success,
+                        std::unique_ptr<U2fApduResponse> response) {
+    response_ = std::move(response);
     closure_.Run();
   }
 
-  scoped_refptr<U2fApduResponse> WaitForCallback() {
+  std::unique_ptr<U2fApduResponse> WaitForCallback() {
     closure_ = run_loop_.QuitClosure();
     run_loop_.Run();
-    return response_;
+    return std::move(response_);
   }
 
   const U2fDevice::DeviceCallback& callback() { return callback_; }
 
  private:
-  scoped_refptr<U2fApduResponse> response_;
+  std::unique_ptr<U2fApduResponse> response_;
   base::Closure closure_;
   U2fDevice::DeviceCallback callback_;
   base::RunLoop run_loop_;
 };
 
 class U2fHidDeviceTest : public testing::Test {
  public:
   void SetUp() override {
     message_loop_.reset(new base::MessageLoopForUI());
     io_thread_.reset(new base::TestIOThread(base::TestIOThread::kAutoStart));
@@ skipping 66 matching lines @@
 
   ASSERT_EQ(static_cast<size_t>(1), u2f_devices.size());
   auto& device = u2f_devices.front();
   // Put device in IDLE state
   TestDeviceCallback cb0;
   device->state_ = U2fHidDevice::State::IDLE;
 
   // Manually delete connection
   device->connection_ = nullptr;
   // Add pending transactions manually and ensure they are processed
-  scoped_refptr<U2fApduResponse> response1(
+  std::unique_ptr<U2fApduResponse> response1(
       U2fApduResponse::CreateFromMessage(std::vector<uint8_t>({0x0, 0x0})));
   device->pending_transactions_.push_back(
       {U2fApduCommand::CreateVersion(),
        base::Bind(&ResponseCallback, &response1)});
-  scoped_refptr<U2fApduResponse> response2(
+  std::unique_ptr<U2fApduResponse> response2(
       U2fApduResponse::CreateFromMessage(std::vector<uint8_t>({0x0, 0x0})));
   device->pending_transactions_.push_back(
       {U2fApduCommand::CreateVersion(),
        base::Bind(&ResponseCallback, &response2)});
-  scoped_refptr<U2fApduResponse> response3(
+  std::unique_ptr<U2fApduResponse> response3(
       U2fApduResponse::CreateFromMessage(std::vector<uint8_t>({0x0, 0x0})));
   device->DeviceTransact(U2fApduCommand::CreateVersion(),
                          base::Bind(&ResponseCallback, &response3));
   EXPECT_EQ(U2fHidDevice::State::DEVICE_ERROR, device->state_);
   EXPECT_EQ(nullptr, response1);
   EXPECT_EQ(nullptr, response2);
   EXPECT_EQ(nullptr, response3);
 };
 
 TEST_F(U2fHidDeviceTest, TestDeviceError) {
@@ skipping 12 matching lines @@
   std::list<std::unique_ptr<U2fHidDevice>>& u2f_devices =
       callback.WaitForCallback();
 
   ASSERT_EQ(static_cast<size_t>(1), u2f_devices.size());
   auto& device = u2f_devices.front();
   // Mock connection where writes always fail
   scoped_refptr<MockHidErrorConnection> connection(
       new MockHidErrorConnection(device0));
   device->connection_ = connection;
   device->state_ = U2fHidDevice::State::IDLE;
-  scoped_refptr<U2fApduResponse> response0(
+  std::unique_ptr<U2fApduResponse> response0(
       U2fApduResponse::CreateFromMessage(std::vector<uint8_t>({0x0, 0x0})));
   device->DeviceTransact(U2fApduCommand::CreateVersion(),
                          base::Bind(&ResponseCallback, &response0));
   EXPECT_EQ(nullptr, response0);
   EXPECT_EQ(U2fHidDevice::State::DEVICE_ERROR, device->state_);
 
   // Add pending transactions manually and ensure they are processed
-  scoped_refptr<U2fApduResponse> response1(
+  std::unique_ptr<U2fApduResponse> response1(
       U2fApduResponse::CreateFromMessage(std::vector<uint8_t>({0x0, 0x0})));
   device->pending_transactions_.push_back(
       {U2fApduCommand::CreateVersion(),
        base::Bind(&ResponseCallback, &response1)});
-  scoped_refptr<U2fApduResponse> response2(
+  std::unique_ptr<U2fApduResponse> response2(
       U2fApduResponse::CreateFromMessage(std::vector<uint8_t>({0x0, 0x0})));
   device->pending_transactions_.push_back(
       {U2fApduCommand::CreateVersion(),
        base::Bind(&ResponseCallback, &response2)});
-  scoped_refptr<U2fApduResponse> response3(
+  std::unique_ptr<U2fApduResponse> response3(
       U2fApduResponse::CreateFromMessage(std::vector<uint8_t>({0x0, 0x0})));
   device->DeviceTransact(U2fApduCommand::CreateVersion(),
                          base::Bind(&ResponseCallback, &response3));
   EXPECT_EQ(U2fHidDevice::State::DEVICE_ERROR, device->state_);
   EXPECT_EQ(nullptr, response1);
   EXPECT_EQ(nullptr, response2);
   EXPECT_EQ(nullptr, response3);
 };
 
 }  // namespace device