diff --git a/quic/platform/api/quic_ip_address.cc b/quic/platform/api/quic_ip_address.cc
index 3b48c47..ebc71e1 100644
--- a/quic/platform/api/quic_ip_address.cc
+++ b/quic/platform/api/quic_ip_address.cc
@@ -4,35 +4,83 @@
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_ip_address.h"
 
+#include <algorithm>
+#include <cstring>
 #include <string>
 
+#include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
+
 namespace quic {
 
+static int ToPlatformAddressFamily(IpAddressFamily family) {
+  switch (family) {
+    case IpAddressFamily::IP_V4:
+      return AF_INET;
+    case IpAddressFamily::IP_V6:
+      return AF_INET6;
+    case IpAddressFamily::IP_UNSPEC:
+      return AF_UNSPEC;
+  }
+}
+
 QuicIpAddress QuicIpAddress::Loopback4() {
-  return QuicIpAddress(QuicIpAddressImpl::Loopback4());
+  QuicIpAddress result;
+  result.family_ = IpAddressFamily::IP_V4;
+  result.address_.bytes[0] = 127;
+  result.address_.bytes[1] = 0;
+  result.address_.bytes[2] = 0;
+  result.address_.bytes[3] = 1;
+  return result;
 }
 
 QuicIpAddress QuicIpAddress::Loopback6() {
-  return QuicIpAddress(QuicIpAddressImpl::Loopback6());
+  QuicIpAddress result;
+  result.family_ = IpAddressFamily::IP_V6;
+  uint8_t* bytes = result.address_.bytes;
+  memset(bytes, 0, 15);
+  bytes[15] = 1;
+  return result;
 }
 
 QuicIpAddress QuicIpAddress::Any4() {
-  return QuicIpAddress(QuicIpAddressImpl::Any4());
+  in_addr address;
+  memset(&address, 0, sizeof(address));
+  return QuicIpAddress(address);
 }
 
 QuicIpAddress QuicIpAddress::Any6() {
-  return QuicIpAddress(QuicIpAddressImpl::Any6());
+  in6_addr address;
+  memset(&address, 0, sizeof(address));
+  return QuicIpAddress(address);
 }
 
-QuicIpAddress::QuicIpAddress(const QuicIpAddressImpl& impl) : impl_(impl) {}
+QuicIpAddress::QuicIpAddress() : family_(IpAddressFamily::IP_UNSPEC) {}
 
 QuicIpAddress::QuicIpAddress(const in_addr& ipv4_address)
-    : impl_(ipv4_address) {}
+    : family_(IpAddressFamily::IP_V4) {
+  address_.v4 = ipv4_address;
+}
 QuicIpAddress::QuicIpAddress(const in6_addr& ipv6_address)
-    : impl_(ipv6_address) {}
+    : family_(IpAddressFamily::IP_V6) {
+  address_.v6 = ipv6_address;
+}
 
 bool operator==(QuicIpAddress lhs, QuicIpAddress rhs) {
-  return lhs.impl_ == rhs.impl_;
+  if (lhs.family_ != rhs.family_) {
+    return false;
+  }
+  switch (lhs.family_) {
+    case IpAddressFamily::IP_V4:
+      return std::equal(lhs.address_.bytes,
+                        lhs.address_.bytes + QuicIpAddress::kIPv4AddressSize,
+                        rhs.address_.bytes);
+    case IpAddressFamily::IP_V6:
+      return std::equal(lhs.address_.bytes,
+                        lhs.address_.bytes + QuicIpAddress::kIPv6AddressSize,
+                        rhs.address_.bytes);
+    case IpAddressFamily::IP_UNSPEC:
+      return true;
+  }
 }
 
 bool operator!=(QuicIpAddress lhs, QuicIpAddress rhs) {
@@ -40,60 +88,141 @@
 }
 
 bool QuicIpAddress::IsInitialized() const {
-  return impl_.IsInitialized();
+  return family_ != IpAddressFamily::IP_UNSPEC;
 }
 
 IpAddressFamily QuicIpAddress::address_family() const {
-  return impl_.address_family();
+  return family_;
 }
 
 int QuicIpAddress::AddressFamilyToInt() const {
-  return impl_.AddressFamilyToInt();
+  return ToPlatformAddressFamily(family_);
 }
 
 std::string QuicIpAddress::ToPackedString() const {
-  return impl_.ToPackedString();
+  switch (family_) {
+    case IpAddressFamily::IP_V4:
+      return std::string(address_.chars, sizeof(address_.v4));
+    case IpAddressFamily::IP_V6:
+      return std::string(address_.chars, sizeof(address_.v6));
+    case IpAddressFamily::IP_UNSPEC:
+      return "";
+  }
 }
 
 std::string QuicIpAddress::ToString() const {
-  return impl_.ToString();
+  if (!IsInitialized()) {
+    return "";
+  }
+
+  char buffer[INET6_ADDRSTRLEN] = {0};
+  const char* result =
+      inet_ntop(AddressFamilyToInt(), address_.bytes, buffer, sizeof(buffer));
+  QUIC_BUG_IF(result == nullptr) << "Failed to convert an IP address to string";
+  return buffer;
 }
 
+static const uint8_t kMappedAddressPrefix[] = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+};
+
 QuicIpAddress QuicIpAddress::Normalized() const {
-  return QuicIpAddress(impl_.Normalized());
+  if (!IsIPv6()) {
+    return *this;
+  }
+  if (!std::equal(std::begin(kMappedAddressPrefix),
+                  std::end(kMappedAddressPrefix), address_.bytes)) {
+    return *this;
+  }
+
+  in_addr result;
+  memcpy(&result, &address_.bytes[12], sizeof(result));
+  return QuicIpAddress(result);
 }
 
 QuicIpAddress QuicIpAddress::DualStacked() const {
-  return QuicIpAddress(impl_.DualStacked());
+  if (!IsIPv4()) {
+    return *this;
+  }
+
+  QuicIpAddress result;
+  result.family_ = IpAddressFamily::IP_V6;
+  memcpy(result.address_.bytes, kMappedAddressPrefix,
+         sizeof(kMappedAddressPrefix));
+  memcpy(result.address_.bytes + 12, address_.bytes, kIPv4AddressSize);
+  return result;
 }
 
 bool QuicIpAddress::FromPackedString(const char* data, size_t length) {
-  return impl_.FromPackedString(data, length);
+  switch (length) {
+    case kIPv4AddressSize:
+      family_ = IpAddressFamily::IP_V4;
+      break;
+    case kIPv6AddressSize:
+      family_ = IpAddressFamily::IP_V6;
+      break;
+    default:
+      return false;
+  }
+  memcpy(address_.chars, data, length);
+  return true;
 }
 
 bool QuicIpAddress::FromString(std::string str) {
-  return impl_.FromString(str);
+  for (IpAddressFamily family :
+       {IpAddressFamily::IP_V6, IpAddressFamily::IP_V4}) {
+    int result =
+        inet_pton(ToPlatformAddressFamily(family), str.c_str(), address_.bytes);
+    if (result > 0) {
+      family_ = family;
+      return true;
+    }
+  }
+  return false;
 }
 
 bool QuicIpAddress::IsIPv4() const {
-  return impl_.IsIPv4();
+  return family_ == IpAddressFamily::IP_V4;
 }
 
 bool QuicIpAddress::IsIPv6() const {
-  return impl_.IsIPv6();
+  return family_ == IpAddressFamily::IP_V6;
 }
 
 bool QuicIpAddress::InSameSubnet(const QuicIpAddress& other,
                                  int subnet_length) {
-  return impl_.InSameSubnet(other.impl_, subnet_length);
+  if (!IsInitialized()) {
+    QUIC_BUG << "Attempting to do subnet matching on undefined address";
+    return false;
+  }
+  if ((IsIPv4() && subnet_length > 32) || (IsIPv6() && subnet_length > 128)) {
+    QUIC_BUG << "Subnet mask is out of bounds";
+    return false;
+  }
+
+  int bytes_to_check = subnet_length / 8;
+  int bits_to_check = subnet_length % 8;
+  const uint8_t* const lhs = address_.bytes;
+  const uint8_t* const rhs = other.address_.bytes;
+  if (!std::equal(lhs, lhs + bytes_to_check, rhs)) {
+    return false;
+  }
+  if (bits_to_check == 0) {
+    return true;
+  }
+  DCHECK_LT(static_cast<size_t>(bytes_to_check), sizeof(address_.bytes));
+  int mask = (~0) << (8 - bits_to_check);
+  return (lhs[bytes_to_check] & mask) == (rhs[bytes_to_check] & mask);
 }
 
 in_addr QuicIpAddress::GetIPv4() const {
-  return impl_.GetIPv4();
+  DCHECK(IsIPv4());
+  return address_.v4;
 }
 
 in6_addr QuicIpAddress::GetIPv6() const {
-  return impl_.GetIPv6();
+  DCHECK(IsIPv6());
+  return address_.v6;
 }
 
 }  // namespace quic
