service: Rename Uuid to UUID

This is more consistent with the ancronym naming convention in the
framework code (e.g. java.util.UUID) and elsewhere in the Bluetooth
daemon.

Change-Id: I3461cf12d563e00ba5e0b0b390bd9ef94e6d7418

6 files changed, 97 insertions, 95 deletions

diff --git a/system/service/gatt_server.cpp b/system/service/gatt_server.cpp
index 5fcda809fc..b5efebe41c 100644
--- a/system/service/gatt_server.cpp
+++ b/system/service/gatt_server.cpp
@@ -82,7 +82,7 @@ namespace bluetooth {
 namespace gatt {
 
 struct Characteristic {
-  Uuid uuid;
+  UUID uuid;
   int blob_section;
   std::vector<uint8_t> blob;
 
@@ -97,12 +97,12 @@ struct ServerInternals {
   ~ServerInternals();
   int Initialize();
   bt_status_t AddCharacteristic(
-      const Uuid& uuid,
+      const UUID& uuid,
       int properties,
       int permissions);
 
   // This maps API attribute UUIDs to BlueDroid handles.
-  std::map<Uuid, int> uuid_to_attribute;
+  std::map<UUID, int> uuid_to_attribute;
 
   // The attribute cache, indexed by BlueDroid handles.
   std::unordered_map<int, Characteristic> characteristics;
@@ -112,7 +112,7 @@ struct ServerInternals {
 
   ScanResults scan_results;
 
-  Uuid last_write;
+  UUID last_write;
   const btgatt_interface_t *gatt;
   int server_if;
   int client_if;
@@ -231,7 +231,7 @@ void RequestWriteCallback(int conn_id, int trans_id, bt_bdaddr_t *bda,
   } else if (!is_prep) {
     // This is a single frame characteristic write.
     // Notify upwards because we're done now.
-    const bluetooth::Uuid::Uuid128Bit &attr_uuid = ch.uuid.GetFullBigEndian();
+    const bluetooth::UUID::UUID128Bit &attr_uuid = ch.uuid.GetFullBigEndian();
     int status = write(g_internal->pipefd[kPipeWriteEnd], attr_uuid.data(),
                        attr_uuid.size());
     if (-1 == status)
@@ -272,7 +272,7 @@ void RequestExecWriteCallback(int conn_id, int trans_id, bt_bdaddr_t *bda,
 
   std::lock_guard<std::mutex> lock(g_internal->lock);
   // Communicate the attribute UUID as notification of a write update.
-  const bluetooth::Uuid::Uuid128Bit uuid =
+  const bluetooth::UUID::UUID128Bit uuid =
       g_internal->last_write.GetFullBigEndian();
   int status = write(g_internal->pipefd[kPipeWriteEnd],
                      uuid.data(), uuid.size());
@@ -298,7 +298,7 @@ void CharacteristicAddedCallback(int status, int server_if, bt_uuid_t *uuid,
       "%s: status:%d server_if:%d service_handle:%d char_handle:%d", __func__,
       status, server_if, srvc_handle, char_handle);
 
-  bluetooth::Uuid id(*uuid);
+  bluetooth::UUID id(*uuid);
 
   std::lock_guard<std::mutex> lock(g_internal->lock);
 
@@ -508,7 +508,7 @@ int ServerInternals::Initialize() {
 }
 
 bt_status_t ServerInternals::AddCharacteristic(
-    const Uuid& uuid,
+    const UUID& uuid,
     int properties,
     int permissions) {
   bt_uuid_t c_uuid = uuid.GetBlueDroid();
@@ -538,7 +538,7 @@ Server::Server() : internal_(nullptr) {}
 
 Server::~Server() {}
 
-bool Server::Initialize(const Uuid& service_id, int* gatt_pipe) {
+bool Server::Initialize(const UUID& service_id, int* gatt_pipe) {
   internal_.reset(new ServerInternals);
   if (!internal_) {
     LOG_ERROR(LOG_TAG, "Error creating internals");
@@ -573,7 +573,7 @@ bool Server::Initialize(const Uuid& service_id, int* gatt_pipe) {
   return true;
 }
 
-bool Server::SetAdvertisement(const std::vector<Uuid>& ids,
+bool Server::SetAdvertisement(const std::vector<UUID>& ids,
                               const std::vector<uint8_t>& service_data,
                               const std::vector<uint8_t>& manufacturer_data,
                               bool transmit_name) {
@@ -581,7 +581,7 @@ bool Server::SetAdvertisement(const std::vector<Uuid>& ids,
   auto mutable_manufacturer_data = manufacturer_data;
   auto mutable_service_data = service_data;
 
-  for (const Uuid &id : ids) {
+  for (const UUID &id : ids) {
     const auto le_id = id.GetFullLittleEndian();
     id_data.insert(id_data.end(), le_id.begin(), le_id.end());
   }
@@ -607,7 +607,7 @@ bool Server::SetAdvertisement(const std::vector<Uuid>& ids,
   return true;
 }
 
-bool Server::SetScanResponse(const std::vector<Uuid>& ids,
+bool Server::SetScanResponse(const std::vector<UUID>& ids,
                              const std::vector<uint8_t>& service_data,
                              const std::vector<uint8_t>& manufacturer_data,
                              bool transmit_name) {
@@ -615,7 +615,7 @@ bool Server::SetScanResponse(const std::vector<Uuid>& ids,
   auto mutable_manufacturer_data = manufacturer_data;
   auto mutable_service_data = service_data;
 
-  for (const Uuid &id : ids) {
+  for (const UUID &id : ids) {
     const auto le_id = id.GetFullLittleEndian();
     id_data.insert(id_data.end(), le_id.begin(), le_id.end());
   }
@@ -642,7 +642,7 @@ bool Server::SetScanResponse(const std::vector<Uuid>& ids,
 }
 
 bool Server::AddCharacteristic(
-    const Uuid &id, int properties, int permissions) {
+    const UUID &id, int properties, int permissions) {
   std::unique_lock<std::mutex> lock(internal_->lock);
   bt_status_t btstat = internal_->AddCharacteristic(
       id, properties, permissions);
@@ -657,7 +657,7 @@ bool Server::AddCharacteristic(
   return true;
 }
 
-bool Server::AddBlob(const Uuid &id, const Uuid &control_id, int properties,
+bool Server::AddBlob(const UUID &id, const UUID &control_id, int properties,
                     int permissions) {
   std::unique_lock<std::mutex> lock(internal_->lock);
 
@@ -746,7 +746,7 @@ bool Server::GetScanResults(ScanResults *results) {
   return true;
 }
 
-bool Server::SetCharacteristicValue(const Uuid &id,
+bool Server::SetCharacteristicValue(const UUID &id,
                               const std::vector<uint8_t> &value) {
   std::lock_guard<std::mutex> lock(internal_->lock);
   const int attribute_id = internal_->uuid_to_attribute[id];
@@ -769,7 +769,7 @@ bool Server::SetCharacteristicValue(const Uuid &id,
   return true;
 }
 
-bool Server::GetCharacteristicValue(const Uuid &id, std::vector<uint8_t> *value) {
+bool Server::GetCharacteristicValue(const UUID &id, std::vector<uint8_t> *value) {
   std::lock_guard<std::mutex> lock(internal_->lock);
   const int attribute_id = internal_->uuid_to_attribute[id];
   *value = internal_->characteristics[attribute_id].blob;
diff --git a/system/service/gatt_server.h b/system/service/gatt_server.h
index e71abffd72..ff4176023c 100644
--- a/system/service/gatt_server.h
+++ b/system/service/gatt_server.h
@@ -65,34 +65,34 @@ class Server {
 
   // Register GATT interface, initialize internal state,
   // and open a pipe for characteristic write notification.
-  bool Initialize(const Uuid& service_id, int* gatt_pipe);
+  bool Initialize(const UUID& service_id, int* gatt_pipe);
 
   // Control the content of service advertisement.
-  bool SetAdvertisement(const std::vector<Uuid>& ids,
+  bool SetAdvertisement(const std::vector<UUID>& ids,
                         const std::vector<uint8_t>& service_data,
                         const std::vector<uint8_t>& manufacturer_data,
                         bool transmit_name);
 
   // Control the content of service scan response.
-  bool SetScanResponse(const std::vector<Uuid>& ids,
+  bool SetScanResponse(const std::vector<UUID>& ids,
                        const std::vector<uint8_t>& service_data,
                        const std::vector<uint8_t>& manufacturer_data,
                        bool transmit_name);
 
   // Add an ordinary characteristic for reading and/or writing.
-  bool AddCharacteristic(const Uuid &id, int properties, int permissions);
+  bool AddCharacteristic(const UUID &id, int properties, int permissions);
 
   // Add a special 'blob' characteristic with a corresponding control
   // attribute to manipulate which part of the blob the attribute represents.
-  bool AddBlob(const Uuid &id, const Uuid &control_id, int properties,
+  bool AddBlob(const UUID &id, const UUID &control_id, int properties,
                int permissions);
 
   // Put a new value into a characeteristic.
   // It will be read from a client starting at the next 0-offset read.
-  bool SetCharacteristicValue(const Uuid &id, const std::vector<uint8_t> &value);
+  bool SetCharacteristicValue(const UUID &id, const std::vector<uint8_t> &value);
 
   // Get the current value of a characteristic.
-  bool GetCharacteristicValue(const Uuid &id, std::vector<uint8_t> *value);
+  bool GetCharacteristicValue(const UUID &id, std::vector<uint8_t> *value);
 
   // Start this service. Activate advertisements, allow connections.
   // Characteristics should all be created before this.
diff --git a/system/service/ipc/unix_ipc_host.cpp b/system/service/ipc/unix_ipc_host.cpp
index b7a64da315..2f801d4f5e 100644
--- a/system/service/ipc/unix_ipc_host.cpp
+++ b/system/service/ipc/unix_ipc_host.cpp
@@ -39,7 +39,7 @@
 #include "service/uuid.h"
 
 using bluetooth::Adapter;
-using bluetooth::Uuid;
+using bluetooth::UUID;
 
 using namespace bluetooth::gatt;
 
@@ -115,7 +115,7 @@ bool UnixIPCHost::OnCreateService(const std::string& service_uuid) {
 
   int gattfd;
   bool status = gatt_servers_[service_uuid]->Initialize(
-          Uuid(service_uuid), &gattfd);
+          UUID(service_uuid), &gattfd);
   if (!status) {
     LOG_ERROR(LOG_TAG, "Failed to initialize bluetooth");
     return false;
@@ -161,10 +161,10 @@ bool UnixIPCHost::OnAddCharacteristic(const std::string& service_uuid,
 
   if (control_uuid.empty()) {
     gatt_servers_[service_uuid]->AddCharacteristic(
-        Uuid(characteristic_uuid), properties_mask, permissions_mask);
+        UUID(characteristic_uuid), properties_mask, permissions_mask);
   } else {
-    gatt_servers_[service_uuid]->AddBlob(Uuid(characteristic_uuid),
-                                         Uuid(control_uuid), properties_mask,
+    gatt_servers_[service_uuid]->AddBlob(UUID(characteristic_uuid),
+                                         UUID(control_uuid), properties_mask,
                                          permissions_mask);
   }
   return true;
@@ -176,7 +176,7 @@ bool UnixIPCHost::OnSetCharacteristicValue(const std::string& service_uuid,
   std::string decoded_data;
   base::Base64Decode(value, &decoded_data);
   std::vector<uint8_t> blob_data(decoded_data.begin(), decoded_data.end());
-  gatt_servers_[service_uuid]->SetCharacteristicValue(Uuid(characteristic_uuid),
+  gatt_servers_[service_uuid]->SetCharacteristicValue(UUID(characteristic_uuid),
                                                       blob_data);
   return true;
 }
@@ -192,8 +192,8 @@ bool UnixIPCHost::OnSetAdvertisement(const std::string& service_uuid,
   std::vector<std::string> advertise_uuid_tokens;
   base::SplitString(advertise_uuids, '.', &advertise_uuid_tokens);
 
-  // string -> vector<Uuid>
-  std::vector<Uuid> ids;
+  // string -> vector<UUID>
+  std::vector<UUID> ids;
   for (const auto& uuid_token : advertise_uuid_tokens)
     ids.emplace_back(uuid_token);
 
@@ -220,8 +220,8 @@ bool UnixIPCHost::OnSetScanResponse(const std::string& service_uuid,
   std::vector<std::string> scan_response_uuid_tokens;
   base::SplitString(scan_response_uuids, '.', &scan_response_uuid_tokens);
 
-  // string -> vector<Uuid>
-  std::vector<Uuid> ids;
+  // string -> vector<UUID>
+  std::vector<UUID> ids;
   for (const auto& uuid_token : scan_response_uuid_tokens)
     ids.emplace_back(uuid_token);
 
@@ -307,7 +307,7 @@ bool UnixIPCHost::OnMessage() {
 }
 
 bool UnixIPCHost::OnGattWrite() {
-  Uuid::Uuid128Bit id;
+  UUID::UUID128Bit id;
   int r = read(pfds_[kFdGatt].fd, id.data(), id.size());
   if (r != id.size()) {
     LOG_ERROR(LOG_TAG, "Error reading GATT attribute ID");
@@ -317,7 +317,7 @@ bool UnixIPCHost::OnGattWrite() {
   std::vector<uint8_t> value;
   // TODO(icoolidge): Generalize this for multiple clients.
   auto server = gatt_servers_.begin();
-  server->second->GetCharacteristicValue(Uuid(id), &value);
+  server->second->GetCharacteristicValue(UUID(id), &value);
   const std::string value_string(value.begin(), value.end());
   std::string encoded_value;
   base::Base64Encode(value_string, &encoded_value);
diff --git a/system/service/test/uuid_unittest.cpp b/system/service/test/uuid_unittest.cpp
index 6e69a4817e..6f828c9552 100644
--- a/system/service/test/uuid_unittest.cpp
+++ b/system/service/test/uuid_unittest.cpp
@@ -25,99 +25,99 @@ using namespace bluetooth;
 
 namespace {
 
-const std::array<uint8_t, Uuid::kUuid128Octets> kBtSigBaseUuid = {
+const std::array<uint8_t, UUID::kUUID128Octets> kBtSigBaseUUID = {
     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
       0x80, 0x00, 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb, }
 };
 
 }  // namespace
 
-// Verify that an uninitialized Uuid is equal
+// Verify that an uninitialized UUID is equal
 // To the BT SIG Base UUID.
-TEST(UuidTest, DefaultUuid) {
-  Uuid uuid;
-  ASSERT_TRUE(uuid.GetFullBigEndian() == kBtSigBaseUuid);
+TEST(UUIDTest, DefaultUUID) {
+  UUID uuid;
+  ASSERT_TRUE(uuid.GetFullBigEndian() == kBtSigBaseUUID);
 }
 
 // Verify that we initialize a 16-bit UUID in a
 // way consistent with how we read it.
-TEST(UuidTest, Init16Bit) {
-  auto my_uuid_16 = kBtSigBaseUuid;
+TEST(UUIDTest, Init16Bit) {
+  auto my_uuid_16 = kBtSigBaseUUID;
   my_uuid_16[2] = 0xde;
   my_uuid_16[3] = 0xad;
-  Uuid uuid(Uuid::Uuid16Bit({{ 0xde, 0xad }}));
+  UUID uuid(UUID::UUID16Bit({{ 0xde, 0xad }}));
   ASSERT_TRUE(uuid.GetFullBigEndian() == my_uuid_16);
 }
 
 // Verify that we initialize a 16-bit UUID in a
 // way consistent with how we read it.
-TEST(UuidTest, Init16BitString) {
-  auto my_uuid_16 = kBtSigBaseUuid;
+TEST(UUIDTest, Init16BitString) {
+  auto my_uuid_16 = kBtSigBaseUUID;
   my_uuid_16[2] = 0xde;
   my_uuid_16[3] = 0xad;
-  Uuid uuid("dead");
+  UUID uuid("dead");
   ASSERT_TRUE(uuid.GetFullBigEndian() == my_uuid_16);
 }
 
 
 // Verify that we initialize a 32-bit UUID in a
 // way consistent with how we read it.
-TEST(UuidTest, Init32Bit) {
-  auto my_uuid_32 = kBtSigBaseUuid;
+TEST(UUIDTest, Init32Bit) {
+  auto my_uuid_32 = kBtSigBaseUUID;
   my_uuid_32[0] = 0xde;
   my_uuid_32[1] = 0xad;
   my_uuid_32[2] = 0xbe;
   my_uuid_32[3] = 0xef;
-  Uuid uuid(Uuid::Uuid32Bit({{ 0xde, 0xad, 0xbe, 0xef }}));
+  UUID uuid(UUID::UUID32Bit({{ 0xde, 0xad, 0xbe, 0xef }}));
   ASSERT_TRUE(uuid.GetFullBigEndian() == my_uuid_32);
 }
 
 // Verify correct reading of a 32-bit UUID initialized from string.
-TEST(UuidTest, Init32BitString) {
-  auto my_uuid_32 = kBtSigBaseUuid;
+TEST(UUIDTest, Init32BitString) {
+  auto my_uuid_32 = kBtSigBaseUUID;
   my_uuid_32[0] = 0xde;
   my_uuid_32[1] = 0xad;
   my_uuid_32[2] = 0xbe;
   my_uuid_32[3] = 0xef;
-  Uuid uuid("deadbeef");
+  UUID uuid("deadbeef");
   ASSERT_TRUE(uuid.GetFullBigEndian() == my_uuid_32);
 }
 
 // Verify that we initialize a 128-bit UUID in a
 // way consistent with how we read it.
-TEST(UuidTest, Init128Bit) {
-  auto my_uuid_128 = kBtSigBaseUuid;
+TEST(UUIDTest, Init128Bit) {
+  auto my_uuid_128 = kBtSigBaseUUID;
   for (int i = 0; i < static_cast<int>(my_uuid_128.size()); ++i) {
     my_uuid_128[i] = i;
   }
 
-  Uuid uuid(my_uuid_128);
+  UUID uuid(my_uuid_128);
   ASSERT_TRUE(uuid.GetFullBigEndian() == my_uuid_128);
 }
 
 // Verify that we initialize a 128-bit UUID in a
 // way consistent with how we read it as LE.
-TEST(UuidTest, Init128BitLittleEndian) {
-  auto my_uuid_128 = kBtSigBaseUuid;
+TEST(UUIDTest, Init128BitLittleEndian) {
+  auto my_uuid_128 = kBtSigBaseUUID;
   for (int i = 0; i < static_cast<int>(my_uuid_128.size()); ++i) {
     my_uuid_128[i] = i;
   }
 
-  Uuid uuid(my_uuid_128);
+  UUID uuid(my_uuid_128);
   std::reverse(my_uuid_128.begin(), my_uuid_128.end());
   ASSERT_TRUE(uuid.GetFullLittleEndian() == my_uuid_128);
 }
 
 // Verify that we initialize a 128-bit UUID in a
 // way consistent with how we read it.
-TEST(UuidTest, Init128BitString) {
-  auto my_uuid_128 = kBtSigBaseUuid;
+TEST(UUIDTest, Init128BitString) {
+  auto my_uuid_128 = kBtSigBaseUUID;
   for (int i = 0; i < static_cast<int>(my_uuid_128.size()); ++i) {
     my_uuid_128[i] = i;
   }
 
   std::string uuid_text("000102030405060708090A0B0C0D0E0F");
   ASSERT_TRUE(uuid_text.size() == (16 * 2));
-  Uuid uuid(uuid_text);
+  UUID uuid(uuid_text);
   ASSERT_TRUE(uuid.GetFullBigEndian() == my_uuid_128);
 }
diff --git a/system/service/uuid.cpp b/system/service/uuid.cpp
index c48ba5e087..74009c49a7 100644
--- a/system/service/uuid.cpp
+++ b/system/service/uuid.cpp
@@ -13,7 +13,8 @@
 //  See the License for the specific language governing permissions and
 //  limitations under the License.
 //
-#include "uuid.h"
+
+#include "service/uuid.h"
 
 #include <algorithm>
 #include <array>
@@ -22,17 +23,17 @@
 
 namespace bluetooth {
 
-void Uuid::InitializeDefault() {
+void UUID::InitializeDefault() {
   // Initialize to base bluetooth UUID.
   id_ = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
          0x80, 0x00, 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb}};
 }
 
-Uuid::Uuid() {
+UUID::UUID() {
   InitializeDefault();
 }
 
-Uuid::Uuid(const std::string& uuid) {
+UUID::UUID(const std::string& uuid) {
   InitializeDefault();
   const int start_index = uuid.size() == 4 ? 2 : 0;
   const size_t copy_size = std::min(id_.size(), uuid.size() / 2);
@@ -42,44 +43,44 @@ Uuid::Uuid(const std::string& uuid) {
   }
 }
 
-Uuid::Uuid(const bt_uuid_t& uuid) {
+UUID::UUID(const bt_uuid_t& uuid) {
   std::reverse_copy(uuid.uu, uuid.uu + sizeof(uuid.uu), id_.begin());
 }
 
-Uuid::Uuid(const Uuid::Uuid16Bit& uuid) {
+UUID::UUID(const UUID::UUID16Bit& uuid) {
   InitializeDefault();
-  std::copy(uuid.begin(), uuid.end(), id_.begin() + kUuid16Octets);
+  std::copy(uuid.begin(), uuid.end(), id_.begin() + kUUID16Octets);
 }
 
-Uuid::Uuid(const Uuid::Uuid32Bit& uuid) {
+UUID::UUID(const UUID::UUID32Bit& uuid) {
   InitializeDefault();
   std::copy(uuid.begin(), uuid.end(), id_.begin());
 }
 
-Uuid::Uuid(const Uuid::Uuid128Bit& uuid) : id_(uuid) {}
+UUID::UUID(const UUID::UUID128Bit& uuid) : id_(uuid) {}
 
-const Uuid::Uuid128Bit Uuid::GetFullBigEndian() const {
+const UUID::UUID128Bit UUID::GetFullBigEndian() const {
   return id_;
 }
 
-const Uuid::Uuid128Bit Uuid::GetFullLittleEndian() const {
-  Uuid::Uuid128Bit ret;
+const UUID::UUID128Bit UUID::GetFullLittleEndian() const {
+  UUID::UUID128Bit ret;
   std::reverse_copy(id_.begin(), id_.end(), ret.begin());
   return ret;
 }
 
-const bt_uuid_t Uuid::GetBlueDroid() const {
+const bt_uuid_t UUID::GetBlueDroid() const {
   bt_uuid_t ret;
   std::reverse_copy(id_.begin(), id_.end(), ret.uu);
   return ret;
 }
 
-bool Uuid::operator<(const Uuid& rhs) const {
+bool UUID::operator<(const UUID& rhs) const {
   return std::lexicographical_compare(id_.begin(), id_.end(), rhs.id_.begin(),
                                       rhs.id_.end());
 }
 
-bool Uuid::operator==(const Uuid& rhs) const {
+bool UUID::operator==(const UUID& rhs) const {
   return std::equal(id_.begin(), id_.end(), rhs.id_.begin());
 }
 
diff --git a/system/service/uuid.h b/system/service/uuid.h
index 0226ef623d..929294f848 100644
--- a/system/service/uuid.h
+++ b/system/service/uuid.h
@@ -13,6 +13,7 @@
 //  See the License for the specific language governing permissions and
 //  limitations under the License.
 //
+
 #pragma once
 
 #include <array>
@@ -22,48 +23,48 @@
 
 namespace bluetooth {
 
-class Uuid {
+class UUID {
  public:
   enum Type {
-    kUuid128Octets = 16,
-    kUuid32Octets = 4,
-    kUuid16Octets = 2,
+    kUUID128Octets = 16,
+    kUUID32Octets = 4,
+    kUUID16Octets = 2,
   };
 
-  typedef std::array<uint8_t, Uuid::kUuid16Octets> Uuid16Bit;
-  typedef std::array<uint8_t, Uuid::kUuid32Octets> Uuid32Bit;
-  typedef std::array<uint8_t, Uuid::kUuid128Octets> Uuid128Bit;
+  typedef std::array<uint8_t, UUID::kUUID16Octets> UUID16Bit;
+  typedef std::array<uint8_t, UUID::kUUID32Octets> UUID32Bit;
+  typedef std::array<uint8_t, UUID::kUUID128Octets> UUID128Bit;
 
   // Construct a Bluetooth 'base' UUID.
-  Uuid();
+  UUID();
 
   // BlueDroid constructor.
-  explicit Uuid(const bt_uuid_t& uuid);
+  explicit UUID(const bt_uuid_t& uuid);
 
   // String constructor. Only hex ASCII accepted.
-  explicit Uuid(const std::string& uuid);
+  explicit UUID(const std::string& uuid);
 
   // std::array variants constructors.
-  explicit Uuid(const Uuid::Uuid16Bit& uuid);
-  explicit Uuid(const Uuid::Uuid32Bit& uuid);
-  explicit Uuid(const Uuid::Uuid128Bit& uuid);
+  explicit UUID(const UUID::UUID16Bit& uuid);
+  explicit UUID(const UUID::UUID32Bit& uuid);
+  explicit UUID(const UUID::UUID128Bit& uuid);
 
   // Provide the full network-byte-ordered blob.
-  const Uuid128Bit GetFullBigEndian() const;
+  const UUID128Bit GetFullBigEndian() const;
 
   // Provide blob in Little endian (BlueDroid expects this).
-  const Uuid128Bit GetFullLittleEndian() const;
+  const UUID128Bit GetFullLittleEndian() const;
 
   // Helper for bluedroid LE type.
   const bt_uuid_t GetBlueDroid() const;
 
-  bool operator<(const Uuid& rhs) const;
-  bool operator==(const Uuid& rhs) const;
+  bool operator<(const UUID& rhs) const;
+  bool operator==(const UUID& rhs) const;
 
  private:
   void InitializeDefault();
   // Network-byte-ordered ID.
-  Uuid128Bit id_;
+  UUID128Bit id_;
 };
 
 }  // namespace bluetooth