Remove SockaddrStorage::addr member

Removing SockaddrStorage::addr member as it always points to &addr_storage. This removes RAW_PTR_EXCLUSION, saves a tiny amount of memory, and also let us remove the custom copy constructor. An accessor addr has been added.

Bug: 40277966
Change-Id: I3b8c7c1eaa9ff0f60fc0f212686a6ca5df59c549
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6063822
Reviewed-by: Adam Rice <ricea@chromium.org>
Reviewed-by: Erik Chen <erikchen@chromium.org>
Commit-Queue: Mainak Bhattacharjee <mabhatta@microsoft.com>
Cr-Commit-Position: refs/heads/main@{#1395763}

chrome/browser/local_discovery/service_discovery_client_mac_unittest.mm

@@ -156,9 +156,9 @@ TEST_F(ServiceDiscoveryClientMacTest, ParseServiceRecord) {
   ASSERT_TRUE(ip_address.AssignFromIPLiteral(kIp));
   net::IPEndPoint endpoint(ip_address, kPort);
   net::SockaddrStorage storage;
-  ASSERT_TRUE(endpoint.ToSockAddr(storage.addr, &storage.addr_len));
-  NSData* discoveryHost =
-      [NSData dataWithBytes:storage.addr length:storage.addr_len];
+  ASSERT_TRUE(endpoint.ToSockAddr(storage.addr(), &storage.addr_len));
+  NSData* discoveryHost = [NSData dataWithBytes:storage.addr()
+                                         length:storage.addr_len];
   NSArray* addresses = @[ discoveryHost ];
   [test_service setAddresses:addresses];
 
@@ -194,9 +194,9 @@ TEST_F(ServiceDiscoveryClientMacTest, ParseInvalidUnicodeRecord) {
   ASSERT_TRUE(ip_address.AssignFromIPLiteral(kIp));
   net::IPEndPoint endpoint(ip_address, kPort);
   net::SockaddrStorage storage;
-  ASSERT_TRUE(endpoint.ToSockAddr(storage.addr, &storage.addr_len));
-  NSData* discovery_host =
-      [NSData dataWithBytes:storage.addr length:storage.addr_len];
+  ASSERT_TRUE(endpoint.ToSockAddr(storage.addr(), &storage.addr_len));
+  NSData* discovery_host = [NSData dataWithBytes:storage.addr()
+                                          length:storage.addr_len];
   NSArray* addresses = @[ discovery_host ];
   [test_service setAddresses:addresses];
 

mojo/public/cpp/platform/named_platform_channel_posix.cc

@@ -107,7 +107,7 @@ PlatformChannelServerEndpoint NamedPlatformChannel::CreateServerEndpoint(
     return PlatformChannelServerEndpoint();
 
   // Bind the socket.
-  if (bind(handle.GetFD().get(), storage.addr, storage.addr_len) < 0) {
+  if (bind(handle.GetFD().get(), storage.addr(), storage.addr_len) < 0) {
     PLOG(ERROR) << "bind " << name;
     return PlatformChannelServerEndpoint();
   }
@@ -137,8 +137,8 @@ PlatformChannelEndpoint NamedPlatformChannel::CreateClientEndpoint(
   if (!handle.is_valid())
     return PlatformChannelEndpoint();
 
-  if (HANDLE_EINTR(
-          connect(handle.GetFD().get(), storage.addr, storage.addr_len)) < 0) {
+  if (HANDLE_EINTR(connect(handle.GetFD().get(), storage.addr(),
+                           storage.addr_len)) < 0) {
     VPLOG(1) << "connect " << options.server_name;
     return PlatformChannelEndpoint();
   }

net/base/address_list_unittest.cc

@@ -58,7 +58,7 @@ TEST(AddressListTest, CreateFromAddrinfo) {
   std::array<addrinfo, kNumElements> ai;
   for (unsigned i = 0; i < kNumElements; ++i) {
     struct sockaddr_in* addr =
-        reinterpret_cast<struct sockaddr_in*>(storage[i].addr);
+        reinterpret_cast<struct sockaddr_in*>(storage[i].addr());
     storage[i].addr_len = sizeof(struct sockaddr_in);
     // Populating the address with { i, i, i, i }.
     memset(&addr->sin_addr, i, IPAddress::kIPv4AddressSize);
@@ -69,7 +69,7 @@ TEST(AddressListTest, CreateFromAddrinfo) {
     ai[i].ai_family = addr->sin_family;
     ai[i].ai_socktype = SOCK_STREAM;
     ai[i].ai_addrlen = storage[i].addr_len;
-    ai[i].ai_addr = storage[i].addr;
+    ai[i].ai_addr = storage[i].addr();
     if (i + 1 < kNumElements)
       ai[i].ai_next = &ai[i + 1];
   }

net/base/ip_endpoint_unittest.cc

@@ -164,22 +164,22 @@ TEST_F(IPEndPointTest, ToFromSockAddr) {
 
     // Convert to a sockaddr.
     SockaddrStorage storage;
-    EXPECT_TRUE(ip_endpoint.ToSockAddr(storage.addr, &storage.addr_len));
+    EXPECT_TRUE(ip_endpoint.ToSockAddr(storage.addr(), &storage.addr_len));
 
     // Basic verification.
     socklen_t expected_size =
         test.ipv6 ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in);
     EXPECT_EQ(expected_size, storage.addr_len);
     EXPECT_EQ(ip_endpoint.port(),
-              GetPortFromSockaddr(storage.addr, storage.addr_len));
+              GetPortFromSockaddr(storage.addr(), storage.addr_len));
     if (test.ipv6) {
       uint32_t scope_id =
-          reinterpret_cast<struct sockaddr_in6*>(storage.addr)->sin6_scope_id;
+          reinterpret_cast<struct sockaddr_in6*>(storage.addr())->sin6_scope_id;
       EXPECT_EQ(scope_id, test.scope_id.value_or(0));
     }
     // And convert back to an IPEndPoint.
     IPEndPoint ip_endpoint2;
-    EXPECT_TRUE(ip_endpoint2.FromSockAddr(storage.addr, storage.addr_len));
+    EXPECT_TRUE(ip_endpoint2.FromSockAddr(storage.addr(), storage.addr_len));
     EXPECT_EQ(ip_endpoint.port(), ip_endpoint2.port());
     EXPECT_EQ(ip_endpoint.address(), ip_endpoint2.address());
     EXPECT_EQ(ip_endpoint.scope_id(), ip_endpoint2.scope_id());
@@ -193,7 +193,7 @@ TEST_F(IPEndPointTest, ToSockAddrBufTooSmall) {
 
     SockaddrStorage storage;
     storage.addr_len = 3;  // size is too small!
-    EXPECT_FALSE(ip_endpoint.ToSockAddr(storage.addr, &storage.addr_len));
+    EXPECT_FALSE(ip_endpoint.ToSockAddr(storage.addr(), &storage.addr_len));
   }
 }
 
@@ -246,7 +246,7 @@ TEST_F(IPEndPointTest, WinBluetoothSockAddrCompareWithSelf) {
   EXPECT_DCHECK_DEATH(bt_endpoint.port());
   SockaddrStorage storage;
   EXPECT_DCHECK_DEATH(
-      std::ignore = bt_endpoint.ToSockAddr(storage.addr, &storage.addr_len));
+      std::ignore = bt_endpoint.ToSockAddr(storage.addr(), &storage.addr_len));
   EXPECT_DCHECK_DEATH(bt_endpoint.ToString());
   EXPECT_DCHECK_DEATH(bt_endpoint.ToStringWithoutPort());
 }
@@ -291,7 +291,7 @@ TEST_F(IPEndPointTest, WinBluetoothSockAddrCompareWithCopy) {
   EXPECT_DCHECK_DEATH(bt_endpoint_other.port());
   SockaddrStorage storage;
   EXPECT_DCHECK_DEATH(std::ignore = bt_endpoint_other.ToSockAddr(
-                          storage.addr, &storage.addr_len));
+                          storage.addr(), &storage.addr_len));
   EXPECT_DCHECK_DEATH(bt_endpoint_other.ToString());
   EXPECT_DCHECK_DEATH(bt_endpoint_other.ToStringWithoutPort());
 }
@@ -322,7 +322,7 @@ TEST_F(IPEndPointTest, WinBluetoothSockAddrCompareWithDifferentPort) {
   EXPECT_DCHECK_DEATH(bt_endpoint_other.port());
   SockaddrStorage storage;
   EXPECT_DCHECK_DEATH(std::ignore = bt_endpoint_other.ToSockAddr(
-                          storage.addr, &storage.addr_len));
+                          storage.addr(), &storage.addr_len));
   EXPECT_DCHECK_DEATH(bt_endpoint_other.ToString());
   EXPECT_DCHECK_DEATH(bt_endpoint_other.ToStringWithoutPort());
 }
@@ -352,7 +352,7 @@ TEST_F(IPEndPointTest, WinBluetoothSockAddrCompareWithDifferentAddress) {
   EXPECT_DCHECK_DEATH(bt_endpoint_other.port());
   SockaddrStorage storage;
   EXPECT_DCHECK_DEATH(std::ignore = bt_endpoint_other.ToSockAddr(
-                          storage.addr, &storage.addr_len));
+                          storage.addr(), &storage.addr_len));
   EXPECT_DCHECK_DEATH(bt_endpoint_other.ToString());
   EXPECT_DCHECK_DEATH(bt_endpoint_other.ToStringWithoutPort());
 }

