Modify U2F apdu classes to use unique pointers

device/u2f/u2f_apdu_command.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 "base/memory/ptr_util.h"
+
 #include "u2f_apdu_command.h"
 
 namespace device {
 
-scoped_refptr<U2fApduCommand> U2fApduCommand::CreateFromMessage(
+std::unique_ptr<U2fApduCommand> U2fApduCommand::CreateFromMessage(
     const std::vector<uint8_t>& message) {
   uint16_t data_length = 0;
   size_t index = 0;
   size_t response_length = 0;
   std::vector<uint8_t> data;
   std::vector<uint8_t> suffix;
 
   if (message.size() < kApduMinHeader || message.size() > kApduMaxLength)
     return nullptr;
   uint8_t cla = message[index++];
@@ skipping 44 matching lines @@
         // Non-ISO7816-4 special legacy case where 2 suffix bytes are passed
         // along with a version message
         if (data_length == 0 && ins == kInsU2fVersion)
           suffix = {0x0, 0x0};
       } else {
         return nullptr;
       }
       break;
   }
 
-  return make_scoped_refptr(new U2fApduCommand(
-      cla, ins, p1, p2, response_length, std::move(data), std::move(suffix)));
-}
-
-// static
-scoped_refptr<U2fApduCommand> U2fApduCommand::Create() {
-  return make_scoped_refptr(new U2fApduCommand());
+  return base::MakeUnique<U2fApduCommand>(cla, ins, p1, p2, response_length,
+                                          std::move(data), std::move(suffix));
 }
 
 std::vector<uint8_t> U2fApduCommand::GetEncodedCommand() const {
   std::vector<uint8_t> encoded = {cla_, ins_, p1_, p2_};
 
   // If data exists, request size (Lc) is encoded in 3 bytes, with the first
   // byte always being null, and the other two bytes being a big-endian
   // representation of the request size. If data length is 0, response size (Le)
   // will be prepended with a null byte.
   if (data_.size() > 0) {
@@ skipping 32 matching lines @@
       ins_(ins),
       p1_(p1),
       p2_(p2),
       response_length_(response_length),
       data_(std::move(data)),
       suffix_(std::move(suffix)) {}
 
 U2fApduCommand::~U2fApduCommand() {}
 
 // static
-scoped_refptr<U2fApduCommand> U2fApduCommand::CreateRegister(
+std::unique_ptr<U2fApduCommand> U2fApduCommand::CreateRegister(
     const std::vector<uint8_t>& appid_digest,
     const std::vector<uint8_t>& challenge_digest) {
   if (appid_digest.size() != kAppIdDigestLen ||
       challenge_digest.size() != kChallengeDigestLen) {
     return nullptr;
   }
 
-  scoped_refptr<U2fApduCommand> command = Create();
+  auto command = base::MakeUnique<U2fApduCommand>();
   std::vector<uint8_t> data(challenge_digest.begin(), challenge_digest.end());
   data.insert(data.end(), appid_digest.begin(), appid_digest.end());
   command->set_ins(kInsU2fEnroll);
   command->set_p1(kP1TupRequiredConsumed);
   command->set_data(data);
   return command;
 }
 
 // static
-scoped_refptr<U2fApduCommand> U2fApduCommand::CreateVersion() {
-  scoped_refptr<U2fApduCommand> command = Create();
+std::unique_ptr<U2fApduCommand> U2fApduCommand::CreateVersion() {
+  auto command = base::MakeUnique<U2fApduCommand>();
   command->set_ins(kInsU2fVersion);
   command->set_response_length(kApduMaxResponseLength);
   return command;
 }
 
 // static
-scoped_refptr<U2fApduCommand> U2fApduCommand::CreateLegacyVersion() {
-  scoped_refptr<U2fApduCommand> command = Create();
+std::unique_ptr<U2fApduCommand> U2fApduCommand::CreateLegacyVersion() {
+  auto command = base::MakeUnique<U2fApduCommand>();
   command->set_ins(kInsU2fVersion);
   command->set_response_length(kApduMaxResponseLength);
   // Early U2F drafts defined the U2F version command in extended
   // length ISO 7816-4 format so 2 additional 0x0 bytes are necessary.
   // https://fidoalliance.org/specs/fido-u2f-v1.1-id-20160915/fido-u2f-raw-message-formats-v1.1-id-20160915.html#implementation-considerations
   command->set_suffix(std::vector<uint8_t>(2, 0));
   return command;
 }
 
 // static
-scoped_refptr<U2fApduCommand> U2fApduCommand::CreateSign(
+std::unique_ptr<U2fApduCommand> U2fApduCommand::CreateSign(
     const std::vector<uint8_t>& appid_digest,
     const std::vector<uint8_t>& challenge_digest,
     const std::vector<uint8_t>& key_handle) {
   if (appid_digest.size() != kAppIdDigestLen ||
       challenge_digest.size() != kChallengeDigestLen ||
       key_handle.size() > kMaxKeyHandleLength) {
     return nullptr;
   }
 
-  scoped_refptr<U2fApduCommand> command = Create();
+  auto command = base::MakeUnique<U2fApduCommand>();
   std::vector<uint8_t> data(challenge_digest.begin(), challenge_digest.end());
   data.insert(data.end(), appid_digest.begin(), appid_digest.end());
   data.push_back(static_cast<uint8_t>(key_handle.size()));
   data.insert(data.end(), key_handle.begin(), key_handle.end());
   command->set_ins(kInsU2fSign);
   command->set_p1(kP1TupRequiredConsumed);
   command->set_data(data);
   return command;
 }
 
 }  // namespace device