Prefer no std:: prefixes on integer types

Specifically for `size_t` from `stddef.h` and `uint*_t`/`int*_t` types
from `stdint.h`.  Per the style guide: https://google.github.io/styleguide/cppguide.html#Integer_Types

Also, `Include What You Use` updates: https://google.github.io/styleguide/cppguide.html#Include_What_You_Use

Bug: 484413551

Author: cjreynol

base/cvd/cuttlefish/common/libs/concurrency/thread_safe_queue.h

@@ -1,5 +1,3 @@
-#pragma once
-
 /*
  * Copyright (C) 2016 The Android Open Source Project
  *
@@ -16,6 +14,10 @@
  * limitations under the License.
  */
 
+#pragma once
+
+#include <stddef.h>
+
 #include <condition_variable>
 #include <deque>
 #include <functional>
@@ -38,7 +40,7 @@ class ThreadSafeQueue {
   using QueueFullHandler = std::function<void(QueueImpl*)>;
 
   ThreadSafeQueue() = default;
-  explicit ThreadSafeQueue(std::size_t max_elements,
+  explicit ThreadSafeQueue(size_t max_elements,
                            QueueFullHandler max_elements_handler)
       : max_elements_{max_elements},
         max_elements_handler_{std::move(max_elements_handler)} {}
@@ -99,7 +101,7 @@ class ThreadSafeQueue {
   }
 
   std::mutex m_;
-  std::size_t max_elements_{};
+  size_t max_elements_{};
   QueueFullHandler max_elements_handler_{};
   std::condition_variable new_item_;
   QueueImpl items_;

base/cvd/cuttlefish/common/libs/confui/packet.cpp

@@ -15,8 +15,9 @@
 
 #include "cuttlefish/common/libs/confui/packet.h"
 
+#include <stdint.h>
+
 #include <algorithm>
-#include <cstdint>
 #include <optional>
 #include <string>
 #include <vector>
@@ -26,7 +27,7 @@
 namespace cuttlefish {
 namespace confui {
 namespace packet {
-static std::optional<std::vector<std::uint8_t>> ReadRawData(SharedFD s) {
+static std::optional<std::vector<uint8_t>> ReadRawData(SharedFD s) {
   if (!s->IsOpen()) {
     ConfUiLog(ERROR) << "file, socket, etc, is not open to read";
     return std::nullopt;
@@ -56,13 +57,13 @@ static std::optional<std::vector<std::uint8_t>> ReadRawData(SharedFD s) {
     ConfUiLog(ERROR) << "The length ReadRawData read does not match.";
     return std::nullopt;
   }
-  std::vector<std::uint8_t> result{buf.get(), buf.get() + nread};
+  std::vector<uint8_t> result{buf.get(), buf.get() + nread};
 
   return {result};
 }
 
 static std::optional<ParsedPacket> ParseRawData(
-    const std::vector<std::uint8_t>& data_to_parse) {
+    const std::vector<uint8_t>& data_to_parse) {
   /*
    * data_to_parse has 0 in it, so it is not exactly "your (text) std::string."
    * If we type-cast data_to_parse to std::string and use 3rd party std::string-
@@ -133,7 +134,7 @@ static std::optional<ParsedPacket> ParseRawData(
     if (len == 0) {
       // push null vector or whatever empty, appropriately-typed
       // container
-      data_to_return.emplace_back(std::vector<std::uint8_t>{});
+      data_to_return.emplace_back(std::vector<uint8_t>{});
       continue;
     }
     data_to_return.emplace_back(data_to_parse.begin() + pos,

base/cvd/cuttlefish/common/libs/confui/packet.h

@@ -15,8 +15,9 @@
 
 #pragma once
 
+#include <stdint.h>
+
 #include <algorithm>
-#include <cstdint>
 #include <optional>
 #include <string>
 #include <tuple>
@@ -91,7 +92,7 @@ Payload ToPayload(const std::string& cmd_str, const std::string& session_id,
     ss << sz << ":";
   }
   std::string header = ss.str();
-  std::vector<std::uint8_t> payload_buffer{header.begin(), header.end()};
+  std::vector<uint8_t> payload_buffer{header.begin(), header.end()};
   impl::AppendToBuffer(payload_buffer, std::forward<Args>(args)...);
 
   PayloadHeader ph;

base/cvd/cuttlefish/common/libs/confui/packet_types.h

@@ -15,7 +15,8 @@
 
 #pragma once
 
-#include <cstdint>
+#include <stdint.h>
+
 #include <sstream>
 #include <string>
 #include <tuple>
@@ -25,18 +26,18 @@ namespace cuttlefish {
 namespace confui {
 namespace packet {
 struct PayloadHeader {
-  std::uint32_t payload_length_;
+  uint32_t payload_length_;
 };
 
-using BufferType = std::vector<std::uint8_t>;
+using BufferType = std::vector<uint8_t>;
 
 // PayloadHeader + the byte size sent over the channel
 using Payload = std::tuple<PayloadHeader, BufferType>;
 
 // this is for short messages
 constexpr const ssize_t kMaxPayloadLength = 10000;
 
-using ConfUiPacketInfo = std::vector<std::vector<std::uint8_t>>;
+using ConfUiPacketInfo = std::vector<std::vector<uint8_t>>;
 struct ParsedPacket {
   std::string session_id_;
   std::string type_;

base/cvd/cuttlefish/common/libs/confui/protocol.cpp

@@ -15,6 +15,8 @@
 
 #include "cuttlefish/common/libs/confui/protocol.h"
 
+#include <stdint.h>
+
 #include <sstream>
 #include <vector>
 
@@ -132,16 +134,16 @@ bool SendAck(SharedFD fd, const std::string& session_id, const bool is_success,
 
 bool SendResponse(SharedFD fd, const std::string& session_id,
                   const UserResponse::type& plain_selection,
-                  const std::vector<std::uint8_t>& signed_response,
-                  const std::vector<std::uint8_t>& message) {
+                  const std::vector<uint8_t>& signed_response,
+                  const std::vector<uint8_t>& message) {
   ConfUiCliResponseMessage confui_msg{session_id, plain_selection,
                                       signed_response, message};
   return confui_msg.SendOver(fd);
 }
 
 bool SendStartCmd(SharedFD fd, const std::string& session_id,
                   const std::string& prompt_text,
-                  const std::vector<std::uint8_t>& extra_data,
+                  const std::vector<uint8_t>& extra_data,
                   const std::string& locale,
                   const std::vector<teeui::UIOption>& ui_opts) {
   ConfUiStartMessage confui_msg{session_id, prompt_text, extra_data, locale,

base/cvd/cuttlefish/common/libs/confui/protocol.h

@@ -15,7 +15,8 @@
 
 #pragma once
 
-#include <cstdint>
+#include <stdint.h>
+
 #include <memory>
 #include <string>
 #include <vector>
@@ -49,14 +50,14 @@ bool SendAck(SharedFD fd, const std::string& session_id, const bool is_success,
              const std::string& status_message);
 bool SendResponse(SharedFD fd, const std::string& session_id,
                   const UserResponse::type& plain_selection,
-                  const std::vector<std::uint8_t>& signed_response,
+                  const std::vector<uint8_t>& signed_response,
                   // signing is a function of message, key
-                  const std::vector<std::uint8_t>& message);
+                  const std::vector<uint8_t>& message);
 
 // for HAL
 bool SendStartCmd(SharedFD fd, const std::string& session_id,
                   const std::string& prompt_text,
-                  const std::vector<std::uint8_t>& extra_data,
+                  const std::vector<uint8_t>& extra_data,
                   const std::string& locale,
                   const std::vector<teeui::UIOption>& ui_opts);
 

base/cvd/cuttlefish/common/libs/confui/protocol_types.cpp

@@ -15,7 +15,8 @@
 
 #include "cuttlefish/common/libs/confui/protocol_types.h"
 
-#include <cstdint>
+#include <stdint.h>
+
 #include <map>
 #include <sstream>
 #include <unordered_map>
@@ -51,7 +52,7 @@ std::string ToDebugString(const ConfUiCmd& cmd, const bool is_verbose) {
 
 std::string ToString(const ConfUiCmd& cmd) { return ToDebugString(cmd, false); }
 
-ConfUiCmd ToCmd(std::uint32_t i) {
+ConfUiCmd ToCmd(uint32_t i) {
   std::vector<ConfUiCmd> all_cmds{
       ConfUiCmd::kStart,          ConfUiCmd::kStop,
       ConfUiCmd::kCliAck,         ConfUiCmd::kCliRespond,

base/cvd/cuttlefish/common/libs/confui/protocol_types.h

@@ -15,7 +15,8 @@
 
 #pragma once
 
-#include <cstdint>
+#include <stdint.h>
+
 #include <string>
 #include <utility>
 #include <vector>
@@ -32,7 +33,7 @@ namespace cuttlefish {
 namespace confui {
 // When you update this, please update all the utility functions
 // in conf.cpp: e.g. ToString, etc
-enum class ConfUiCmd : std::uint32_t {
+enum class ConfUiCmd : uint32_t {
   kUnknown = 100,
   kStart = 111,   // start rendering, send confirmation msg, & wait respond
   kStop = 112,    // start rendering, send confirmation msg, & wait respond
@@ -49,7 +50,7 @@ constexpr const ssize_t kMaxMessageLength = packet::kMaxPayloadLength;
 std::string ToString(const ConfUiCmd& cmd);
 std::string ToDebugString(const ConfUiCmd& cmd, const bool is_verbose);
 ConfUiCmd ToCmd(const std::string& cmd_str);
-ConfUiCmd ToCmd(std::uint32_t i);
+ConfUiCmd ToCmd(uint32_t i);
 
 std::string ToString(const teeui::UIOption ui_opt);
 std::optional<teeui::UIOption> ToUiOption(const std::string&);
@@ -136,8 +137,8 @@ class ConfUiCliResponseMessage : public ConfUiMessage {
  public:
   ConfUiCliResponseMessage(const std::string& session_id,
                            const UserResponse::type& response,
-                           const std::vector<std::uint8_t>& sign = {},
-                           const std::vector<std::uint8_t>& msg = {})
+                           const std::vector<uint8_t>& sign = {},
+                           const std::vector<uint8_t>& msg = {})
       : ConfUiMessage(session_id),
         response_(response),
         sign_(sign),
@@ -152,16 +153,16 @@ class ConfUiCliResponseMessage : public ConfUiMessage {
 
  private:
   UserResponse::type response_;     // plain format
-  std::vector<std::uint8_t> sign_;  // signed format
+  std::vector<uint8_t> sign_;       // signed format
   // second argument to pass via resultCB of promptUserConfirmation
-  std::vector<std::uint8_t> message_;
+  std::vector<uint8_t> message_;
 };
 
 class ConfUiStartMessage : public ConfUiMessage {
  public:
   ConfUiStartMessage(const std::string session_id,
                      const std::string& prompt_text = "",
-                     const std::vector<std::uint8_t>& extra_data = {},
+                     const std::vector<uint8_t>& extra_data = {},
                      const std::string& locale = "C",
                      const std::vector<teeui::UIOption> ui_opts = {})
       : ConfUiMessage(session_id),
@@ -173,14 +174,14 @@ class ConfUiStartMessage : public ConfUiMessage {
   std::string ToString() const override;
   ConfUiCmd GetType() const override { return ConfUiCmd::kStart; }
   std::string GetPromptText() const { return prompt_text_; }
-  std::vector<std::uint8_t> GetExtraData() const { return extra_data_; }
+  std::vector<uint8_t> GetExtraData() const { return extra_data_; }
   std::string GetLocale() const { return locale_; }
   std::vector<teeui::UIOption> GetUiOpts() const { return ui_opts_; }
   bool SendOver(SharedFD fd) override;
 
  private:
   std::string prompt_text_;
-  std::vector<std::uint8_t> extra_data_;
+  std::vector<uint8_t> extra_data_;
   std::string locale_;
   std::vector<teeui::UIOption> ui_opts_;
 

base/cvd/cuttlefish/common/libs/fs/shared_fd_stream.cpp

@@ -16,6 +16,8 @@
 
 #include "cuttlefish/common/libs/fs/shared_fd_stream.h"
 
+#include <stddef.h>
+
 #include <cstdio>
 #include <streambuf>
 
@@ -87,7 +89,7 @@ int SharedFDStreambuf::overflow(int c) {
 std::streamsize SharedFDStreambuf::xsputn(const char* source,
                                           std::streamsize count) {
   return static_cast<std::streamsize>(
-      WriteAll(shared_fd_, source, static_cast<std::size_t>(count)));
+      WriteAll(shared_fd_, source, static_cast<size_t>(count)));
 }
 
 int SharedFDStreambuf::pbackfail(int c) {

base/cvd/cuttlefish/common/libs/security/confui_sign.cpp

@@ -16,7 +16,8 @@
 
 #include "cuttlefish/common/libs/security/confui_sign.h"
 
-#include <cstdint>
+#include <stdint.h>
+
 #include <optional>
 #include <vector>
 
@@ -25,7 +26,7 @@
 namespace cuttlefish {
 bool ConfUiSignerImpl::Send(SharedFD output,
                             const confui::SignMessageError error,
-                            const std::vector<std::uint8_t>& payload) {
+                            const std::vector<uint8_t>& payload) {
 #define SET_FLAG_AND_RETURN_SEND \
   sign_status_ |= kIoError;      \
   return false
@@ -75,7 +76,7 @@ std::optional<confui::SignRawMessage> ConfUiSignerImpl::Receive(
     return std::nullopt;
   }
 
-  std::vector<std::uint8_t> buffer(payload_size);
+  std::vector<uint8_t> buffer(payload_size);
   char* buf_data = reinterpret_cast<char*>(buffer.data());
   n_read = ReadExact(input, buf_data, payload_size);
   if (n_read != payload_size) {
@@ -91,15 +92,15 @@ std::optional<confui::SignRawMessage> ConfUiSignSender::Receive() {
 }
 
 bool ConfUiSignSender::Send(const SignMessageError error,
-                            const std::vector<std::uint8_t>& encoded_hmac) {
+                            const std::vector<uint8_t>& encoded_hmac) {
   if (!impl_.IsOk()) {
     return false;
   }
   impl_.Send(server_fd_, error, encoded_hmac);
   return impl_.IsOk();
 }
 
-bool ConfUiSignRequester::Request(const std::vector<std::uint8_t>& message) {
+bool ConfUiSignRequester::Request(const std::vector<uint8_t>& message) {
   impl_.Send(client_fd_, confui::SignMessageError::kOk, message);
   return impl_.IsOk();
 }