diff --git a/quic/platform/api/quic_ip_address.h b/quic/platform/api/quic_ip_address.h
index 6d507b4..e1a1076 100644
--- a/quic/platform/api/quic_ip_address.h
+++ b/quic/platform/api/quic_ip_address.h
@@ -9,6 +9,7 @@
 #include <winsock2.h>
 #include <ws2tcpip.h>
 #else
+#include <arpa/inet.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <sys/types.h>
@@ -17,18 +18,18 @@
 #include <string>
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/quic/platform/impl/quic_ip_address_impl.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_ip_address_family.h"
 
 namespace quic {
 
+// Represents an IP address.
 class QUIC_EXPORT_PRIVATE QuicIpAddress {
-  // A class representing an IPv4 or IPv6 address in QUIC. The actual
-  // implementation (platform dependent) of an IP address is in
-  // QuicIpAddressImpl.
  public:
+  // Sizes of IP addresses of different types, in bytes.
   enum : size_t {
-    kIPv4AddressSize = QuicIpAddressImpl::kIPv4AddressSize,
-    kIPv6AddressSize = QuicIpAddressImpl::kIPv6AddressSize
+    kIPv4AddressSize = 32 / 8,
+    kIPv6AddressSize = 128 / 8,
+    kMaxAddressSize = kIPv6AddressSize,
   };
 
   // TODO(fayang): Remove Loopback*() and use TestLoopback*() in tests.
@@ -37,9 +38,8 @@
   static QuicIpAddress Any4();
   static QuicIpAddress Any6();
 
-  QuicIpAddress() = default;
+  QuicIpAddress();
   QuicIpAddress(const QuicIpAddress& other) = default;
-  explicit QuicIpAddress(const QuicIpAddressImpl& impl);
   explicit QuicIpAddress(const in_addr& ipv4_address);
   explicit QuicIpAddress(const in6_addr& ipv6_address);
   QuicIpAddress& operator=(const QuicIpAddress& other) = default;
@@ -77,9 +77,20 @@
   in6_addr GetIPv6() const;
 
  private:
-  QuicIpAddressImpl impl_;
+  union {
+    in_addr v4;
+    in6_addr v6;
+    uint8_t bytes[kMaxAddressSize];
+    char chars[kMaxAddressSize];
+  } address_;
+  IpAddressFamily family_;
 };
 
+inline std::ostream& operator<<(std::ostream& os, const QuicIpAddress address) {
+  os << address.ToString();
+  return os;
+}
+
 }  // namespace quic
 
 #endif  // QUICHE_QUIC_PLATFORM_API_QUIC_IP_ADDRESS_H_