net/base/sockaddr_storage.cc

@@ -6,22 +6,22 @@
 
 #include <string.h>
 
+#include "base/containers/span.h"
+
 namespace net {
 
-SockaddrStorage::SockaddrStorage()
-    : addr_len(sizeof(addr_storage)),
-      addr(reinterpret_cast<struct sockaddr*>(&addr_storage)) {}
+SockaddrStorage::SockaddrStorage() : addr_len(sizeof(addr_storage)) {}
 
 SockaddrStorage::SockaddrStorage(const SockaddrStorage& other)
-    : addr_len(other.addr_len),
-      addr(reinterpret_cast<struct sockaddr*>(&addr_storage)) {
-  memcpy(addr, other.addr, addr_len);
+    : addr_len(other.addr_len) {
+  base::byte_span_from_ref(addr_storage)
+      .copy_from(base::byte_span_from_ref(other.addr_storage));
 }
 
 void SockaddrStorage::operator=(const SockaddrStorage& other) {
   addr_len = other.addr_len;
-  // addr is already set to &this->addr_storage by default ctor.
-  memcpy(addr, other.addr, addr_len);
+  base::byte_span_from_ref(addr_storage)
+      .copy_from(base::byte_span_from_ref(other.addr_storage));
 }
 
 }  // namespace net

net/base/sockaddr_storage.h

@@ -28,9 +28,12 @@ struct NET_EXPORT SockaddrStorage {
 
   struct sockaddr_storage addr_storage;
   socklen_t addr_len;
-  // This field is not a raw_ptr<> because of a rewriter issue not adding .get()
-  // in reinterpret_cast.
-  RAW_PTR_EXCLUSION struct sockaddr* const addr;
+
+  const sockaddr* addr() const {
+    return reinterpret_cast<const sockaddr*>(&addr_storage);
+  }
+
+  sockaddr* addr() { return reinterpret_cast<sockaddr*>(&addr_storage); }
 };
 
 }  // namespace net

