Avoid heap allocations in IPAddress

net/base/ip_address.h

 // Copyright (c) 2015 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.
 
 #ifndef NET_BASE_IP_ADDRESS_H_
 #define NET_BASE_IP_ADDRESS_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <array>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/strings/string_piece.h"
 #include "net/base/net_export.h"
 
 namespace net {
 
 class NET_EXPORT IPAddress {
  public:
   enum : size_t { kIPv4AddressSize = 4, kIPv6AddressSize = 16 };
 
+  // Helper class to represent the sequence of bytes in an IP address.
+  // A vector<uint8_t> would be simpler but incurs heap allocation, so
+  // IPAddressBytes uses a fixed size array

[eroman, 2017/05/18 18:43:17]

nits: end with period.

[Ryan Hamilton, 2017/05/19 03:38:50]

Done.

+  class IPAddressBytes {
+   public:
+    IPAddressBytes();
+    IPAddressBytes(const uint8_t* data, size_t data_len);
+    IPAddressBytes(const IPAddressBytes& other);
+    ~IPAddressBytes();
+
+    // Returns the number of elements in the underlying array.
+    size_t size() const { return size_; }
+
+    // Sets the size to be |size|. Does not actually change the size
+    // of the underlying array.

[eroman, 2017/05/18 18:43:17]

or zero-initialize the bytes.

[Ryan Hamilton, 2017/05/19 03:38:50]

Done.

+    void Resize(size_t size) {
+      DCHECK_LE(size, 16u);
+      size_ = static_cast<uint8_t>(size);
+    }
+
+    // Returns true if the underlying array is empty.
+    bool empty() const { return size_ == 0; }
+
+    // Returns a pointer to the underlying array of bytes.
+    const uint8_t* data() const { return bytes_.data(); }
+    uint8_t* data() { return bytes_.data(); }
+
+    // Returns a pointer to the first element.
+    const uint8_t* begin() const { return data(); }
+
+    // Returns a pointer past the last element.
+    const uint8_t* end() const { return data() + size_; }
+
+    // Returns a reference to the last element.
+    uint8_t& back() {
+      DCHECK(!empty());
+      return bytes_[size_ - 1];
+    }
+    const uint8_t& back() const {
+      DCHECK(!empty());
+      return bytes_[size_ - 1];
+    }
+
+    // Appends |val| to the end and increments the size.
+    void push_back(uint8_t val) {
+      DCHECK_GT(16, size_);
+      bytes_[size_++] = val;
+    }
+
+    // Returns a reference to the byte at index |pos|.
+    uint8_t& operator[](size_t pos) {
+      DCHECK_LT(pos, size_);
+      return bytes_[pos];
+    }
+    const uint8_t& operator[](size_t pos) const {
+      DCHECK_LT(pos, size_);
+      return bytes_[pos];
+    }
+
+   private:
+    friend bool operator>(const IPAddressBytes& lhs, const IPAddressBytes& rhs);

[eroman, 2017/05/18 18:43:17]

optional: Instead of friending, what about defining the operators as public
member functions of IPAddressBytes ? Probably saves a few extra lines.

[Ryan Hamilton, 2017/05/19 03:38:50]

Why did I not do that at first?! Done.

+    friend bool operator<(const IPAddressBytes& lhs, const IPAddressBytes& rhs);
+    friend bool operator!=(const IPAddressBytes& lhs,
+                           const IPAddressBytes& rhs);
+    friend bool operator==(const IPAddressBytes& lhs,
+                           const IPAddressBytes& rhs);
+
+    // Underlying sequence of bytes
+    std::array<uint8_t, kIPv6AddressSize> bytes_;
+
+    // Number of elements in |bytes_|. Should be either kIPv4AddressSize
+    // or kIPv6AddressSize or 0.
+    uint8_t size_;
+  };
+
   // Creates a zero-sized, invalid address.
   IPAddress();
 
   // Copies the input address to |ip_address_|. The input is expected to be in
   // network byte order.
   explicit IPAddress(const std::vector<uint8_t>& address);
 
   IPAddress(const IPAddress& other);
 
   // Copies the input address to |ip_address_|. The input is expected to be in
@@ skipping 61 matching lines @@
   // Returns the canonical string representation of an IP address.
   // For example: "192.168.0.1" or "::1". Returns the empty string when
   // |ip_address_| is invalid.
   std::string ToString() const;
 
   // Parses an IP address literal (either IPv4 or IPv6) to its numeric value.
   // Returns true on success and fills |ip_address_| with the numeric value.
   bool AssignFromIPLiteral(const base::StringPiece& ip_literal)
       WARN_UNUSED_RESULT;
 
-  // Returns the underlying byte vector.
-  const std::vector<uint8_t>& bytes() const { return ip_address_; };
+  // Returns the underlying bytes.
+  const IPAddressBytes& bytes() const { return ip_address_; };
+
+  // Returns the underlying bytes as a vector.

[eroman, 2017/05/18 18:43:17]

optional: Add a comment discouraging use of this function?

[Ryan Hamilton, 2017/05/19 03:38:50]

Done.

+  std::vector<uint8_t> BytesAsVector() const;
 
   // Returns an IPAddress instance representing the 127.0.0.1 address.
   static IPAddress IPv4Localhost();
 
   // Returns an IPAddress instance representing the ::1 address.
   static IPAddress IPv6Localhost();
 
   // Returns an IPAddress made up of |num_zero_bytes| zeros.
   static IPAddress AllZeros(size_t num_zero_bytes);
 
   // Returns an IPAddress instance representing the 0.0.0.0 address.
   static IPAddress IPv4AllZeros();
 
   // Returns an IPAddress instance representing the :: address.
   static IPAddress IPv6AllZeros();
 
   bool operator==(const IPAddress& that) const;
   bool operator!=(const IPAddress& that) const;
   bool operator<(const IPAddress& that) const;
 
  private:
   // IPv4 addresses will have length kIPv4AddressSize, whereas IPv6 address

[eroman, 2017/05/18 18:43:17]

optional: I think this comment can be removed, since this is a documented detail
of IPAddressBytes now.

[Ryan Hamilton, 2017/05/19 03:38:50]

Good point. Done.

   // will have length kIPv6AddressSize.
-  std::vector<uint8_t> ip_address_;
+  IPAddressBytes ip_address_;
 
   // This class is copyable and assignable.
 };
 
+bool operator>(const IPAddress::IPAddressBytes& lhs,
+               const IPAddress::IPAddressBytes& rhs);
+bool operator<(const IPAddress::IPAddressBytes& lhs,
+               const IPAddress::IPAddressBytes& rhs);
+bool operator!=(const IPAddress::IPAddressBytes& lhs,
+                const IPAddress::IPAddressBytes& rhs);
+bool operator==(const IPAddress::IPAddressBytes& lhs,
+                const IPAddress::IPAddressBytes& rhs);
+
 using IPAddressList = std::vector<IPAddress>;
 
 // Returns the canonical string representation of an IP address along with its
 // port. For example: "192.168.0.1:99" or "[::1]:80".
 NET_EXPORT std::string IPAddressToStringWithPort(const IPAddress& address,
                                                  uint16_t port);
 
 // Returns the address as a sequence of bytes in network-byte-order.
 NET_EXPORT std::string IPAddressToPackedString(const IPAddress& address);
 
@@ skipping 54 matching lines @@
 template <size_t N>
 bool IPAddressStartsWith(const IPAddress& address, const uint8_t (&prefix)[N]) {
   if (address.size() < N)
     return false;
   return std::equal(prefix, prefix + N, address.bytes().begin());
 }
 
 }  // namespace net
 
 #endif  // NET_BASE_IP_ADDRESS_H_