Merge remote-tracking branch 'origin/main' into releases/v50.x

Author: ddiproietto

BUILD

@@ -1682,6 +1682,7 @@ perfetto_filegroup(
         "src/trace_processor/dataframe/impl/query_plan.cc",
         "src/trace_processor/dataframe/impl/query_plan.h",
         "src/trace_processor/dataframe/impl/slab.h",
+        "src/trace_processor/dataframe/impl/static_vector.h",
         "src/trace_processor/dataframe/impl/types.h",
     ],
 )

CHANGELOG

@@ -11,6 +11,11 @@ Unreleased:
     *
 
 
+v50.1 - 2025-04-17:
+  Trace Processor:
+    * Fix build on windows
+
+
 v50.0 - 2025-04-17:
   Tracing service and probes:
     * Removed mm_events support as it is no longer maintained.

include/perfetto/ext/base/http/http_server.h

@@ -160,7 +160,6 @@ class HttpServer : public UnixSocket::EventListener {
   HttpServer(TaskRunner*, HttpRequestHandler*);
   ~HttpServer() override;
   void Start(int port);
-  void Start(const std::string& listen_ip, int port);
   void AddAllowedOrigin(const std::string&);
 
  private:
@@ -169,9 +168,6 @@ class HttpServer : public UnixSocket::EventListener {
   void HandleCorsPreflightRequest(const HttpRequest&);
   bool IsOriginAllowed(StringView);
 
-  void ListenOnIpV4(const std::string& ip_addr);
-  void ListenOnIpV6(const std::string& ip_addr);
-
   // UnixSocket::EventListener implementation.
   void OnNewIncomingConnection(UnixSocket*,
                                std::unique_ptr<UnixSocket>) override;

include/perfetto/ext/base/unix_socket.h

@@ -74,7 +74,7 @@ enum class SockPeerCredMode {
 #endif
 };
 
-// Returns the socket family from the full address that perfetto uses.
+// Returns the socket family from the full addres that perfetto uses.
 // Addr can be:
 // - /path/to/socket : for linked AF_UNIX sockets.
 // - @abstract_name  : for abstract AF_UNIX sockets.
@@ -83,25 +83,6 @@ enum class SockPeerCredMode {
 // - vsock://-1:3000 : for VM sockets.
 SockFamily GetSockFamily(const char* addr);
 
-// NetAddrInfo is a wrapper for a full address and it's family
-// and type.
-struct NetAddrInfo {
-  NetAddrInfo(const std::string& ip_port, SockFamily family, SockType type)
-      : ip_port_(ip_port), family_(family), type_(type) {}
-  std::string ip_port_;  // full address with ip and port
-  SockFamily family_;    // socket family
-  SockType type_;        // socket type
-};
-
-// Returns a list of NetAddrInfo from ip and port which
-// ip can be an ipv4 or an ipv6 or a domain.
-// 127.0.0.1    : ipv4 address
-// localhost    : domain
-// ::1          : ipv6 address
-// port is a normal tcp port as string.
-std::vector<NetAddrInfo> GetNetAddrInfo(const std::string& ip,
-                                        const std::string& port);
-
 // Returns whether inter-process shared memory is supported for the socket.
 inline bool SockShmemSupported(SockFamily sock_family) {
 #if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)

protos/third_party/chromium/chrome_track_event.proto

@@ -2386,7 +2386,7 @@ message InputTransferHandler {
   // LINT.IfChange(TransferInputToVizResult)
   enum TransferInputToVizResult {
     // We don't expect this to be present in traces.
-    UNKNWON = 0;
+    UNKNOWN = 0;
     SUCCESSFULLY_TRANSFERRED = 1;
     INPUT_TRANSFER_HANDLER_NOT_FOUND_IN_MAP = 2;
     NON_FINGER_TOOL_TYPE = 3;

src/base/http/http_server.cc

@@ -56,45 +56,23 @@ void HttpServer::Start(int port) {
   std::string ipv4_addr = "127.0.0.1:" + std::to_string(port);
   std::string ipv6_addr = "[::1]:" + std::to_string(port);
 
-  ListenOnIpV4(ipv4_addr);
-  ListenOnIpV6(ipv6_addr);
-}
-
-void HttpServer::ListenOnIpV4(const std::string& ip_addr) {
-  sock4_ = UnixSocket::Listen(ip_addr, this, task_runner_, SockFamily::kInet,
+  sock4_ = UnixSocket::Listen(ipv4_addr, this, task_runner_, SockFamily::kInet,
                               SockType::kStream);
   bool ipv4_listening = sock4_ && sock4_->is_listening();
   if (!ipv4_listening) {
-    PERFETTO_PLOG("Failed to listen on IPv4 socket: \"%s\"", ip_addr.c_str());
+    PERFETTO_PLOG("Failed to listen on IPv4 socket: \"%s\"", ipv4_addr.c_str());
     sock4_.reset();
   }
-}
 
-void HttpServer::ListenOnIpV6(const std::string& ip_addr) {
-  sock6_ = UnixSocket::Listen(ip_addr, this, task_runner_, SockFamily::kInet6,
+  sock6_ = UnixSocket::Listen(ipv6_addr, this, task_runner_, SockFamily::kInet6,
                               SockType::kStream);
   bool ipv6_listening = sock6_ && sock6_->is_listening();
   if (!ipv6_listening) {
-    PERFETTO_PLOG("Failed to listen on IPv6 socket: \"%s\"", ip_addr.c_str());
+    PERFETTO_PLOG("Failed to listen on IPv6 socket: \"%s\"", ipv6_addr.c_str());
     sock6_.reset();
   }
 }
 
-void HttpServer::Start(const std::string& listen_ip, int port) {
-  std::string ip = listen_ip.empty() ? "localhost" : listen_ip;
-  std::string port_str = std::to_string(port);
-  std::vector<NetAddrInfo> addr_infos = GetNetAddrInfo(ip, port_str);
-  for (NetAddrInfo& info : addr_infos) {
-    if (info.family_ == SockFamily::kInet) {
-      PERFETTO_ILOG("[HTTP] Starting HTTP server on %s", info.ip_port_.c_str());
-      ListenOnIpV4(info.ip_port_);
-    } else if (info.family_ == SockFamily::kInet6) {
-      PERFETTO_ILOG("[HTTP] Starting HTTP server on %s", info.ip_port_.c_str());
-      ListenOnIpV6(info.ip_port_);
-    }
-  }
-}
-
 void HttpServer::AddAllowedOrigin(const std::string& origin) {
   allowed_origins_.emplace_back(origin);
 }

src/base/unix_socket.cc

@@ -257,43 +257,17 @@ SockaddrAny MakeSockAddr(SockFamily family, const std::string& socket_name) {
   PERFETTO_CHECK(false);  // For GCC.
 }
 
-void InitWinSockOnce() {
+ScopedSocketHandle CreateSocketHandle(SockFamily family, SockType type) {
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
   static bool init_winsock_once = [] {
     WSADATA ignored{};
     return WSAStartup(MAKEWORD(2, 2), &ignored) == 0;
   }();
   PERFETTO_CHECK(init_winsock_once);
 #endif
-}
-
-ScopedSocketHandle CreateSocketHandle(SockFamily family, SockType type) {
-  InitWinSockOnce();
   return ScopedSocketHandle(socket(MkSockFamily(family), MkSockType(type), 0));
 }
 
-std::string AddrinfoToIpStr(const struct addrinfo* addrinfo_ptr) {
-  PERFETTO_CHECK(addrinfo_ptr && addrinfo_ptr->ai_addr);
-  PERFETTO_CHECK((addrinfo_ptr->ai_family == AF_INET) ||
-                 (addrinfo_ptr->ai_family == AF_INET6));
-
-  void* addr_ptr = nullptr;
-  char ip_str_buffer[INET6_ADDRSTRLEN];
-
-  if (addrinfo_ptr->ai_family == AF_INET) {  // IPv4
-    struct sockaddr_in* ipv4_addr =
-        reinterpret_cast<struct sockaddr_in*>(addrinfo_ptr->ai_addr);
-    addr_ptr = &(ipv4_addr->sin_addr);
-  } else if (addrinfo_ptr->ai_family == AF_INET6) {  // IPv6
-    struct sockaddr_in6* ipv6_addr =
-        reinterpret_cast<struct sockaddr_in6*>(addrinfo_ptr->ai_addr);
-    addr_ptr = &(ipv6_addr->sin6_addr);
-  }
-  PERFETTO_CHECK(inet_ntop(addrinfo_ptr->ai_family, addr_ptr, ip_str_buffer,
-                           sizeof(ip_str_buffer)) != NULL);
-  return std::string(ip_str_buffer);
-}
-
 }  // namespace
 
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
@@ -325,32 +299,6 @@ SockFamily GetSockFamily(const char* addr) {
   return SockFamily::kUnix;  // For anything else assume it's a linked AF_UNIX.
 }
 
-std::vector<NetAddrInfo> GetNetAddrInfo(const std::string& ip,
-                                        const std::string& port) {
-  InitWinSockOnce();
-  struct addrinfo hints, *serv_info, *p;
-  memset(&hints, 0, sizeof hints);
-  hints.ai_family = AF_UNSPEC;
-  hints.ai_socktype = SOCK_STREAM;
-  hints.ai_flags = AI_PASSIVE;
-  PERFETTO_CHECK(getaddrinfo(ip.c_str(), port.c_str(), &hints, &serv_info) ==
-                 0);
-  std::vector<NetAddrInfo> res;
-  for (p = serv_info; p != NULL; p = p->ai_next) {
-    if (p->ai_family == AF_INET) {
-      std::string ip_str = AddrinfoToIpStr(p);
-      std::string ip_port = ip_str + ":" + port;
-      res.emplace_back(ip_port, SockFamily::kInet, SockType::kStream);
-    } else if (p->ai_family == AF_INET6) {
-      std::string ip_str = AddrinfoToIpStr(p);
-      std::string ip_port = "[" + ip_str + "]:" + port;
-      res.emplace_back(ip_port, SockFamily::kInet6, SockType::kStream);
-    }
-  }
-  freeaddrinfo(serv_info);
-  return res;
-}
-
 // +-----------------------+
 // | UnixSocketRaw methods |
 // +-----------------------+

src/trace_processor/dataframe/dataframe.h

@@ -29,6 +29,7 @@
 #include "src/trace_processor/containers/string_pool.h"
 #include "src/trace_processor/dataframe/cursor.h"
 #include "src/trace_processor/dataframe/impl/query_plan.h"
+#include "src/trace_processor/dataframe/impl/static_vector.h"
 #include "src/trace_processor/dataframe/impl/types.h"
 #include "src/trace_processor/dataframe/specs.h"
 
@@ -139,9 +140,10 @@ class Dataframe {
   std::vector<ColumnSpec> CreateColumnSpecs() const {
     std::vector<ColumnSpec> specs;
     specs.reserve(columns_.size());
-    for (const auto& col : columns_) {
-      specs.push_back({col.name, col.storage.type(), col.overlay.nullability(),
-                       col.sort_state});
+    for (uint32_t i = 0; i < columns_.size(); ++i) {
+      const auto& col = columns_[i];
+      specs.push_back({column_names_[i], col.storage.type(),
+                       col.null_storage.nullability(), col.sort_state});
     }
     return specs;
   }
@@ -153,15 +155,22 @@ class Dataframe {
   // dataframe.
   friend class DataframeBytecodeTest;
 
-  Dataframe(std::vector<impl::Column> columns,
+  Dataframe(impl::FixedVector<std::string, impl::kMaxColumns> column_names,
+            impl::FixedVector<impl::Column, impl::kMaxColumns> columns,
             uint32_t row_count,
             StringPool* string_pool)
-      : columns_(std::move(columns)),
+      : column_names_(std::move(column_names)),
+        columns_(std::move(columns)),
         row_count_(row_count),
         string_pool_(string_pool) {}
 
+  // The names of all columns.
+  // `column_names_` and `columns_` should always have the same size.
+  impl::FixedVector<std::string, impl::kMaxColumns> column_names_;
+
   // Internal storage for columns in the dataframe.
-  std::vector<impl::Column> columns_;
+  // `column_names_` and `columns_` should always have the same size.
+  impl::FixedVector<impl::Column, impl::kMaxColumns> columns_;
 
   // Number of rows in the dataframe.
   uint32_t row_count_ = 0;