diff --git a/build/source_list.bzl b/build/source_list.bzl
index 8c1584d..2f69820 100644
--- a/build/source_list.bzl
+++ b/build/source_list.bzl
@@ -48,6 +48,8 @@
     "common/quiche_data_reader.h",
     "common/quiche_data_writer.h",
     "common/quiche_endian.h",
+    "common/quiche_ip_address.h",
+    "common/quiche_ip_address_family.h",
     "common/quiche_linked_hash_map.h",
     "common/quiche_mem_slice_storage.h",
     "common/quiche_protocol_flags_list.h",
@@ -406,6 +408,8 @@
     "common/quiche_buffer_allocator.cc",
     "common/quiche_data_reader.cc",
     "common/quiche_data_writer.cc",
+    "common/quiche_ip_address.cc",
+    "common/quiche_ip_address_family.cc",
     "common/quiche_mem_slice_storage.cc",
     "common/quiche_text_utils.cc",
     "common/simple_buffer_allocator.cc",
@@ -662,8 +666,6 @@
     "quic/core/tls_server_handshaker.cc",
     "quic/core/uber_quic_stream_id_manager.cc",
     "quic/core/uber_received_packet_manager.cc",
-    "quic/platform/api/quic_ip_address.cc",
-    "quic/platform/api/quic_ip_address_family.cc",
     "quic/platform/api/quic_socket_address.cc",
     "spdy/core/array_output_buffer.cc",
     "spdy/core/hpack/hpack_constants.cc",
@@ -1064,6 +1066,7 @@
     "common/quiche_data_reader_test.cc",
     "common/quiche_data_writer_test.cc",
     "common/quiche_endian_test.cc",
+    "common/quiche_ip_address_test.cc",
     "common/quiche_linked_hash_map_test.cc",
     "common/quiche_mem_slice_storage_test.cc",
     "common/quiche_text_utils_test.cc",
@@ -1269,7 +1272,6 @@
     "quic/core/tls_server_handshaker_test.cc",
     "quic/core/uber_quic_stream_id_manager_test.cc",
     "quic/core/uber_received_packet_manager_test.cc",
-    "quic/platform/api/quic_ip_address_test.cc",
     "quic/platform/api/quic_socket_address_test.cc",
     "quic/test_tools/crypto_test_utils_test.cc",
     "quic/test_tools/quic_test_utils_test.cc",
diff --git a/build/source_list.gni b/build/source_list.gni
index 74e2d35..9defb90 100644
--- a/build/source_list.gni
+++ b/build/source_list.gni
@@ -48,6 +48,8 @@
     "src/quiche/common/quiche_data_reader.h",
     "src/quiche/common/quiche_data_writer.h",
     "src/quiche/common/quiche_endian.h",
+    "src/quiche/common/quiche_ip_address.h",
+    "src/quiche/common/quiche_ip_address_family.h",
     "src/quiche/common/quiche_linked_hash_map.h",
     "src/quiche/common/quiche_mem_slice_storage.h",
     "src/quiche/common/quiche_protocol_flags_list.h",
@@ -406,6 +408,8 @@
     "src/quiche/common/quiche_buffer_allocator.cc",
     "src/quiche/common/quiche_data_reader.cc",
     "src/quiche/common/quiche_data_writer.cc",
+    "src/quiche/common/quiche_ip_address.cc",
+    "src/quiche/common/quiche_ip_address_family.cc",
     "src/quiche/common/quiche_mem_slice_storage.cc",
     "src/quiche/common/quiche_text_utils.cc",
     "src/quiche/common/simple_buffer_allocator.cc",
@@ -662,8 +666,6 @@
     "src/quiche/quic/core/tls_server_handshaker.cc",
     "src/quiche/quic/core/uber_quic_stream_id_manager.cc",
     "src/quiche/quic/core/uber_received_packet_manager.cc",
-    "src/quiche/quic/platform/api/quic_ip_address.cc",
-    "src/quiche/quic/platform/api/quic_ip_address_family.cc",
     "src/quiche/quic/platform/api/quic_socket_address.cc",
     "src/quiche/spdy/core/array_output_buffer.cc",
     "src/quiche/spdy/core/hpack/hpack_constants.cc",
@@ -1064,6 +1066,7 @@
     "src/quiche/common/quiche_data_reader_test.cc",
     "src/quiche/common/quiche_data_writer_test.cc",
     "src/quiche/common/quiche_endian_test.cc",
