[u2f] Factor out command type enum.

This is necessary to share the enum with U2F over BLE implementation.

Bug: 763303
Change-Id: Id31326c6cd42e0027de7e6c788c7e24b3795faa9
Reviewed-on: https://chromium-review.googlesource.com/659817
Commit-Queue: Pavel Kalinnikov <pkalinnikov@chromium.org>
Reviewed-by: Reilly Grant <reillyg@chromium.org>
Cr-Commit-Position: refs/heads/master@{#501307}

device/u2f/BUILD.gn

@@ -11,6 +11,7 @@ source_set("u2f") {
     "u2f_apdu_command.h",
     "u2f_apdu_response.cc",
     "u2f_apdu_response.h",
+    "u2f_command_type.h",
     "u2f_device.cc",
     "u2f_device.h",
     "u2f_hid_device.cc",

device/u2f/u2f_command_type.h

+// 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.
+
+#ifndef DEVICE_U2F_U2F_COMMAND_TYPE_H_
+#define DEVICE_U2F_U2F_COMMAND_TYPE_H_
+
+#include <stdint.h>
+
+namespace device {
+
+// The type of a command that can be sent either to or from a U2F authenticator,
+// i.e. a request or a response.
+//
+// Each request sent to a device results in a response of *the same* type sent
+// back, unless there was an error in which case a CMD_ERROR is returned.
+//
+// TODO(pkalinnikov): Merge BLE-specific commands to this type.
+enum class U2fCommandType : uint8_t {
+  // Sends arbitrary data to the device which echoes the same data back.
+  CMD_PING = 0x81,
+  // Encapsulates a U2F protocol raw message.
+  CMD_MSG = 0x83,
+  // Requests a unique channel from a USB/HID device.
+  CMD_INIT = 0x86,
+  // Instructs a USB/HID authenticator to show the user that it is active.
+  CMD_WINK = 0x88,
+  // Used as a response in case an error occurs during a request.
+  CMD_ERROR = 0xBF,
+};
+
+}  // namespace device
+
+#endif  // DEVICE_U2F_U2F_COMMAND_TYPE_H_

device/u2f/u2f_hid_device.cc

@@ -11,8 +11,9 @@
 #include "crypto/random.h"
 #include "device/base/device_client.h"
 #include "device/hid/hid_connection.h"
-#include "u2f_apdu_command.h"
-#include "u2f_message.h"
+#include "device/u2f/u2f_apdu_command.h"
+#include "device/u2f/u2f_command_type.h"
+#include "device/u2f/u2f_message.h"
 
 namespace device {
 
@@ -54,7 +55,7 @@ void U2fHidDevice::Transition(std::unique_ptr<U2fApduCommand> command,
     case State::IDLE: {
       state_ = State::BUSY;
       std::unique_ptr<U2fMessage> msg = U2fMessage::Create(
-          channel_id_, U2fMessage::Type::CMD_MSG, command->GetEncodedCommand());
+          channel_id_, U2fCommandType::CMD_MSG, command->GetEncodedCommand());
 
       ArmTimeout(callback);
       // Write message to the device
@@ -109,7 +110,7 @@ void U2fHidDevice::AllocateChannel(std::unique_ptr<U2fApduCommand> command,
   std::vector<uint8_t> nonce(8);
   crypto::RandBytes(nonce.data(), nonce.size());
   std::unique_ptr<U2fMessage> message =
-      U2fMessage::Create(channel_id_, U2fMessage::Type::CMD_INIT, nonce);
+      U2fMessage::Create(channel_id_, U2fCommandType::CMD_INIT, nonce);
 
   WriteMessage(
       std::move(message), true,
@@ -302,7 +303,7 @@ void U2fHidDevice::TryWink(const WinkCallback& callback) {
   }
 
   std::unique_ptr<U2fMessage> wink_message = U2fMessage::Create(
-      channel_id_, U2fMessage::Type::CMD_WINK, std::vector<uint8_t>());
+      channel_id_, U2fCommandType::CMD_WINK, std::vector<uint8_t>());
   WriteMessage(
       std::move(wink_message), true,
       base::Bind(&U2fHidDevice::OnWink, weak_factory_.GetWeakPtr(), callback));

device/u2f/u2f_message.cc

@@ -13,7 +13,7 @@ namespace device {
 // static
 std::unique_ptr<U2fMessage> U2fMessage::Create(
     uint32_t channel_id,
-    Type type,
+    U2fCommandType type,
     const std::vector<uint8_t>& data) {
   if (data.size() > kMaxMessageSize)
     return nullptr;
@@ -44,7 +44,7 @@ U2fMessage::U2fMessage(std::unique_ptr<U2fInitPacket> init_packet,
 }
 
 U2fMessage::U2fMessage(uint32_t channel_id,
-                       Type type,
+                       U2fCommandType type,
                        const std::vector<uint8_t>& data)
     : packets_(), remaining_size_(), channel_id_(channel_id) {
   size_t remaining_bytes = data.size();

device/u2f/u2f_message.h

@@ -9,6 +9,7 @@
 #include <vector>
 
 #include "base/gtest_prod_util.h"
+#include "device/u2f/u2f_command_type.h"
 #include "device/u2f/u2f_packet.h"
 
 namespace net {
@@ -23,20 +24,14 @@ namespace device {
 // about the message are available through class methods.
 class U2fMessage {
  public:
-  enum class Type : uint8_t {
-    CMD_PING = 0x81,
-    CMD_MSG = 0x83,
-    CMD_INIT = 0x86,
-    CMD_WINK = 0x88,
-    CMD_ERROR = 0xbf,
-  };
-
-  U2fMessage(uint32_t channel_id, Type type, const std::vector<uint8_t>& data);
+  U2fMessage(uint32_t channel_id,
+             U2fCommandType type,
+             const std::vector<uint8_t>& data);
   U2fMessage(std::unique_ptr<U2fInitPacket> init_packet, size_t remaining_size);
   ~U2fMessage();
 
   static std::unique_ptr<U2fMessage> Create(uint32_t channel_id,
-                                            Type type,
+                                            U2fCommandType type,
                                             const std::vector<uint8_t>& data);
   // Reconstruct a message from serialized message data
   static std::unique_ptr<U2fMessage> CreateFromSerializedData(

device/u2f/u2f_message_unittest.cc

@@ -39,7 +39,7 @@ TEST_F(U2fMessageTest, TestPacketSize) {
 TEST_F(U2fMessageTest, TestPacketData) {
   uint32_t channel_id = 0xF5060708;
   std::vector<uint8_t> data{10, 11};
-  uint8_t cmd = static_cast<uint8_t>(U2fMessage::Type::CMD_WINK);
+  uint8_t cmd = static_cast<uint8_t>(U2fCommandType::CMD_WINK);
   auto init_packet =
       std::make_unique<U2fInitPacket>(channel_id, cmd, data, data.size());
   int index = 0;
@@ -70,7 +70,7 @@ TEST_F(U2fMessageTest, TestPacketData) {
 TEST_F(U2fMessageTest, TestPacketConstructors) {
   uint32_t channel_id = 0x05060708;
   std::vector<uint8_t> data{10, 11};
-  uint8_t cmd = static_cast<uint8_t>(U2fMessage::Type::CMD_WINK);
+  uint8_t cmd = static_cast<uint8_t>(U2fCommandType::CMD_WINK);
   auto orig_packet =
       std::make_unique<U2fInitPacket>(channel_id, cmd, data, data.size());
 
@@ -105,7 +105,7 @@ TEST_F(U2fMessageTest, TestMaxLengthPacketConstructors) {
   for (size_t i = 0; i < U2fMessage::kMaxMessageSize; ++i)
     data.push_back(static_cast<uint8_t>(i % 0xff));
 
-  U2fMessage::Type cmd = U2fMessage::Type::CMD_MSG;
+  U2fCommandType cmd = U2fCommandType::CMD_MSG;
   std::unique_ptr<U2fMessage> orig_msg =
       U2fMessage::Create(channel_id, cmd, data);
   auto it = orig_msg->begin();
@@ -147,18 +147,18 @@ TEST_F(U2fMessageTest, TestMessagePartitoning) {
   uint32_t channel_id = 0x01010203;
   std::vector<uint8_t> data(U2fMessage::kInitPacketDataSize + 1);
   std::unique_ptr<U2fMessage> two_packet_message =
-      U2fMessage::Create(channel_id, U2fMessage::Type::CMD_PING, data);
+      U2fMessage::Create(channel_id, U2fCommandType::CMD_PING, data);
   EXPECT_EQ(2U, two_packet_message->NumPackets());
 
   data.resize(U2fMessage::kInitPacketDataSize);
   std::unique_ptr<U2fMessage> one_packet_message =
-      U2fMessage::Create(channel_id, U2fMessage::Type::CMD_PING, data);
+      U2fMessage::Create(channel_id, U2fCommandType::CMD_PING, data);
   EXPECT_EQ(1U, one_packet_message->NumPackets());
 
   data.resize(U2fMessage::kInitPacketDataSize +
               U2fMessage::kContinuationPacketDataSize + 1);
   std::unique_ptr<U2fMessage> three_packet_message =
-      U2fMessage::Create(channel_id, U2fMessage::Type::CMD_PING, data);
+      U2fMessage::Create(channel_id, U2fCommandType::CMD_PING, data);
   EXPECT_EQ(3U, three_packet_message->NumPackets());
 }
 
@@ -166,7 +166,7 @@ TEST_F(U2fMessageTest, TestMaxSize) {
   uint32_t channel_id = 0x00010203;
   std::vector<uint8_t> data(U2fMessage::kMaxMessageSize + 1);
   std::unique_ptr<U2fMessage> oversize_message =
-      U2fMessage::Create(channel_id, U2fMessage::Type::CMD_PING, data);
+      U2fMessage::Create(channel_id, U2fCommandType::CMD_PING, data);
   EXPECT_EQ(nullptr, oversize_message);
 }
 
@@ -174,7 +174,7 @@ TEST_F(U2fMessageTest, TestDeconstruct) {
   uint32_t channel_id = 0x0A0B0C0D;
   std::vector<uint8_t> data(U2fMessage::kMaxMessageSize, 0x7F);
   std::unique_ptr<U2fMessage> filled_message =
-      U2fMessage::Create(channel_id, U2fMessage::Type::CMD_PING, data);
+      U2fMessage::Create(channel_id, U2fCommandType::CMD_PING, data);
 
   EXPECT_THAT(data, testing::ContainerEq(filled_message->GetMessagePayload()));
 }
@@ -184,7 +184,7 @@ TEST_F(U2fMessageTest, TestDeserialize) {
   std::vector<uint8_t> data(U2fMessage::kMaxMessageSize);
 
   std::unique_ptr<U2fMessage> orig_message =
-      U2fMessage::Create(channel_id, U2fMessage::Type::CMD_PING, data);
+      U2fMessage::Create(channel_id, U2fCommandType::CMD_PING, data);
   std::list<scoped_refptr<net::IOBufferWithSize>> orig_list;
   scoped_refptr<net::IOBufferWithSize> buf = orig_message->PopNextPacket();
   orig_list.push_back(buf);