diff --git a/quic/platform/api/quic_ip_address_test.cc b/quic/platform/api/quic_ip_address_test.cc
index 6942427..7dfe243 100644
--- a/quic/platform/api/quic_ip_address_test.cc
+++ b/quic/platform/api/quic_ip_address_test.cc
@@ -56,6 +56,84 @@
   EXPECT_EQ(0xff01u, *(v6_address_ptr + 5));
   EXPECT_EQ(0x23feu, *(v6_address_ptr + 6));
   EXPECT_EQ(0x6745u, *(v6_address_ptr + 7));
+
+  EXPECT_EQ(ip_address, ip_address.Normalized());
+  EXPECT_EQ(ip_address, ip_address.DualStacked());
+}
+
+TEST(QuicIpAddressTest, FromPackedString) {
+  QuicIpAddress loopback4, loopback6;
+  const char loopback4_packed[] = "\x7f\0\0\x01";
+  const char loopback6_packed[] = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01";
+  EXPECT_TRUE(loopback4.FromPackedString(loopback4_packed, 4));
+  EXPECT_TRUE(loopback6.FromPackedString(loopback6_packed, 16));
+  EXPECT_EQ(loopback4, QuicIpAddress::Loopback4());
+  EXPECT_EQ(loopback6, QuicIpAddress::Loopback6());
+}
+
+TEST(QuicIpAddressTest, MappedAddress) {
+  QuicIpAddress ipv4_address;
+  QuicIpAddress mapped_address;
+
+  EXPECT_TRUE(ipv4_address.FromString("127.0.0.1"));
+  EXPECT_TRUE(mapped_address.FromString("::ffff:7f00:1"));
+
+  EXPECT_EQ(mapped_address, ipv4_address.DualStacked());
+  EXPECT_EQ(ipv4_address, mapped_address.Normalized());
+}
+
+TEST(QuicIpAddressTest, Subnets) {
+  struct {
+    const char* address1;
+    const char* address2;
+    int subnet_size;
+    bool same_subnet;
+  } test_cases[] = {
+      {"127.0.0.1", "127.0.0.2", 24, true},
+      {"8.8.8.8", "127.0.0.1", 24, false},
+      {"8.8.8.8", "127.0.0.1", 16, false},
+      {"8.8.8.8", "127.0.0.1", 8, false},
+      {"8.8.8.8", "127.0.0.1", 2, false},
+      {"8.8.8.8", "127.0.0.1", 1, true},
+
+      {"127.0.0.1", "127.0.0.128", 24, true},
+      {"127.0.0.1", "127.0.0.128", 25, false},
+      {"127.0.0.1", "127.0.0.127", 25, true},
+
+      {"127.0.0.1", "127.0.0.0", 30, true},
+      {"127.0.0.1", "127.0.0.1", 30, true},
+      {"127.0.0.1", "127.0.0.2", 30, true},
+      {"127.0.0.1", "127.0.0.3", 30, true},
+      {"127.0.0.1", "127.0.0.4", 30, false},
+
+      {"127.0.0.1", "127.0.0.2", 31, false},
+      {"127.0.0.1", "127.0.0.0", 31, true},
+
+      {"::1", "fe80::1", 8, false},
+      {"::1", "fe80::1", 1, false},
+      {"::1", "fe80::1", 0, true},
+      {"fe80::1", "fe80::2", 126, true},
+      {"fe80::1", "fe80::2", 127, false},
+  };
+
+  for (const auto& test_case : test_cases) {
+    QuicIpAddress address1, address2;
+    ASSERT_TRUE(address1.FromString(test_case.address1));
+    ASSERT_TRUE(address2.FromString(test_case.address2));
+    EXPECT_EQ(test_case.same_subnet,
+              address1.InSameSubnet(address2, test_case.subnet_size))
+        << "Addresses: " << test_case.address1 << ", " << test_case.address2
+        << "; subnet: /" << test_case.subnet_size;
+  }
+}
+
+TEST(QuicIpAddress, LoopbackAddresses) {
+  QuicIpAddress loopback4;
+  QuicIpAddress loopback6;
+  ASSERT_TRUE(loopback4.FromString("127.0.0.1"));
+  ASSERT_TRUE(loopback6.FromString("::1"));
+  EXPECT_EQ(loopback4, QuicIpAddress::Loopback4());
+  EXPECT_EQ(loopback6, QuicIpAddress::Loopback6());
 }
 
 }  // namespace