net/base/sockaddr_util_posix.cc

@@ -31,7 +31,7 @@ bool FillUnixAddress(const std::string& socket_path,
     return false;
 
   struct sockaddr_un* socket_addr =
-      reinterpret_cast<struct sockaddr_un*>(address->addr);
+      reinterpret_cast<struct sockaddr_un*>(address->addr());
   memset(socket_addr, 0, address->addr_len);
   socket_addr->sun_family = AF_UNIX;
   address->addr_len = path_size + offsetof(struct sockaddr_un, sun_path);

net/base/sockaddr_util_posix_unittest.cc

@@ -45,7 +45,7 @@ TEST(FillUnixAddressTest, SimpleAddress) {
             (unsigned int)storage.addr_len);
 
   struct sockaddr_un* socket_addr =
-      reinterpret_cast<struct sockaddr_un*>(storage.addr);
+      reinterpret_cast<struct sockaddr_un*>(storage.addr());
   EXPECT_EQ(socket_addr->sun_family, AF_UNIX);
 
   // Implicit conversion to std::string for comparison is fine since the path
@@ -69,7 +69,7 @@ TEST(FillUnixAddressTest, AddressMaxLength) {
       FillUnixAddress(path, /*use_abstract_namespace=*/false, &storage));
 
   struct sockaddr_un* socket_addr =
-      reinterpret_cast<struct sockaddr_un*>(storage.addr);
+      reinterpret_cast<struct sockaddr_un*>(storage.addr());
   EXPECT_EQ(socket_addr->sun_family, AF_UNIX);
   EXPECT_EQ(socket_addr->sun_path, path);
 }
@@ -95,7 +95,7 @@ TEST(FillUnixAddressTest, AbstractLinuxAddress) {
             (unsigned int)storage.addr_len);
 
   struct sockaddr_un* socket_addr =
-      reinterpret_cast<struct sockaddr_un*>(storage.addr);
+      reinterpret_cast<struct sockaddr_un*>(storage.addr());
   EXPECT_EQ(socket_addr->sun_family, AF_UNIX);
 
   // The path buffer is preceded by a NUL character for abstract Linux

net/socket/socket_posix.cc

@@ -142,7 +142,7 @@ int SocketPosix::Bind(const SockaddrStorage& address) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(kInvalidSocket, socket_fd_);
 