+    "src/quiche/common/quiche_ip_address_test.cc",
     "src/quiche/common/quiche_linked_hash_map_test.cc",
     "src/quiche/common/quiche_mem_slice_storage_test.cc",
     "src/quiche/common/quiche_text_utils_test.cc",
@@ -1269,7 +1272,6 @@
     "src/quiche/quic/core/tls_server_handshaker_test.cc",
     "src/quiche/quic/core/uber_quic_stream_id_manager_test.cc",
     "src/quiche/quic/core/uber_received_packet_manager_test.cc",
-    "src/quiche/quic/platform/api/quic_ip_address_test.cc",
     "src/quiche/quic/platform/api/quic_socket_address_test.cc",
     "src/quiche/quic/test_tools/crypto_test_utils_test.cc",
     "src/quiche/quic/test_tools/quic_test_utils_test.cc",
diff --git a/build/source_list.json b/build/source_list.json
index 6e4aa67..8ab853a 100644
--- a/build/source_list.json
+++ b/build/source_list.json
@@ -47,6 +47,8 @@
     "quiche/common/quiche_data_reader.h",
     "quiche/common/quiche_data_writer.h",
     "quiche/common/quiche_endian.h",
+    "quiche/common/quiche_ip_address.h",
+    "quiche/common/quiche_ip_address_family.h",
     "quiche/common/quiche_linked_hash_map.h",
     "quiche/common/quiche_mem_slice_storage.h",
     "quiche/common/quiche_protocol_flags_list.h",
@@ -405,6 +407,8 @@
     "quiche/common/quiche_buffer_allocator.cc",
     "quiche/common/quiche_data_reader.cc",
     "quiche/common/quiche_data_writer.cc",
+    "quiche/common/quiche_ip_address.cc",
+    "quiche/common/quiche_ip_address_family.cc",
     "quiche/common/quiche_mem_slice_storage.cc",
     "quiche/common/quiche_text_utils.cc",
     "quiche/common/simple_buffer_allocator.cc",
@@ -661,8 +665,6 @@
     "quiche/quic/core/tls_server_handshaker.cc",
     "quiche/quic/core/uber_quic_stream_id_manager.cc",
     "quiche/quic/core/uber_received_packet_manager.cc",
-    "quiche/quic/platform/api/quic_ip_address.cc",
-    "quiche/quic/platform/api/quic_ip_address_family.cc",
     "quiche/quic/platform/api/quic_socket_address.cc",
     "quiche/spdy/core/array_output_buffer.cc",
     "quiche/spdy/core/hpack/hpack_constants.cc",
@@ -1063,6 +1065,7 @@
     "quiche/common/quiche_data_reader_test.cc",
     "quiche/common/quiche_data_writer_test.cc",
     "quiche/common/quiche_endian_test.cc",
+    "quiche/common/quiche_ip_address_test.cc",
     "quiche/common/quiche_linked_hash_map_test.cc",
     "quiche/common/quiche_mem_slice_storage_test.cc",
     "quiche/common/quiche_text_utils_test.cc",
@@ -1268,7 +1271,6 @@
     "quiche/quic/core/tls_server_handshaker_test.cc",
     "quiche/quic/core/uber_quic_stream_id_manager_test.cc",
     "quiche/quic/core/uber_received_packet_manager_test.cc",
-    "quiche/quic/platform/api/quic_ip_address_test.cc",
     "quiche/quic/platform/api/quic_socket_address_test.cc",
     "quiche/quic/test_tools/crypto_test_utils_test.cc",
     "quiche/quic/test_tools/quic_test_utils_test.cc",
diff --git a/quiche/quic/platform/api/quic_ip_address.cc b/quiche/common/quiche_ip_address.cc
similarity index 64%
rename from quiche/quic/platform/api/quic_ip_address.cc
rename to quiche/common/quiche_ip_address.cc
index ba7f6af..fd90deb 100644
--- a/quiche/quic/platform/api/quic_ip_address.cc
+++ b/quiche/common/quiche_ip_address.cc
@@ -2,21 +2,21 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "quiche/quic/platform/api/quic_ip_address.h"
+#include "quiche/common/quiche_ip_address.h"
 
 #include <algorithm>
 #include <cstdint>
 #include <cstring>
 #include <string>
 
-#include "quiche/quic/platform/api/quic_bug_tracker.h"
-#include "quiche/quic/platform/api/quic_ip_address_family.h"
-#include "quiche/quic/platform/api/quic_logging.h"
+#include "quiche/common/platform/api/quiche_bug_tracker.h"
+#include "quiche/common/platform/api/quiche_logging.h"
+#include "quiche/common/quiche_ip_address_family.h"
 
