Avoid heap allocations in IPAddress

ppapi/shared_impl/private/net_address_private_impl.cc

 // Copyright (c) 2012 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.
 
 #include "ppapi/shared_impl/private/net_address_private_impl.h"
 
 #include <stddef.h>
 #include <string.h>
 
 #include <string>
 
+#include "base/containers/stack_container.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/private/ppb_net_address_private.h"
 #include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/thunk/thunk.h"
 
 #if defined(OS_WIN)
@@ skipping 422 matching lines @@
       break;
     }
     default:
       // InitNetAddress sets net_addr->is_valid to false.
       return false;
   }
   return true;}
 
 // static
 bool NetAddressPrivateImpl::IPEndPointToNetAddress(
-    const std::vector<uint8_t>& address,
+    const net::IPAddress::IPAddressBytes& address,
     uint16_t port,
     PP_NetAddress_Private* addr) {
   if (!addr)
     return false;
 
   NetAddress* net_addr = InitNetAddress(addr);
   switch (address.size()) {
     case kIPv4AddressSize: {
       net_addr->is_valid = true;
       net_addr->is_ipv6 = false;
@@ skipping 12 matching lines @@
       // InitNetAddress sets net_addr->is_valid to false.
       return false;
   }
 
   return true;
 }
 
 // static
 bool NetAddressPrivateImpl::NetAddressToIPEndPoint(
     const PP_NetAddress_Private& addr,
-    std::vector<uint8_t>* address,
+    base::StackVector<uint8_t, 16>* address,
     uint16_t* port) {
   if (!address || !port)
     return false;
 
   const NetAddress* net_addr = ToNetAddress(&addr);
   if (!IsValid(net_addr))
     return false;
 
   *port = net_addr->port;
   size_t address_size = GetAddressSize(net_addr);
-  address->assign(&net_addr->address[0], &net_addr->address[address_size]);
+  address->container().assign(&net_addr->address[0],
+                              &net_addr->address[address_size]);

[eroman, 2017/05/19 22:00:07]

Technically this existing code was relying on undefined behavior (indexing
beyond the end of the array), even if only to get the address.

Can you change it to not use operator[]? Say:

   assign(net_addr->address, net_addr->address + address_size);

[Ryan Hamilton, 2017/05/20 03:21:44]

As per your previous comment, I switched this to take an IPAddressBytes instead
of a StackVector, which does not have an assign method. Instead I push_back the
bytes 1 at a time. (Of course, it's pushing back into an array so it's not going
to reallocate or anything)

[eroman, 2017/05/22 18:06:44]

This translation presumes that |address| is the empty address upon entry, which
I don't think is guaranteed by the API. It would be prudent to call Resize(0)
first to address this.

Or better yet, add an Assign() method that takes ptr + size  (and change the
constructor to call this as a helper).

[Ryan Hamilton, 2017/05/22 22:12:32]

Done.

 
   return true;
 }
 #endif  // !defined(OS_NACL)
 
 // static
 std::string NetAddressPrivateImpl::DescribeNetAddress(
     const PP_NetAddress_Private& addr,
     bool include_port) {
   const NetAddress* net_addr = ToNetAddress(&addr);
@@ skipping 75 matching lines @@
   ipv6_addr->port = ConvertToNetEndian16(net_addr->port);
 
   static_assert(sizeof(ipv6_addr->addr) == kIPv6AddressSize,
                 "mismatched IPv6 address size");
   memcpy(ipv6_addr->addr, net_addr->address, kIPv6AddressSize);
 
   return true;
 }
 
 }  // namespace ppapi