-  int rv = bind(socket_fd_, address.addr, address.addr_len);
+  int rv = bind(socket_fd_, address.addr(), address.addr_len);
   if (rv < 0) {
     PLOG(ERROR) << "bind() failed";
     return MapSystemError(errno);
@@ -365,8 +365,9 @@ int SocketPosix::GetLocalAddress(SockaddrStorage* address) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(address);
 
-  if (getsockname(socket_fd_, address->addr, &address->addr_len) < 0)
+  if (getsockname(socket_fd_, address->addr(), &address->addr_len) < 0) {
     return MapSystemError(errno);
+  }
   return OK;
 }
 
@@ -431,9 +432,8 @@ void SocketPosix::OnFileCanWriteWithoutBlocking(int fd) {
 
 int SocketPosix::DoAccept(std::unique_ptr<SocketPosix>* socket) {
   SockaddrStorage new_peer_address;
-  int new_socket = HANDLE_EINTR(accept(socket_fd_,
-                                       new_peer_address.addr,
-                                       &new_peer_address.addr_len));
+  int new_socket = HANDLE_EINTR(
+      accept(socket_fd_, new_peer_address.addr(), &new_peer_address.addr_len));
   if (new_socket < 0)
     return MapAcceptError(errno);
 
@@ -459,9 +459,8 @@ void SocketPosix::AcceptCompleted() {
 }
 
 int SocketPosix::DoConnect() {
-  int rv = HANDLE_EINTR(connect(socket_fd_,
-                                peer_address_->addr,
-                                peer_address_->addr_len));
+  int rv = HANDLE_EINTR(
+      connect(socket_fd_, peer_address_->addr(), peer_address_->addr_len));
   DCHECK_GE(0, rv);
   return rv == 0 ? OK : MapConnectError(errno);
 }

net/socket/socket_tag_unittest.cc

@@ -70,7 +70,7 @@ TEST(SocketTagTest, Apply) {
   AddressList addr_list;
   ASSERT_TRUE(test_server.GetAddressList(&addr_list));
   SockaddrStorage addr;
-  ASSERT_TRUE(addr_list[0].ToSockAddr(addr.addr, &addr.addr_len));
+  ASSERT_TRUE(addr_list[0].ToSockAddr(addr.addr(), &addr.addr_len));
 
   // Create socket.
   int s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
@@ -81,7 +81,7 @@ TEST(SocketTagTest, Apply) {
   uint64_t old_traffic = GetTaggedBytes(tag_val1);
   SocketTag tag1(SocketTag::UNSET_UID, tag_val1);
   tag1.Apply(s);
-  ASSERT_EQ(connect(s, addr.addr, addr.addr_len), 0);
+  ASSERT_EQ(connect(s, addr.addr(), addr.addr_len), 0);
   EXPECT_GT(GetTaggedBytes(tag_val1), old_traffic);
 
   // Verify socket can be retagged with a new value and the current process's

net/socket/tcp_socket_posix.cc

@@ -209,7 +209,7 @@ int TCPSocketPosix::AdoptConnectedSocket(SocketDescriptor socket,
   DCHECK(!socket_);
 
   SockaddrStorage storage;
-  if (!peer_address.ToSockAddr(storage.addr, &storage.addr_len) &&
+  if (!peer_address.ToSockAddr(storage.addr(), &storage.addr_len) &&
       // For backward compatibility, allows the empty address.
       !(peer_address == IPEndPoint())) {
     return ERR_ADDRESS_INVALID;
@@ -240,8 +240,9 @@ int TCPSocketPosix::Bind(const IPEndPoint& address) {
   DCHECK(socket_);
 
   SockaddrStorage storage;
-  if (!address.ToSockAddr(storage.addr, &storage.addr_len))
+  if (!address.ToSockAddr(storage.addr(), &storage.addr_len)) {
     return ERR_ADDRESS_INVALID;
+  }
 
   return socket_->Bind(storage);
 }
@@ -281,8 +282,9 @@ int TCPSocketPosix::Connect(const IPEndPoint& address,
                       [&] { return CreateNetLogIPEndPointParams(&address); });
 
   SockaddrStorage storage;
-  if (!address.ToSockAddr(storage.addr, &storage.addr_len))
+  if (!address.ToSockAddr(storage.addr(), &storage.addr_len)) {
     return ERR_ADDRESS_INVALID;
+  }
 
   int rv = socket_->Connect(
       storage, base::BindOnce(&TCPSocketPosix::ConnectCompleted,
@@ -379,8 +381,9 @@ int TCPSocketPosix::GetLocalAddress(IPEndPoint* address) const {
   if (rv != OK)
     return rv;
 
-  if (!address->FromSockAddr(storage.addr, storage.addr_len))
+  if (!address->FromSockAddr(storage.addr(), storage.addr_len)) {
     return ERR_ADDRESS_INVALID;
+  }
 
   return OK;
 }
@@ -396,8 +399,9 @@ int TCPSocketPosix::GetPeerAddress(IPEndPoint* address) const {
   if (rv != OK)
     return rv;
 
-  if (!address->FromSockAddr(storage.addr, storage.addr_len))
+  if (!address->FromSockAddr(storage.addr(), storage.addr_len)) {
     return ERR_ADDRESS_INVALID;
+  }
 
   return OK;
 }
@@ -553,7 +557,7 @@ int TCPSocketPosix::BuildTcpSocketPosix(
 
   SockaddrStorage storage;
   if (accept_socket_->GetPeerAddress(&storage) != OK ||
-      !address->FromSockAddr(storage.addr, storage.addr_len)) {
+      !address->FromSockAddr(storage.addr(), storage.addr_len)) {
     accept_socket_.reset();
     return ERR_ADDRESS_INVALID;
   }

net/socket/tcp_socket_unittest.cc

@@ -428,8 +428,8 @@ TEST_P(TCPSocketTest, AcceptForAdoptedUnconnectedSocket) {
 
   IPEndPoint address(IPAddress::IPv4Localhost(), 0);
   SockaddrStorage storage;
-  ASSERT_TRUE(address.ToSockAddr(storage.addr, &storage.addr_len));
-  ASSERT_EQ(0, bind(existing_socket, storage.addr, storage.addr_len));
+  ASSERT_TRUE(address.ToSockAddr(storage.addr(), &storage.addr_len));
+  ASSERT_EQ(0, bind(existing_socket, storage.addr(), storage.addr_len));
 
   ASSERT_THAT(socket_->Listen(kListenBacklog), IsOk());
   ASSERT_THAT(socket_->GetLocalAddress(&local_address_), IsOk());

net/socket/tcp_socket_win.cc

@@ -448,10 +448,11 @@ int TCPSocketWin::Bind(const IPEndPoint& address) {
   DCHECK_NE(socket_, INVALID_SOCKET);
 
   SockaddrStorage storage;
-  if (!address.ToSockAddr(storage.addr, &storage.addr_len))
+  if (!address.ToSockAddr(storage.addr(), &storage.addr_len)) {
     return ERR_ADDRESS_INVALID;
+  }
 
-  int result = bind(socket_, storage.addr, storage.addr_len);
+  int result = bind(socket_, storage.addr(), storage.addr_len);
   int os_error = WSAGetLastError();
   if (result < 0) {
     PLOG(ERROR) << "bind() returned an error";
@@ -715,12 +716,13 @@ int TCPSocketWin::GetLocalAddress(IPEndPoint* address) const {
   DCHECK(address);
 
   SockaddrStorage storage;
-  if (getsockname(socket_, storage.addr, &storage.addr_len)) {
+  if (getsockname(socket_, storage.addr(), &storage.addr_len)) {
     int os_error = WSAGetLastError();
     return MapSystemError(os_error);
   }
-  if (!address->FromSockAddr(storage.addr, storage.addr_len))
+  if (!address->FromSockAddr(storage.addr(), storage.addr_len)) {
     return ERR_ADDRESS_INVALID;
+  }
 
   return OK;
 }
@@ -893,7 +895,7 @@ void TCPSocketWin::CloseSocketDescriptorForTesting() {
 int TCPSocketWin::AcceptInternal(std::unique_ptr<TCPSocketWin>* socket,
                                  IPEndPoint* address) {
   SockaddrStorage storage;
-  int new_socket = accept(socket_, storage.addr, &storage.addr_len);
+  int new_socket = accept(socket_, storage.addr(), &storage.addr_len);
   int os_error = WSAGetLastError();
   if (new_socket < 0) {
     int net_error = MapSystemError(os_error);
@@ -903,7 +905,7 @@ int TCPSocketWin::AcceptInternal(std::unique_ptr<TCPSocketWin>* socket,
   }
 
   IPEndPoint ip_end_point;
-  if (!ip_end_point.FromSockAddr(storage.addr, storage.addr_len)) {
+  if (!ip_end_point.FromSockAddr(storage.addr(), storage.addr_len)) {
     NOTREACHED();
   }
   auto tcp_socket =
@@ -962,8 +964,9 @@ int TCPSocketWin::DoConnect() {
   WSAEventSelect(socket_, core_->GetConnectEvent(), FD_CONNECT);
 
   SockaddrStorage storage;
-  if (!peer_address_->ToSockAddr(storage.addr, &storage.addr_len))
+  if (!peer_address_->ToSockAddr(storage.addr(), &storage.addr_len)) {
     return ERR_ADDRESS_INVALID;
+  }
 
   // Set option to choose a random port, if the socket is not already bound.
   // Ignore failures, which may happen if the socket was already bound.
@@ -975,7 +978,7 @@ int TCPSocketWin::DoConnect() {
                sizeof(randomize_port));
   }
 
-  if (!connect(socket_, storage.addr, storage.addr_len)) {
+  if (!connect(socket_, storage.addr(), storage.addr_len)) {
     // Connected without waiting!
     //
     // The MSDN page for connect says:

net/socket/udp_socket_posix.cc

@@ -238,11 +238,13 @@ int UDPSocketPosix::GetPeerAddress(IPEndPoint* address) const {
 
   if (!remote_address_.get()) {
     SockaddrStorage storage;
-    if (getpeername(socket_, storage.addr, &storage.addr_len))
+    if (getpeername(socket_, storage.addr(), &storage.addr_len)) {
       return MapSystemError(errno);
+    }
     auto endpoint = std::make_unique<IPEndPoint>();
-    if (!endpoint->FromSockAddr(storage.addr, storage.addr_len))
+    if (!endpoint->FromSockAddr(storage.addr(), storage.addr_len)) {
       return ERR_ADDRESS_INVALID;
+    }
     remote_address_ = std::move(endpoint);
   }
 
@@ -258,11 +260,13 @@ int UDPSocketPosix::GetLocalAddress(IPEndPoint* address) const {
 
   if (!local_address_.get()) {
     SockaddrStorage storage;
-    if (getsockname(socket_, storage.addr, &storage.addr_len))
+    if (getsockname(socket_, storage.addr(), &storage.addr_len)) {
       return MapSystemError(errno);
+    }
     auto endpoint = std::make_unique<IPEndPoint>();
-    if (!endpoint->FromSockAddr(storage.addr, storage.addr_len))
+    if (!endpoint->FromSockAddr(storage.addr(), storage.addr_len)) {
       return ERR_ADDRESS_INVALID;
+    }
     local_address_ = std::move(endpoint);
     net_log_.AddEvent(NetLogEventType::UDP_LOCAL_ADDRESS, [&] {
       return CreateNetLogUDPConnectParams(*local_address_, bound_network_);
@@ -396,10 +400,11 @@ int UDPSocketPosix::InternalConnect(const IPEndPoint& address) {
   }
 
   SockaddrStorage storage;
-  if (!address.ToSockAddr(storage.addr, &storage.addr_len))
+  if (!address.ToSockAddr(storage.addr(), &storage.addr_len)) {
     return ERR_ADDRESS_INVALID;
+  }
 
-  rv = HANDLE_EINTR(connect(socket_, storage.addr, storage.addr_len));
+  rv = HANDLE_EINTR(connect(socket_, storage.addr(), storage.addr_len));
   if (rv < 0)
     return MapSystemError(errno);
 
@@ -723,9 +728,9 @@ int UDPSocketPosix::InternalRecvFromConnectedSocket(IOBuffer* buf,
 
   SockaddrStorage sock_addr;
   bool success =
-        remote_address_->ToSockAddr(sock_addr.addr, &sock_addr.addr_len);
-    DCHECK(success);
-    LogRead(result, buf->data(), sock_addr.addr_len, sock_addr.addr);
+      remote_address_->ToSockAddr(sock_addr.addr(), &sock_addr.addr_len);
+  DCHECK(success);
+  LogRead(result, buf->data(), sock_addr.addr_len, sock_addr.addr());
   return result;
 }
 
@@ -742,7 +747,7 @@ int UDPSocketPosix::InternalRecvFromNonConnectedSocket(IOBuffer* buf,
   // 512 Bytes, re-used here.
   char control_buffer[512];
   struct msghdr msg = {
-      .msg_name = storage.addr,
+      .msg_name = storage.addr(),
       .msg_namelen = storage.addr_len,
       .msg_iov = &iov,
       .msg_iovlen = 1,
@@ -763,7 +768,7 @@ int UDPSocketPosix::InternalRecvFromNonConnectedSocket(IOBuffer* buf,
       // Linux, but isn't supported by POSIX.
       result = ERR_MSG_TOO_BIG;
     } else if (address &&
-               !address->FromSockAddr(storage.addr, storage.addr_len)) {
+               !address->FromSockAddr(storage.addr(), storage.addr_len)) {
       result = ERR_ADDRESS_INVALID;
     } else {
       result = bytes_transferred;
@@ -787,7 +792,7 @@ int UDPSocketPosix::InternalRecvFromNonConnectedSocket(IOBuffer* buf,
     }
   }
 
-  LogRead(result, buf->data(), storage.addr_len, storage.addr);
+  LogRead(result, buf->data(), storage.addr_len, storage.addr());
   return result;
 }
 
@@ -795,12 +800,12 @@ int UDPSocketPosix::InternalSendTo(IOBuffer* buf,
                                    int buf_len,
                                    const IPEndPoint* address) {
   SockaddrStorage storage;
-  struct sockaddr* addr = storage.addr;
+  struct sockaddr* addr = storage.addr();
   if (!address) {
     addr = nullptr;
     storage.addr_len = 0;
   } else {
-    if (!address->ToSockAddr(storage.addr, &storage.addr_len)) {
+    if (!address->ToSockAddr(storage.addr(), &storage.addr_len)) {
       int result = ERR_ADDRESS_INVALID;
       LogWrite(result, nullptr, nullptr);
       return result;
@@ -876,9 +881,10 @@ int UDPSocketPosix::SetMulticastOptions() {
 
 int UDPSocketPosix::DoBind(const IPEndPoint& address) {
   SockaddrStorage storage;
-  if (!address.ToSockAddr(storage.addr, &storage.addr_len))
+  if (!address.ToSockAddr(storage.addr(), &storage.addr_len)) {
     return ERR_ADDRESS_INVALID;
-  int rv = bind(socket_, storage.addr, storage.addr_len);
+  }
+  int rv = bind(socket_, storage.addr(), storage.addr_len);
   if (rv == 0)
     return OK;
   int last_error = errno;

net/socket/udp_socket_win.cc

@@ -369,11 +369,13 @@ int UDPSocketWin::GetPeerAddress(IPEndPoint* address) const {
   // TODO(szym): Simplify. http://crbug.com/126152
   if (!remote_address_.get()) {
     SockaddrStorage storage;
-    if (getpeername(socket_, storage.addr, &storage.addr_len))
+    if (getpeername(socket_, storage.addr(), &storage.addr_len)) {
       return MapSystemError(WSAGetLastError());
+    }
     auto remote_address = std::make_unique<IPEndPoint>();
-    if (!remote_address->FromSockAddr(storage.addr, storage.addr_len))
+    if (!remote_address->FromSockAddr(storage.addr(), storage.addr_len)) {
       return ERR_ADDRESS_INVALID;
+    }
     remote_address_ = std::move(remote_address);
   }
 
@@ -390,11 +392,13 @@ int UDPSocketWin::GetLocalAddress(IPEndPoint* address) const {
   // TODO(szym): Simplify. http://crbug.com/126152
   if (!local_address_.get()) {
     SockaddrStorage storage;
-    if (getsockname(socket_, storage.addr, &storage.addr_len))
+    if (getsockname(socket_, storage.addr(), &storage.addr_len)) {
       return MapSystemError(WSAGetLastError());
+    }
     auto local_address = std::make_unique<IPEndPoint>();
-    if (!local_address->FromSockAddr(storage.addr, storage.addr_len))
+    if (!local_address->FromSockAddr(storage.addr(), storage.addr_len)) {
       return ERR_ADDRESS_INVALID;
+    }
     local_address_ = std::move(local_address);
     net_log_.AddEvent(NetLogEventType::UDP_LOCAL_ADDRESS, [&] {
       return CreateNetLogUDPConnectParams(*local_address_,
@@ -505,10 +509,11 @@ int UDPSocketWin::InternalConnect(const IPEndPoint& address) {
              sizeof(randomize_port_value));
 
   SockaddrStorage storage;
-  if (!address.ToSockAddr(storage.addr, &storage.addr_len))
+  if (!address.ToSockAddr(storage.addr(), &storage.addr_len)) {
     return ERR_ADDRESS_INVALID;
+  }
 
-  int rv = connect(socket_, storage.addr, storage.addr_len);
+  int rv = connect(socket_, storage.addr(), storage.addr_len);
   if (rv < 0)
     return MapSystemError(WSAGetLastError());
 
@@ -734,7 +739,7 @@ void UDPSocketWin::DidCompleteRead() {
   IPEndPoint address;
   IPEndPoint* address_to_log = nullptr;
   if (result >= 0) {
-    if (address.FromSockAddr(core_->recv_addr_storage_.addr,
+    if (address.FromSockAddr(core_->recv_addr_storage_.addr(),
                              core_->recv_addr_storage_.addr_len)) {
       if (recv_from_address_) {
         *recv_from_address_ = address;
@@ -892,7 +897,7 @@ void UDPSocketWin::PopulateWSAMSG(WSAMSG& message,
   } else {
     is_ipv6 = (addr_family_ == AF_INET6);
   }
-  message.name = storage.addr;
+  message.name = storage.addr();
   message.namelen = storage.addr_len;
   message.lpBuffers = data_buffer;
   message.dwBufferCount = 1;
@@ -957,7 +962,7 @@ int UDPSocketWin::InternalRecvFromOverlapped(IOBuffer* buf,
       SetLastTosFromWSAMSG(*message);
     }
   } else {
-    rv = WSARecvFrom(socket_, &read_buffer, 1, &num, &flags, storage.addr,
+    rv = WSARecvFrom(socket_, &read_buffer, 1, &num, &flags, storage.addr(),
                      &storage.addr_len, &core_->read_overlapped_, nullptr);
   }
   if (rv == 0) {
@@ -967,7 +972,7 @@ int UDPSocketWin::InternalRecvFromOverlapped(IOBuffer* buf,
       IPEndPoint address_storage;
       IPEndPoint* address_to_log = nullptr;
       if (result >= 0) {
-        if (address_storage.FromSockAddr(core_->recv_addr_storage_.addr,
+        if (address_storage.FromSockAddr(core_->recv_addr_storage_.addr(),
                                          core_->recv_addr_storage_.addr_len)) {
           if (address) {
             *address = address_storage;
@@ -999,7 +1004,7 @@ int UDPSocketWin::InternalSendToOverlapped(IOBuffer* buf,
                                            const IPEndPoint* address) {
   DCHECK(!core_->write_iobuffer_.get());
   SockaddrStorage storage;
-  struct sockaddr* addr = storage.addr;
+  struct sockaddr* addr = storage.addr();
   // Convert address.
   if (!address) {
     addr = nullptr;
@@ -1087,7 +1092,7 @@ int UDPSocketWin::InternalRecvFromNonBlocking(IOBuffer* buf,
                         // returns the number of bytes received.
     }
   } else {
-    rv = recvfrom(socket_, buf->data(), buf_len, 0, storage.addr,
+    rv = recvfrom(socket_, buf->data(), buf_len, 0, storage.addr(),
                   &storage.addr_len);
   }
   if (rv == SOCKET_ERROR) {
@@ -1105,7 +1110,7 @@ int UDPSocketWin::InternalRecvFromNonBlocking(IOBuffer* buf,
   IPEndPoint address_storage;
   IPEndPoint* address_to_log = nullptr;
   if (rv >= 0) {
-    if (address_storage.FromSockAddr(storage.addr, storage.addr_len)) {
+    if (address_storage.FromSockAddr(storage.addr(), storage.addr_len)) {
       if (address) {
         *address = address_storage;
       }
@@ -1123,7 +1128,7 @@ int UDPSocketWin::InternalSendToNonBlocking(IOBuffer* buf,
                                             const IPEndPoint* address) {
   DCHECK(!write_iobuffer_ || write_iobuffer_.get() == buf);
   SockaddrStorage storage;
-  struct sockaddr* addr = storage.addr;
+  struct sockaddr* addr = storage.addr();
   // Convert address.
   if (address) {
     if (!address->ToSockAddr(addr, &storage.addr_len)) {
@@ -1226,10 +1231,10 @@ int UDPSocketWin::SetMulticastOptions() {
 
 int UDPSocketWin::DoBind(const IPEndPoint& address) {
   SockaddrStorage storage;
-  if (!address.ToSockAddr(storage.addr, &storage.addr_len)) {
+  if (!address.ToSockAddr(storage.addr(), &storage.addr_len)) {
     return ERR_ADDRESS_INVALID;
   }
-  int rv = bind(socket_, storage.addr, storage.addr_len);
+  int rv = bind(socket_, storage.addr(), storage.addr_len);
   if (rv == 0) {
     return OK;
   }
@@ -1525,7 +1530,7 @@ int DscpManager::PrepareForSend(const IPEndPoint& remote_address) {
   }
 
   SockaddrStorage storage;
-  if (!remote_address.ToSockAddr(storage.addr, &storage.addr_len)) {
+  if (!remote_address.ToSockAddr(storage.addr(), &storage.addr_len)) {
     return ERR_ADDRESS_INVALID;
   }
 
@@ -1537,7 +1542,7 @@ int DscpManager::PrepareForSend(const IPEndPoint& remote_address) {
 
   const QOS_TRAFFIC_TYPE traffic_type = DscpToTrafficType(dscp_value_);
 
-  if (!api_->AddSocketToFlow(qos_handle_, socket_, storage.addr, traffic_type,
+  if (!api_->AddSocketToFlow(qos_handle_, socket_, storage.addr(), traffic_type,
                              QOS_NON_ADAPTIVE_FLOW, &flow_id_)) {
     DWORD err = ::GetLastError();
     if (err == ERROR_DEVICE_REINITIALIZATION_NEEDED) {