-namespace quic {
+namespace quiche {
 
-QuicIpAddress QuicIpAddress::Loopback4() {
-  QuicIpAddress result;
+QuicheIpAddress QuicheIpAddress::Loopback4() {
+  QuicheIpAddress result;
   result.family_ = IpAddressFamily::IP_V4;
   result.address_.bytes[0] = 127;
   result.address_.bytes[1] = 0;
@@ -25,8 +25,8 @@
   return result;
 }
 
-QuicIpAddress QuicIpAddress::Loopback6() {
-  QuicIpAddress result;
+QuicheIpAddress QuicheIpAddress::Loopback6() {
+  QuicheIpAddress result;
   result.family_ = IpAddressFamily::IP_V6;
   uint8_t* bytes = result.address_.bytes;
   memset(bytes, 0, 15);
@@ -34,63 +34,65 @@
   return result;
 }
 
-QuicIpAddress QuicIpAddress::Any4() {
+QuicheIpAddress QuicheIpAddress::Any4() {
   in_addr address;
   memset(&address, 0, sizeof(address));
-  return QuicIpAddress(address);
+  return QuicheIpAddress(address);
 }
 
-QuicIpAddress QuicIpAddress::Any6() {
+QuicheIpAddress QuicheIpAddress::Any6() {
   in6_addr address;
   memset(&address, 0, sizeof(address));
-  return QuicIpAddress(address);
+  return QuicheIpAddress(address);
 }
 
-QuicIpAddress::QuicIpAddress() : family_(IpAddressFamily::IP_UNSPEC) {}
+QuicheIpAddress::QuicheIpAddress() : family_(IpAddressFamily::IP_UNSPEC) {}
 
-QuicIpAddress::QuicIpAddress(const in_addr& ipv4_address)
+QuicheIpAddress::QuicheIpAddress(const in_addr& ipv4_address)
     : family_(IpAddressFamily::IP_V4) {
   address_.v4 = ipv4_address;
 }
-QuicIpAddress::QuicIpAddress(const in6_addr& ipv6_address)
+QuicheIpAddress::QuicheIpAddress(const in6_addr& ipv6_address)
     : family_(IpAddressFamily::IP_V6) {
   address_.v6 = ipv6_address;
 }
 
-bool operator==(QuicIpAddress lhs, QuicIpAddress rhs) {
+bool operator==(QuicheIpAddress lhs, QuicheIpAddress rhs) {
   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,
+                        lhs.address_.bytes + QuicheIpAddress::kIPv4AddressSize,
                         rhs.address_.bytes);
     case IpAddressFamily::IP_V6:
       return std::equal(lhs.address_.bytes,
-                        lhs.address_.bytes + QuicIpAddress::kIPv6AddressSize,
+                        lhs.address_.bytes + QuicheIpAddress::kIPv6AddressSize,
                         rhs.address_.bytes);
     case IpAddressFamily::IP_UNSPEC:
       return true;
   }
-  QUIC_BUG(quic_bug_10126_2)
+  QUICHE_BUG(quiche_bug_10126_2)
       << "Invalid IpAddressFamily " << static_cast<int32_t>(lhs.family_);
   return false;
 }
 
-bool operator!=(QuicIpAddress lhs, QuicIpAddress rhs) { return !(lhs == rhs); }
+bool operator!=(QuicheIpAddress lhs, QuicheIpAddress rhs) {
+  return !(lhs == rhs);
+}
 
-bool QuicIpAddress::IsInitialized() const {
+bool QuicheIpAddress::IsInitialized() const {
   return family_ != IpAddressFamily::IP_UNSPEC;
 }
 
-IpAddressFamily QuicIpAddress::address_family() const { return family_; }
+IpAddressFamily QuicheIpAddress::address_family() const { return family_; }
 
-int QuicIpAddress::AddressFamilyToInt() const {
+int QuicheIpAddress::AddressFamilyToInt() const {
   return ToPlatformAddressFamily(family_);
 }
 
-std::string QuicIpAddress::ToPackedString() const {
+std::string QuicheIpAddress::ToPackedString() const {
   switch (family_) {
     case IpAddressFamily::IP_V4:
       return std::string(address_.chars, sizeof(address_.v4));
@@ -99,12 +101,12 @@
     case IpAddressFamily::IP_UNSPEC:
       return "";
   }
-  QUIC_BUG(quic_bug_10126_3)
+  QUICHE_BUG(quiche_bug_10126_3)
       << "Invalid IpAddressFamily " << static_cast<int32_t>(family_);
   return "";
 }
 
-std::string QuicIpAddress::ToString() const {
+std::string QuicheIpAddress::ToString() const {
   if (!IsInitialized()) {
     return "";
   }
@@ -112,7 +114,7 @@
   char buffer[INET6_ADDRSTRLEN] = {0};
   const char* result =
       inet_ntop(AddressFamilyToInt(), address_.bytes, buffer, sizeof(buffer));
-  QUIC_BUG_IF(quic_bug_10126_4, result == nullptr)
+  QUICHE_BUG_IF(quiche_bug_10126_4, result == nullptr)
       << "Failed to convert an IP address to string";
   return buffer;
 }
@@ -121,7 +123,7 @@
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
 };
 
-QuicIpAddress QuicIpAddress::Normalized() const {
+QuicheIpAddress QuicheIpAddress::Normalized() const {
   if (!IsIPv6()) {
     return *this;
   }
@@ -132,15 +134,15 @@
 
   in_addr result;
   memcpy(&result, &address_.bytes[12], sizeof(result));
-  return QuicIpAddress(result);
+  return QuicheIpAddress(result);
 }
 
-QuicIpAddress QuicIpAddress::DualStacked() const {
+QuicheIpAddress QuicheIpAddress::DualStacked() const {
   if (!IsIPv4()) {
     return *this;
   }
 
-  QuicIpAddress result;
+  QuicheIpAddress result;
   result.family_ = IpAddressFamily::IP_V6;
   memcpy(result.address_.bytes, kMappedAddressPrefix,
          sizeof(kMappedAddressPrefix));
@@ -148,7 +150,7 @@
   return result;
 }
 
-bool QuicIpAddress::FromPackedString(const char* data, size_t length) {
+bool QuicheIpAddress::FromPackedString(const char* data, size_t length) {
   switch (length) {
     case kIPv4AddressSize:
       family_ = IpAddressFamily::IP_V4;
@@ -163,7 +165,7 @@
   return true;
 }
 
-bool QuicIpAddress::FromString(std::string str) {
+bool QuicheIpAddress::FromString(std::string str) {
   for (IpAddressFamily family :
        {IpAddressFamily::IP_V6, IpAddressFamily::IP_V4}) {
     int result =
@@ -176,19 +178,23 @@
   return false;
 }
 
-bool QuicIpAddress::IsIPv4() const { return family_ == IpAddressFamily::IP_V4; }
+bool QuicheIpAddress::IsIPv4() const {
+  return family_ == IpAddressFamily::IP_V4;
+}
 
-bool QuicIpAddress::IsIPv6() const { return family_ == IpAddressFamily::IP_V6; }
+bool QuicheIpAddress::IsIPv6() const {
+  return family_ == IpAddressFamily::IP_V6;
+}
 
-bool QuicIpAddress::InSameSubnet(const QuicIpAddress& other,
-                                 int subnet_length) {
+bool QuicheIpAddress::InSameSubnet(const QuicheIpAddress& other,
+                                   int subnet_length) {
   if (!IsInitialized()) {
-    QUIC_BUG(quic_bug_10126_5)
+    QUICHE_BUG(quiche_bug_10126_5)
         << "Attempting to do subnet matching on undefined address";
     return false;
   }
   if ((IsIPv4() && subnet_length > 32) || (IsIPv6() && subnet_length > 128)) {
-    QUIC_BUG(quic_bug_10126_6) << "Subnet mask is out of bounds";
+    QUICHE_BUG(quiche_bug_10126_6) << "Subnet mask is out of bounds";
     return false;
   }
 
@@ -207,14 +213,14 @@
   return (lhs[bytes_to_check] & mask) == (rhs[bytes_to_check] & mask);
 }
 
-in_addr QuicIpAddress::GetIPv4() const {
+in_addr QuicheIpAddress::GetIPv4() const {
   QUICHE_DCHECK(IsIPv4());
   return address_.v4;
 }
 
-in6_addr QuicIpAddress::GetIPv6() const {
+in6_addr QuicheIpAddress::GetIPv6() const {
   QUICHE_DCHECK(IsIPv6());
   return address_.v6;
 }
 
-}  // namespace quic
+}  // namespace quiche
diff --git a/quiche/common/quiche_ip_address.h b/quiche/common/quiche_ip_address.h
new file mode 100644
index 0000000..ef7714c
--- /dev/null
+++ b/quiche/common/quiche_ip_address.h
@@ -0,0 +1,98 @@
+// Copyright (c) 2016 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 QUICHE_COMMON_QUICHE_IP_ADDRESS_H_
+#define QUICHE_COMMON_QUICHE_IP_ADDRESS_H_
+
+#if defined(_WIN32)
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#else
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#endif
+
+#include <ostream>
+#include <string>
+
+#include "quiche/common/platform/api/quiche_export.h"
+#include "quiche/common/quiche_ip_address_family.h"
+
+namespace quiche {
+
+// Represents an IP address.
+class QUICHE_EXPORT_PRIVATE QuicheIpAddress {
+ public:
+  // Sizes of IP addresses of different types, in bytes.
+  enum : size_t {
+    kIPv4AddressSize = 32 / 8,
+    kIPv6AddressSize = 128 / 8,
+    kMaxAddressSize = kIPv6AddressSize,
+  };
+
+  // TODO(fayang): Remove Loopback*() and use TestLoopback*() in tests.
+  static QuicheIpAddress Loopback4();
+  static QuicheIpAddress Loopback6();
+  static QuicheIpAddress Any4();
+  static QuicheIpAddress Any6();
+
+  QuicheIpAddress();
+  QuicheIpAddress(const QuicheIpAddress& other) = default;
+  explicit QuicheIpAddress(const in_addr& ipv4_address);
+  explicit QuicheIpAddress(const in6_addr& ipv6_address);
+  QuicheIpAddress& operator=(const QuicheIpAddress& other) = default;
+  QuicheIpAddress& operator=(QuicheIpAddress&& other) = default;
+  QUICHE_EXPORT_PRIVATE friend bool operator==(QuicheIpAddress lhs,
+                                               QuicheIpAddress rhs);
+  QUICHE_EXPORT_PRIVATE friend bool operator!=(QuicheIpAddress lhs,
+                                               QuicheIpAddress rhs);
+
+  bool IsInitialized() const;
+  IpAddressFamily address_family() const;
+  int AddressFamilyToInt() const;
+  // Returns the address as a sequence of bytes in network-byte-order. IPv4 will
+  // be 4 bytes. IPv6 will be 16 bytes.
+  std::string ToPackedString() const;
+  // Returns string representation of the address.
+  std::string ToString() const;
+  // Normalizes the address representation with respect to IPv4 addresses, i.e,
+  // mapped IPv4 addresses ("::ffff:X.Y.Z.Q") are converted to pure IPv4
+  // addresses.  All other IPv4, IPv6, and empty values are left unchanged.
+  QuicheIpAddress Normalized() const;
+  // Returns an address suitable for use in IPv6-aware contexts.  This is the
+  // opposite of NormalizeIPAddress() above.  IPv4 addresses are converted into
+  // their IPv4-mapped address equivalents (e.g. 192.0.2.1 becomes
+  // ::ffff:192.0.2.1).  IPv6 addresses are a noop (they are returned
+  // unchanged).
+  QuicheIpAddress DualStacked() const;
+  bool FromPackedString(const char* data, size_t length);
+  bool FromString(std::string str);
+  bool IsIPv4() const;
+  bool IsIPv6() const;
+  bool InSameSubnet(const QuicheIpAddress& other, int subnet_length);
+
+  in_addr GetIPv4() const;
+  in6_addr GetIPv6() const;
+
+ private:
+  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 QuicheIpAddress address) {
+  os << address.ToString();
+  return os;
+}
+
+}  // namespace quiche
+
+#endif  // QUICHE_COMMON_QUICHE_IP_ADDRESS_H_
diff --git a/quiche/quic/platform/api/quic_ip_address_family.cc b/quiche/common/quiche_ip_address_family.cc
similarity index 79%
rename from quiche/quic/platform/api/quic_ip_address_family.cc
rename to quiche/common/quiche_ip_address_family.cc
index c78abf2..885ddb6 100644
--- a/quiche/quic/platform/api/quic_ip_address_family.cc
+++ b/quiche/common/quiche_ip_address_family.cc
@@ -2,9 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "quiche/quic/platform/api/quic_ip_address_family.h"
+#include "quiche/common/quiche_ip_address_family.h"
 
-#include "quiche/quic/platform/api/quic_bug_tracker.h"
+#include "quiche/common/platform/api/quiche_bug_tracker.h"
 
 #if defined(_WIN32)
 #include <winsock2.h>
@@ -12,7 +12,7 @@
 #include <sys/socket.h>
 #endif  // defined(_WIN32)
 
-namespace quic {
+namespace quiche {
 
 int ToPlatformAddressFamily(IpAddressFamily family) {
   switch (family) {
@@ -23,7 +23,7 @@
     case IpAddressFamily::IP_UNSPEC:
       return AF_UNSPEC;
     default:
-      QUIC_BUG(quic_bug_10126_1)
+      QUICHE_BUG(quic_bug_10126_1)
           << "Invalid IpAddressFamily " << static_cast<int32_t>(family);
       return AF_UNSPEC;
   }
@@ -38,10 +38,10 @@
     case AF_UNSPEC:
       return IpAddressFamily::IP_UNSPEC;
     default:
-      QUIC_BUG(quic_FromPlatformAddressFamily_unrecognized_family)
+      QUICHE_BUG(quic_FromPlatformAddressFamily_unrecognized_family)
           << "Invalid platform address family int " << family;
       return IpAddressFamily::IP_UNSPEC;
   }
 }
 
-}  // namespace quic
+}  // namespace quiche
diff --git a/quiche/common/quiche_ip_address_family.h b/quiche/common/quiche_ip_address_family.h
new file mode 100644
index 0000000..1fbec53
--- /dev/null
+++ b/quiche/common/quiche_ip_address_family.h
@@ -0,0 +1,23 @@
+// Copyright (c) 2016 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 QUICHE_COMMON_QUICHE_IP_ADDRESS_FAMILY_H_
+#define QUICHE_COMMON_QUICHE_IP_ADDRESS_FAMILY_H_
+
+namespace quiche {
+
+// IP address family type used in QUIC. This hides platform dependant IP address
+// family types.
+enum class IpAddressFamily {
+  IP_V4,
+  IP_V6,
+  IP_UNSPEC,
+};
+
+int ToPlatformAddressFamily(IpAddressFamily family);
+IpAddressFamily FromPlatformAddressFamily(int family);
+
+}  // namespace quiche
+
+#endif  // QUICHE_COMMON_QUICHE_IP_ADDRESS_FAMILY_H_
diff --git a/quiche/quic/platform/api/quic_ip_address_test.cc b/quiche/common/quiche_ip_address_test.cc
similarity index 80%
rename from quiche/quic/platform/api/quic_ip_address_test.cc
rename to quiche/common/quiche_ip_address_test.cc
index cc06917..609b6b2 100644
--- a/quiche/quic/platform/api/quic_ip_address_test.cc
+++ b/quiche/common/quiche_ip_address_test.cc
@@ -2,19 +2,19 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "quiche/quic/platform/api/quic_ip_address.h"
+#include "quiche/common/quiche_ip_address.h"
 
 #include <cstdint>
 
-#include "quiche/quic/platform/api/quic_ip_address_family.h"
-#include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/common/platform/api/quiche_test.h"
+#include "quiche/common/quiche_ip_address_family.h"
 
-namespace quic {
+namespace quiche {
 namespace test {
 namespace {
 
-TEST(QuicIpAddressTest, IPv4) {
-  QuicIpAddress ip_address;
+TEST(QuicheIpAddressTest, IPv4) {
+  QuicheIpAddress ip_address;
   EXPECT_FALSE(ip_address.IsInitialized());
 
   EXPECT_TRUE(ip_address.FromString("127.0.52.223"));
@@ -34,8 +34,8 @@
   EXPECT_EQ(223u, *(v4_address_ptr + 3));
 }
 
-TEST(QuicIpAddressTest, IPv6) {
-  QuicIpAddress ip_address;
+TEST(QuicheIpAddressTest, IPv6) {
+  QuicheIpAddress ip_address;
   EXPECT_FALSE(ip_address.IsInitialized());
 
   EXPECT_TRUE(ip_address.FromString("fe80::1ff:fe23:4567"));
@@ -62,19 +62,19 @@
   EXPECT_EQ(ip_address, ip_address.DualStacked());
 }
 
-TEST(QuicIpAddressTest, FromPackedString) {
-  QuicIpAddress loopback4, loopback6;
+TEST(QuicheIpAddressTest, FromPackedString) {
+  QuicheIpAddress 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());
+  EXPECT_EQ(loopback4, QuicheIpAddress::Loopback4());
+  EXPECT_EQ(loopback6, QuicheIpAddress::Loopback6());
 }
 
-TEST(QuicIpAddressTest, MappedAddress) {
-  QuicIpAddress ipv4_address;
-  QuicIpAddress mapped_address;
+TEST(QuicheIpAddressTest, MappedAddress) {
+  QuicheIpAddress ipv4_address;
+  QuicheIpAddress mapped_address;
 
   EXPECT_TRUE(ipv4_address.FromString("127.0.0.1"));
   EXPECT_TRUE(mapped_address.FromString("::ffff:7f00:1"));
@@ -83,7 +83,7 @@
   EXPECT_EQ(ipv4_address, mapped_address.Normalized());
 }
 
-TEST(QuicIpAddressTest, Subnets) {
+TEST(QuicheIpAddressTest, Subnets) {
   struct {
     const char* address1;
     const char* address2;
@@ -118,7 +118,7 @@
   };
 
   for (const auto& test_case : test_cases) {
-    QuicIpAddress address1, address2;
+    QuicheIpAddress address1, address2;
     ASSERT_TRUE(address1.FromString(test_case.address1));
     ASSERT_TRUE(address2.FromString(test_case.address2));
     EXPECT_EQ(test_case.same_subnet,
@@ -128,15 +128,15 @@
   }
 }
 
-TEST(QuicIpAddress, LoopbackAddresses) {
-  QuicIpAddress loopback4;
-  QuicIpAddress loopback6;
+TEST(QuicheIpAddress, LoopbackAddresses) {
+  QuicheIpAddress loopback4;
+  QuicheIpAddress loopback6;
   ASSERT_TRUE(loopback4.FromString("127.0.0.1"));
   ASSERT_TRUE(loopback6.FromString("::1"));
-  EXPECT_EQ(loopback4, QuicIpAddress::Loopback4());
-  EXPECT_EQ(loopback6, QuicIpAddress::Loopback6());
+  EXPECT_EQ(loopback4, QuicheIpAddress::Loopback4());
+  EXPECT_EQ(loopback6, QuicheIpAddress::Loopback6());
 }
 
 }  // namespace
 }  // namespace test
-}  // namespace quic
+}  // namespace quiche
diff --git a/quiche/quic/core/io/socket_posix.cc b/quiche/quic/core/io/socket_posix.cc
index c8d1555..f72b088 100644
--- a/quiche/quic/core/io/socket_posix.cc
+++ b/quiche/quic/core/io/socket_posix.cc
@@ -128,7 +128,7 @@
 absl::StatusOr<SocketFd> CreateSocketWithFlags(IpAddressFamily address_family,
                                                SocketProtocol protocol,
                                                int flags) {
-  int address_family_int = ToPlatformAddressFamily(address_family);
+  int address_family_int = quiche::ToPlatformAddressFamily(address_family);
 
   int type_int = ToPlatformSocketType(protocol);
   type_int |= flags;
diff --git a/quiche/quic/core/quic_udp_socket_posix.cc b/quiche/quic/core/quic_udp_socket_posix.cc
index 400f45b..248fee3 100644
--- a/quiche/quic/core/quic_udp_socket_posix.cc
+++ b/quiche/quic/core/quic_udp_socket_posix.cc
@@ -205,10 +205,10 @@
   // on ios/osx because CMSG_SPACE isn't a constant expression there.
   QUICHE_DCHECK_GE(kDefaultUdpPacketControlBufferSize, kMinCmsgSpaceForRead);
 
-  absl::StatusOr<SocketFd> socket =
-      socket_api::CreateSocket(FromPlatformAddressFamily(address_family),
-                               socket_api::SocketProtocol::kUdp,
-                               /*blocking=*/false);
+  absl::StatusOr<SocketFd> socket = socket_api::CreateSocket(
+      quiche::FromPlatformAddressFamily(address_family),
+      socket_api::SocketProtocol::kUdp,
+      /*blocking=*/false);
 
   if (!socket.ok()) {
     QUIC_LOG_FIRST_N(ERROR, 100)
diff --git a/quiche/quic/platform/api/quic_ip_address.h b/quiche/quic/platform/api/quic_ip_address.h
index 685cde8..7f2ed20 100644
--- a/quiche/quic/platform/api/quic_ip_address.h
+++ b/quiche/quic/platform/api/quic_ip_address.h
@@ -5,92 +5,11 @@
 #ifndef QUICHE_QUIC_PLATFORM_API_QUIC_IP_ADDRESS_H_
 #define QUICHE_QUIC_PLATFORM_API_QUIC_IP_ADDRESS_H_
 
-#if defined(_WIN32)
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#else
-#include <arpa/inet.h>
-#include <netinet/in.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#endif
-
-#include <ostream>
-#include <string>
-
-#include "quiche/quic/platform/api/quic_export.h"
-#include "quiche/quic/platform/api/quic_ip_address_family.h"
+#include "quiche/common/quiche_ip_address.h"
 
 namespace quic {
 
-// Represents an IP address.
-class QUIC_EXPORT_PRIVATE QuicIpAddress {
- public:
-  // Sizes of IP addresses of different types, in bytes.
-  enum : size_t {
-    kIPv4AddressSize = 32 / 8,
-    kIPv6AddressSize = 128 / 8,
-    kMaxAddressSize = kIPv6AddressSize,
-  };
-
-  // TODO(fayang): Remove Loopback*() and use TestLoopback*() in tests.
-  static QuicIpAddress Loopback4();
-  static QuicIpAddress Loopback6();
-  static QuicIpAddress Any4();
-  static QuicIpAddress Any6();
-
-  QuicIpAddress();
-  QuicIpAddress(const QuicIpAddress& other) = default;
-  explicit QuicIpAddress(const in_addr& ipv4_address);
-  explicit QuicIpAddress(const in6_addr& ipv6_address);
-  QuicIpAddress& operator=(const QuicIpAddress& other) = default;
-  QuicIpAddress& operator=(QuicIpAddress&& other) = default;
-  QUIC_EXPORT_PRIVATE friend bool operator==(QuicIpAddress lhs,
-                                             QuicIpAddress rhs);
-  QUIC_EXPORT_PRIVATE friend bool operator!=(QuicIpAddress lhs,
-                                             QuicIpAddress rhs);
-
-  bool IsInitialized() const;
-  IpAddressFamily address_family() const;
-  int AddressFamilyToInt() const;
-  // Returns the address as a sequence of bytes in network-byte-order. IPv4 will
-  // be 4 bytes. IPv6 will be 16 bytes.
-  std::string ToPackedString() const;
-  // Returns string representation of the address.
-  std::string ToString() const;
-  // Normalizes the address representation with respect to IPv4 addresses, i.e,
-  // mapped IPv4 addresses ("::ffff:X.Y.Z.Q") are converted to pure IPv4
-  // addresses.  All other IPv4, IPv6, and empty values are left unchanged.
-  QuicIpAddress Normalized() const;
-  // Returns an address suitable for use in IPv6-aware contexts.  This is the
-  // opposite of NormalizeIPAddress() above.  IPv4 addresses are converted into
-  // their IPv4-mapped address equivalents (e.g. 192.0.2.1 becomes
-  // ::ffff:192.0.2.1).  IPv6 addresses are a noop (they are returned
-  // unchanged).
-  QuicIpAddress DualStacked() const;
-  bool FromPackedString(const char* data, size_t length);
-  bool FromString(std::string str);
-  bool IsIPv4() const;
-  bool IsIPv6() const;
-  bool InSameSubnet(const QuicIpAddress& other, int subnet_length);
-
-  in_addr GetIPv4() const;
-  in6_addr GetIPv6() const;
-
- private:
-  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;
-}
+using QuicIpAddress = ::quiche::QuicheIpAddress;
 
 }  // namespace quic
 
diff --git a/quiche/quic/platform/api/quic_ip_address_family.h b/quiche/quic/platform/api/quic_ip_address_family.h
index ad3963c..0aeac17 100644
--- a/quiche/quic/platform/api/quic_ip_address_family.h
+++ b/quiche/quic/platform/api/quic_ip_address_family.h
@@ -5,18 +5,11 @@
 #ifndef QUICHE_QUIC_PLATFORM_API_QUIC_IP_ADDRESS_FAMILY_H_
 #define QUICHE_QUIC_PLATFORM_API_QUIC_IP_ADDRESS_FAMILY_H_
 
+#include "quiche/common/quiche_ip_address_family.h"
+
 namespace quic {
 
-// IP address family type used in QUIC. This hides platform dependant IP address
-// family types.
-enum class IpAddressFamily {
-  IP_V4,
-  IP_V6,
-  IP_UNSPEC,
-};
-
-int ToPlatformAddressFamily(IpAddressFamily family);
-IpAddressFamily FromPlatformAddressFamily(int family);
+using IpAddressFamily = ::quiche::IpAddressFamily;
 
 }  // namespace quic