Project import generated by Copybara.
PiperOrigin-RevId: 237361882
Change-Id: I109a68f44db867b20f8c6a7732b0ce657133e52a
diff --git a/quic/platform/api/quic_aligned.h b/quic/platform/api/quic_aligned.h
new file mode 100644
index 0000000..ecfa649
--- /dev/null
+++ b/quic/platform/api/quic_aligned.h
@@ -0,0 +1,15 @@
+// Copyright 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_QUIC_PLATFORM_API_QUIC_ALIGNED_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_ALIGNED_H_
+
+#include "net/quic/platform/impl/quic_aligned_impl.h"
+
+#define QUIC_ALIGN_OF QUIC_ALIGN_OF_IMPL
+#define QUIC_ALIGNED(X) QUIC_ALIGNED_IMPL(X)
+#define QUIC_CACHELINE_ALIGNED QUIC_CACHELINE_ALIGNED_IMPL
+#define QUIC_CACHELINE_SIZE QUIC_CACHELINE_SIZE_IMPL
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_ALIGNED_H_
diff --git a/quic/platform/api/quic_arraysize.h b/quic/platform/api/quic_arraysize.h
new file mode 100644
index 0000000..eaa2a92
--- /dev/null
+++ b/quic/platform/api/quic_arraysize.h
@@ -0,0 +1,12 @@
+// Copyright 2017 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_QUIC_PLATFORM_API_QUIC_ARRAYSIZE_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_ARRAYSIZE_H_
+
+#include "net/quic/platform/impl/quic_arraysize_impl.h"
+
+#define QUIC_ARRAYSIZE(array) QUIC_ARRAYSIZE_IMPL(array)
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_ARRAYSIZE_H_
diff --git a/quic/platform/api/quic_bug_tracker.h b/quic/platform/api/quic_bug_tracker.h
new file mode 100644
index 0000000..23bcb7b
--- /dev/null
+++ b/quic/platform/api/quic_bug_tracker.h
@@ -0,0 +1,15 @@
+// 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_QUIC_PLATFORM_API_QUIC_BUG_TRACKER_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_BUG_TRACKER_H_
+
+#include "net/quic/platform/impl/quic_bug_tracker_impl.h"
+
+#define QUIC_BUG QUIC_BUG_IMPL
+#define QUIC_BUG_IF QUIC_BUG_IF_IMPL
+#define QUIC_PEER_BUG QUIC_PEER_BUG_IMPL
+#define QUIC_PEER_BUG_IF QUIC_PEER_BUG_IF_IMPL
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_BUG_TRACKER_H_
diff --git a/quic/platform/api/quic_cert_utils.h b/quic/platform/api/quic_cert_utils.h
new file mode 100644
index 0000000..1c660b5
--- /dev/null
+++ b/quic/platform/api/quic_cert_utils.h
@@ -0,0 +1,23 @@
+// Copyright 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_QUIC_PLATFORM_API_QUIC_CERT_UTILS_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_CERT_UTILS_H_
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+#include "net/quic/platform/impl/quic_cert_utils_impl.h"
+
+namespace quic {
+
+class QuicCertUtils {
+ public:
+ static bool ExtractSubjectNameFromDERCert(QuicStringPiece cert,
+ QuicStringPiece* subject_out) {
+ return QuicCertUtilsImpl::ExtractSubjectNameFromDERCert(cert, subject_out);
+ }
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_CERT_UTILS_H_
diff --git a/quic/platform/api/quic_client_stats.h b/quic/platform/api/quic_client_stats.h
new file mode 100644
index 0000000..b780ba6
--- /dev/null
+++ b/quic/platform/api/quic_client_stats.h
@@ -0,0 +1,87 @@
+// Copyright 2018 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_QUIC_PLATFORM_API_QUIC_CLIENT_STATS_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_CLIENT_STATS_H_
+
+#include <string>
+#include "net/quic/platform/impl/quic_client_stats_impl.h"
+
+namespace quic {
+
+//------------------------------------------------------------------------------
+// Enumeration histograms.
+//
+// Sample usage:
+// // In Chrome, these values are persisted to logs. Entries should not be
+// // renumbered and numeric values should never be reused.
+// enum class MyEnum {
+// FIRST_VALUE = 0,
+// SECOND_VALUE = 1,
+// ...
+// FINAL_VALUE = N,
+// COUNT
+// };
+// QUIC_CLIENT_HISTOGRAM_ENUM("My.Enumeration", MyEnum::SOME_VALUE,
+// MyEnum::COUNT, "Number of time $foo equals to some enum value");
+//
+// Note: The value in |sample| must be strictly less than |enum_size|.
+
+#define QUIC_CLIENT_HISTOGRAM_ENUM(name, sample, enum_size, docstring) \
+ QUIC_CLIENT_HISTOGRAM_ENUM_IMPL(name, sample, enum_size, docstring)
+
+//------------------------------------------------------------------------------
+// Histogram for boolean values.
+
+// Sample usage:
+// QUIC_CLIENT_HISTOGRAM_BOOL("My.Boolean", bool,
+// "Number of times $foo is true or false");
+#define QUIC_CLIENT_HISTOGRAM_BOOL(name, sample, docstring) \
+ QUIC_CLIENT_HISTOGRAM_BOOL_IMPL(name, sample, docstring)
+
+//------------------------------------------------------------------------------
+// Timing histograms. These are used for collecting timing data (generally
+// latencies).
+
+// These macros create exponentially sized histograms (lengths of the bucket
+// ranges exponentially increase as the sample range increases). The units for
+// sample and max are unspecified, but they must be the same for one histogram.
+
+// Sample usage:
+// QUIC_CLIENT_HISTOGRAM_TIMES("Very.Long.Timing.Histogram", time_delta,
+// QuicTime::Delta::FromSeconds(1), QuicTime::Delta::FromSecond(3600 *
+// 24), 100, "Time spent in doing operation.");
+#define QUIC_CLIENT_HISTOGRAM_TIMES(name, sample, min, max, bucket_count, \
+ docstring) \
+ QUIC_CLIENT_HISTOGRAM_TIMES_IMPL(name, sample, min, max, bucket_count, \
+ docstring)
+
+//------------------------------------------------------------------------------
+// Count histograms. These are used for collecting numeric data.
+
+// These macros default to exponential histograms - i.e. the lengths of the
+// bucket ranges exponentially increase as the sample range increases.
+
+// All of these macros must be called with |name| as a runtime constant.
+
+// Any data outside the range here will be put in underflow and overflow
+// buckets. Min values should be >=1 as emitted 0s will still go into the
+// underflow bucket.
+
+// Sample usage:
+// UMA_CLIENT_HISTOGRAM_CUSTOM_COUNTS("My.Histogram", 1, 100000000, 100,
+// "Counters of hitting certian code.");
+
+#define QUIC_CLIENT_HISTOGRAM_COUNTS(name, sample, min, max, bucket_count, \
+ docstring) \
+ QUIC_CLIENT_HISTOGRAM_COUNTS_IMPL(name, sample, min, max, bucket_count, \
+ docstring)
+
+inline void QuicClientSparseHistogram(const std::string& name, int sample) {
+ QuicClientSparseHistogramImpl(name, sample);
+}
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_CLIENT_STATS_H_
diff --git a/quic/platform/api/quic_clock.cc b/quic/platform/api/quic_clock.cc
new file mode 100644
index 0000000..03851fa
--- /dev/null
+++ b/quic/platform/api/quic_clock.cc
@@ -0,0 +1,70 @@
+// 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 "net/third_party/quiche/src/quic/platform/api/quic_clock.h"
+
+#include <limits>
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
+
+namespace quic {
+
+QuicClock::QuicClock()
+ : is_calibrated_(false), calibration_offset_(QuicTime::Delta::Zero()) {}
+
+QuicClock::~QuicClock() {}
+
+QuicTime::Delta QuicClock::ComputeCalibrationOffset() const {
+ // In the ideal world, all we need to do is to return the difference of
+ // WallNow() and Now(). In the real world, things like context switch may
+ // happen between the calls to WallNow() and Now(), causing their difference
+ // to be arbitrarily large, so we repeat the calculation many times and use
+ // the one with the minimum difference as the true offset.
+ int64_t min_offset_us = std::numeric_limits<int64_t>::max();
+
+ for (int i = 0; i < 128; ++i) {
+ int64_t now_in_us = (Now() - QuicTime::Zero()).ToMicroseconds();
+ int64_t wallnow_in_us =
+ static_cast<int64_t>(WallNow().ToUNIXMicroseconds());
+
+ int64_t offset_us = wallnow_in_us - now_in_us;
+ if (offset_us < min_offset_us) {
+ min_offset_us = offset_us;
+ }
+ }
+
+ return QuicTime::Delta::FromMicroseconds(min_offset_us);
+}
+
+void QuicClock::SetCalibrationOffset(QuicTime::Delta offset) {
+ DCHECK(!is_calibrated_) << "A clock should only be calibrated once";
+ calibration_offset_ = offset;
+ is_calibrated_ = true;
+}
+
+QuicTime QuicClock::ConvertWallTimeToQuicTime(
+ const QuicWallTime& walltime) const {
+ if (is_calibrated_) {
+ int64_t time_in_us = static_cast<int64_t>(walltime.ToUNIXMicroseconds()) -
+ calibration_offset_.ToMicroseconds();
+ return QuicTime::Zero() + QuicTime::Delta::FromMicroseconds(time_in_us);
+ }
+
+ // ..........................
+ // | | |
+ // unix epoch |walltime| WallNow()
+ // ..........................
+ // | | |
+ // clock epoch | Now()
+ // result
+ //
+ // result = Now() - (WallNow() - walltime)
+ return Now() - QuicTime::Delta::FromMicroseconds(
+ WallNow()
+ .Subtract(QuicTime::Delta::FromMicroseconds(
+ walltime.ToUNIXMicroseconds()))
+ .ToUNIXMicroseconds());
+}
+
+} // namespace quic
diff --git a/quic/platform/api/quic_clock.h b/quic/platform/api/quic_clock.h
new file mode 100644
index 0000000..afd82dc
--- /dev/null
+++ b/quic/platform/api/quic_clock.h
@@ -0,0 +1,67 @@
+// 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.
+
+#ifndef QUICHE_QUIC_PLATFORM_API_QUIC_CLOCK_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_CLOCK_H_
+
+#include "net/third_party/quiche/src/quic/core/quic_time.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
+
+namespace quic {
+
+// Interface for retrieving the current time.
+class QUIC_EXPORT_PRIVATE QuicClock {
+ public:
+ QuicClock();
+ virtual ~QuicClock();
+
+ QuicClock(const QuicClock&) = delete;
+ QuicClock& operator=(const QuicClock&) = delete;
+
+ // Compute the offset between this clock with the Unix Epoch clock.
+ // Return the calibrated offset between WallNow() and Now(), in the form of
+ // (wallnow_in_us - now_in_us).
+ // The return value can be used by SetCalibrationOffset() to actually
+ // calibrate the clock, or all instances of this clock type.
+ QuicTime::Delta ComputeCalibrationOffset() const;
+
+ // Calibrate this clock. A calibrated clock guarantees that the
+ // ConvertWallTimeToQuicTime() function always return the same result for the
+ // same walltime.
+ // Should not be called more than once for each QuicClock.
+ void SetCalibrationOffset(QuicTime::Delta offset);
+
+ // Returns the approximate current time as a QuicTime object.
+ virtual QuicTime ApproximateNow() const = 0;
+
+ // Returns the current time as a QuicTime object.
+ // Note: this use significant resources please use only if needed.
+ virtual QuicTime Now() const = 0;
+
+ // WallNow returns the current wall-time - a time that is consistent across
+ // different clocks.
+ virtual QuicWallTime WallNow() const = 0;
+
+ // Converts |walltime| to a QuicTime relative to this clock's epoch.
+ virtual QuicTime ConvertWallTimeToQuicTime(
+ const QuicWallTime& walltime) const;
+
+ protected:
+ // Creates a new QuicTime using |time_us| as the internal value.
+ QuicTime CreateTimeFromMicroseconds(uint64_t time_us) const {
+ return QuicTime(time_us);
+ }
+
+ private:
+ // True if |calibration_offset_| is valid.
+ bool is_calibrated_;
+ // If |is_calibrated_|, |calibration_offset_| is the (fixed) offset between
+ // the Unix Epoch clock and this clock.
+ // In other words, the offset between WallNow() and Now().
+ QuicTime::Delta calibration_offset_;
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_CLOCK_H_
diff --git a/quic/platform/api/quic_containers.h b/quic/platform/api/quic_containers.h
new file mode 100644
index 0000000..7cfb311
--- /dev/null
+++ b/quic/platform/api/quic_containers.h
@@ -0,0 +1,56 @@
+// Copyright (c) 2017 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_QUIC_PLATFORM_API_QUIC_CONTAINERS_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_CONTAINERS_H_
+
+#include "net/quic/platform/impl/quic_containers_impl.h"
+
+namespace quic {
+
+// The default hasher used by hash tables.
+template <typename Key>
+using QuicDefaultHasher = QuicDefaultHasherImpl<Key>;
+
+// A general-purpose unordered map.
+template <typename Key, typename Value, typename Hash = QuicDefaultHasher<Key>>
+using QuicUnorderedMap = QuicUnorderedMapImpl<Key, Value, Hash>;
+
+// A general-purpose unordered set.
+template <typename Key, typename Hash = QuicDefaultHasher<Key>>
+using QuicUnorderedSet = QuicUnorderedSetImpl<Key, Hash>;
+
+// A map which offers insertion-ordered iteration.
+template <typename Key, typename Value, typename Hash = QuicDefaultHasher<Key>>
+using QuicLinkedHashMap = QuicLinkedHashMapImpl<Key, Value, Hash>;
+
+// Used for maps that are typically small, then it is faster than (for example)
+// hash_map which is optimized for large data sets. QuicSmallMap upgrades itself
+// automatically to a QuicSmallMapImpl-specified map when it runs out of space.
+//
+// DOES NOT GUARANTEE POINTER OR ITERATOR STABILITY!
+template <typename Key, typename Value, int Size>
+using QuicSmallMap = QuicSmallMapImpl<Key, Value, Size>;
+
+// Represents a simple queue which may be backed by a list or
+// a flat circular buffer.
+//
+// DOES NOT GUARANTEE POINTER OR ITERATOR STABILITY!
+template <typename T>
+using QuicQueue = QuicQueueImpl<T>;
+
+// Represents a double-ended queue which may be backed by a list or
+// a flat circular buffer.
+//
+// DOES NOT GUARANTEE POINTER OR ITERATOR STABILITY!
+template <typename T>
+using QuicDeque = QuicDequeImpl<T>;
+
+// A vector optimized for small sizes. Provides the same APIs as a std::vector.
+template <typename T, size_t N, typename A = std::allocator<T>>
+using QuicInlinedVector = QuicInlinedVectorImpl<T, N, A>;
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_CONTAINERS_H_
diff --git a/quic/platform/api/quic_containers_test.cc b/quic/platform/api/quic_containers_test.cc
new file mode 100644
index 0000000..b272b09
--- /dev/null
+++ b/quic/platform/api/quic_containers_test.cc
@@ -0,0 +1,63 @@
+// Copyright (c) 2018 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 "net/third_party/quiche/src/quic/platform/api/quic_containers.h"
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
+
+using ::testing::ElementsAre;
+
+namespace quic {
+namespace test {
+namespace {
+
+TEST(QuicInlinedVectorTest, Swap) {
+ {
+ // Inline to inline.
+ QuicInlinedVector<int, 2> self({1, 2});
+ QuicInlinedVector<int, 2> other({3});
+
+ self.swap(other);
+
+ EXPECT_THAT(self, ElementsAre(3));
+ EXPECT_THAT(other, ElementsAre(1, 2));
+ }
+
+ {
+ // Inline to out-of-line.
+ QuicInlinedVector<int, 2> self({1, 2});
+ QuicInlinedVector<int, 2> other({3, 4, 5, 6});
+
+ self.swap(other);
+
+ EXPECT_THAT(self, ElementsAre(3, 4, 5, 6));
+ EXPECT_THAT(other, ElementsAre(1, 2));
+ }
+
+ {
+ // Out-of-line to inline.
+ QuicInlinedVector<int, 2> self({1, 2, 3});
+ QuicInlinedVector<int, 2> other({4, 5});
+
+ self.swap(other);
+
+ EXPECT_THAT(self, ElementsAre(4, 5));
+ EXPECT_THAT(other, ElementsAre(1, 2, 3));
+ }
+
+ {
+ // Out-of-line to Out-of-line.
+ QuicInlinedVector<int, 2> self({1, 2, 3});
+ QuicInlinedVector<int, 2> other({4, 5, 6, 7});
+
+ self.swap(other);
+
+ EXPECT_THAT(self, ElementsAre(4, 5, 6, 7));
+ EXPECT_THAT(other, ElementsAre(1, 2, 3));
+ }
+}
+
+} // namespace
+} // namespace test
+} // namespace quic
diff --git a/quic/platform/api/quic_default_proof_providers.h b/quic/platform/api/quic_default_proof_providers.h
new file mode 100644
index 0000000..6f3b636
--- /dev/null
+++ b/quic/platform/api/quic_default_proof_providers.h
@@ -0,0 +1,31 @@
+// Copyright (c) 2019 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_QUIC_PLATFORM_API_QUIC_DEFAULT_PROOF_PROVIDERS_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_DEFAULT_PROOF_PROVIDERS_H_
+
+#include <memory>
+
+#include "net/third_party/quiche/src/quic/core/crypto/proof_source.h"
+#include "net/third_party/quiche/src/quic/core/crypto/proof_verifier.h"
+#include "net/quic/platform/impl/quic_default_proof_providers_impl.h"
+
+namespace quic {
+
+// Provides a default proof verifier. The verifier has to do a good faith
+// attempt at verifying the certificate against a reasonable root store, and not
+// just always return success.
+inline std::unique_ptr<ProofVerifier> CreateDefaultProofVerifier() {
+ return CreateDefaultProofVerifierImpl();
+}
+
+// Provides a default proof source for CLI-based tools. The actual certificates
+// used in the proof source should be confifgurable via command-line flags.
+inline std::unique_ptr<ProofSource> CreateDefaultProofSource() {
+ return CreateDefaultProofSourceImpl();
+}
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_DEFAULT_PROOF_PROVIDERS_H_
diff --git a/quic/platform/api/quic_endian.h b/quic/platform/api/quic_endian.h
new file mode 100644
index 0000000..65edd51
--- /dev/null
+++ b/quic/platform/api/quic_endian.h
@@ -0,0 +1,54 @@
+// Copyright 2017 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_QUIC_PLATFORM_API_QUIC_ENDIAN_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_ENDIAN_H_
+
+#include "net/quic/platform/impl/quic_endian_impl.h"
+
+namespace quic {
+
+enum Endianness {
+ NETWORK_BYTE_ORDER, // big endian
+ HOST_BYTE_ORDER // little endian
+};
+
+// Provide utility functions that convert from/to network order (big endian)
+// to/from host order (can be either little or big endian depending on the
+// platform).
+class QuicEndian {
+ public:
+ // Convert |x| from host order (can be either little or big endian depending
+ // on the platform) to network order (big endian).
+ static uint16_t HostToNet16(uint16_t x) {
+ return QuicEndianImpl::HostToNet16(x);
+ }
+ static uint32_t HostToNet32(uint32_t x) {
+ return QuicEndianImpl::HostToNet32(x);
+ }
+ static uint64_t HostToNet64(uint64_t x) {
+ return QuicEndianImpl::HostToNet64(x);
+ }
+
+ // Convert |x| from network order (big endian) to host order (can be either
+ // little or big endian depending on the platform).
+ static uint16_t NetToHost16(uint16_t x) {
+ return QuicEndianImpl::NetToHost16(x);
+ }
+ static uint32_t NetToHost32(uint32_t x) {
+ return QuicEndianImpl::NetToHost32(x);
+ }
+ static uint64_t NetToHost64(uint64_t x) {
+ return QuicEndianImpl::NetToHost64(x);
+ }
+
+ // Returns true if current host order is little endian.
+ static bool HostIsLittleEndian() {
+ return QuicEndianImpl::HostIsLittleEndian();
+ }
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_ENDIAN_H_
diff --git a/quic/platform/api/quic_endian_test.cc b/quic/platform/api/quic_endian_test.cc
new file mode 100644
index 0000000..d054d96
--- /dev/null
+++ b/quic/platform/api/quic_endian_test.cc
@@ -0,0 +1,51 @@
+// Copyright 2017 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 "net/third_party/quiche/src/quic/platform/api/quic_endian.h"
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
+
+namespace quic {
+namespace test {
+namespace {
+
+const uint16_t k16BitTestData = 0xaabb;
+const uint16_t k16BitSwappedTestData = 0xbbaa;
+const uint32_t k32BitTestData = 0xaabbccdd;
+const uint32_t k32BitSwappedTestData = 0xddccbbaa;
+const uint64_t k64BitTestData = 0xaabbccdd44332211;
+const uint64_t k64BitSwappedTestData = 0x11223344ddccbbaa;
+
+class QuicEndianTest : public QuicTest {};
+
+TEST_F(QuicEndianTest, HostToNet) {
+ if (QuicEndian::HostIsLittleEndian()) {
+ EXPECT_EQ(k16BitSwappedTestData, QuicEndian::HostToNet16(k16BitTestData));
+ EXPECT_EQ(k32BitSwappedTestData, QuicEndian::HostToNet32(k32BitTestData));
+ EXPECT_EQ(k64BitSwappedTestData, QuicEndian::HostToNet64(k64BitTestData));
+ } else {
+ EXPECT_EQ(k16BitTestData, QuicEndian::HostToNet16(k16BitTestData));
+ EXPECT_EQ(k32BitTestData, QuicEndian::HostToNet32(k32BitTestData));
+ EXPECT_EQ(k64BitTestData, QuicEndian::HostToNet64(k64BitTestData));
+ }
+}
+
+TEST_F(QuicEndianTest, NetToHost) {
+ if (QuicEndian::HostIsLittleEndian()) {
+ EXPECT_EQ(k16BitTestData, QuicEndian::NetToHost16(k16BitSwappedTestData));
+ EXPECT_EQ(k32BitTestData, QuicEndian::NetToHost32(k32BitSwappedTestData));
+ EXPECT_EQ(k64BitTestData, QuicEndian::NetToHost64(k64BitSwappedTestData));
+ } else {
+ EXPECT_EQ(k16BitSwappedTestData,
+ QuicEndian::NetToHost16(k16BitSwappedTestData));
+ EXPECT_EQ(k32BitSwappedTestData,
+ QuicEndian::NetToHost32(k32BitSwappedTestData));
+ EXPECT_EQ(k64BitSwappedTestData,
+ QuicEndian::NetToHost64(k64BitSwappedTestData));
+ }
+}
+
+} // namespace
+} // namespace test
+} // namespace quic
diff --git a/quic/platform/api/quic_epoll.h b/quic/platform/api/quic_epoll.h
new file mode 100644
index 0000000..e429ef8
--- /dev/null
+++ b/quic/platform/api/quic_epoll.h
@@ -0,0 +1,19 @@
+// Copyright (c) 2019 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_QUIC_PLATFORM_API_QUIC_EPOLL_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_EPOLL_H_
+
+#include "net/quic/platform/impl/quic_epoll_impl.h"
+
+namespace quic {
+
+using QuicEpollServer = QuicEpollServerImpl;
+using QuicEpollEvent = QuicEpollEventImpl;
+using QuicEpollAlarmBase = QuicEpollAlarmBaseImpl;
+using QuicEpollCallbackInterface = QuicEpollCallbackInterfaceImpl;
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_EPOLL_H_
diff --git a/quic/platform/api/quic_epoll_test_tools.h b/quic/platform/api/quic_epoll_test_tools.h
new file mode 100644
index 0000000..a7c2ce3
--- /dev/null
+++ b/quic/platform/api/quic_epoll_test_tools.h
@@ -0,0 +1,12 @@
+// Copyright (c) 2019 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_QUIC_PLATFORM_API_QUIC_EPOLL_TEST_TOOLS_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_EPOLL_TEST_TOOLS_H_
+
+#include "net/quic/platform/impl/quic_epoll_test_tools_impl.h"
+
+using QuicFakeEpollServer = QuicFakeEpollServerImpl;
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_EPOLL_TEST_TOOLS_H_
diff --git a/quic/platform/api/quic_error_code_wrappers.h b/quic/platform/api/quic_error_code_wrappers.h
new file mode 100644
index 0000000..733572e
--- /dev/null
+++ b/quic/platform/api/quic_error_code_wrappers.h
@@ -0,0 +1,14 @@
+// Copyright (c) 2019 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_QUIC_PLATFORM_API_QUIC_ERROR_CODE_WRAPPERS_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_ERROR_CODE_WRAPPERS_H_
+
+#include "net/quic/platform/impl/quic_error_code_wrappers_impl.h"
+
+// TODO(vasilvv): ensure WRITE_STATUS_MSG_TOO_BIG works everywhere and remove
+// this.
+#define QUIC_EMSGSIZE QUIC_EMSGSIZE_IMPL
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_ERROR_CODE_WRAPPERS_H_
diff --git a/quic/platform/api/quic_estimate_memory_usage.h b/quic/platform/api/quic_estimate_memory_usage.h
new file mode 100644
index 0000000..dd84485
--- /dev/null
+++ b/quic/platform/api/quic_estimate_memory_usage.h
@@ -0,0 +1,21 @@
+// Copyright 2017 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_QUIC_PLATFORM_API_QUIC_ESTIMATE_MEMORY_USAGE_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_ESTIMATE_MEMORY_USAGE_H_
+
+#include <cstddef>
+
+#include "net/quic/platform/impl/quic_estimate_memory_usage_impl.h"
+
+namespace quic {
+
+template <class T>
+size_t QuicEstimateMemoryUsage(const T& object) {
+ return QuicEstimateMemoryUsageImpl(object);
+}
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_ESTIMATE_MEMORY_USAGE_H_
diff --git a/quic/platform/api/quic_expect_bug.h b/quic/platform/api/quic_expect_bug.h
new file mode 100644
index 0000000..936b11f
--- /dev/null
+++ b/quic/platform/api/quic_expect_bug.h
@@ -0,0 +1,14 @@
+// Copyright (c) 2018 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_QUIC_PLATFORM_API_QUIC_EXPECT_BUG_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_EXPECT_BUG_H_
+
+#include "net/quic/platform/impl/quic_expect_bug_impl.h"
+
+#define EXPECT_QUIC_BUG EXPECT_QUIC_BUG_IMPL
+#define EXPECT_QUIC_PEER_BUG(statement, regex) \
+ EXPECT_QUIC_PEER_BUG_IMPL(statement, regex)
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_EXPECT_BUG_H_
diff --git a/quic/platform/api/quic_export.h b/quic/platform/api/quic_export.h
new file mode 100644
index 0000000..8ffd676
--- /dev/null
+++ b/quic/platform/api/quic_export.h
@@ -0,0 +1,10 @@
+// Copyright 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_QUIC_PLATFORM_API_QUIC_EXPORT_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_EXPORT_H_
+
+#include "net/quic/platform/impl/quic_export_impl.h"
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_EXPORT_H_
diff --git a/quic/platform/api/quic_exported_stats.h b/quic/platform/api/quic_exported_stats.h
new file mode 100644
index 0000000..28c82ec
--- /dev/null
+++ b/quic/platform/api/quic_exported_stats.h
@@ -0,0 +1,96 @@
+// Copyright 2018 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_QUIC_PLATFORM_API_QUIC_EXPORTED_STATS_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_EXPORTED_STATS_H_
+
+#include "net/quic/platform/impl/quic_client_stats_impl.h"
+#include "net/quic/platform/impl/quic_server_stats_impl.h"
+
+namespace quic {
+
+// TODO(wub): Add support for counters. Only histograms are supported for now.
+
+//------------------------------------------------------------------------------
+// Enumeration histograms.
+//
+// Sample usage:
+// // In Chrome, these values are persisted to logs. Entries should not be
+// // renumbered and numeric values should never be reused.
+// enum class MyEnum {
+// FIRST_VALUE = 0,
+// SECOND_VALUE = 1,
+// ...
+// FINAL_VALUE = N,
+// COUNT
+// };
+// QUIC_HISTOGRAM_ENUM("My.Enumeration", MyEnum::SOME_VALUE, MyEnum::COUNT,
+// "Number of time $foo equals to some enum value");
+//
+// Note: The value in |sample| must be strictly less than |enum_size|.
+
+#define QUIC_HISTOGRAM_ENUM(name, sample, enum_size, docstring) \
+ do { \
+ QUIC_CLIENT_HISTOGRAM_ENUM_IMPL(name, sample, enum_size, docstring); \
+ QUIC_SERVER_HISTOGRAM_ENUM_IMPL(name, sample, enum_size, docstring); \
+ } while (0)
+
+//------------------------------------------------------------------------------
+// Histogram for boolean values.
+
+// Sample usage:
+// QUIC_HISTOGRAM_BOOL("My.Boolean", bool,
+// "Number of times $foo is true or false");
+#define QUIC_HISTOGRAM_BOOL(name, sample, docstring) \
+ do { \
+ QUIC_CLIENT_HISTOGRAM_BOOL_IMPL(name, sample, docstring); \
+ QUIC_SERVER_HISTOGRAM_BOOL_IMPL(name, sample, docstring); \
+ } while (0)
+
+//------------------------------------------------------------------------------
+// Timing histograms. These are used for collecting timing data (generally
+// latencies).
+
+// These macros create exponentially sized histograms (lengths of the bucket
+// ranges exponentially increase as the sample range increases). The units for
+// sample and max are unspecified, but they must be the same for one histogram.
+
+// Sample usage:
+// QUIC_HISTOGRAM_TIMES("My.Timing.Histogram.InMs", time_delta,
+// QuicTime::Delta::FromSeconds(1), QuicTime::Delta::FromSecond(3600 *
+// 24), 100, "Time spent in doing operation.");
+
+#define QUIC_HISTOGRAM_TIMES(name, sample, min, max, bucket_count, docstring) \
+ do { \
+ QUIC_CLIENT_HISTOGRAM_TIMES_IMPL(name, sample, min, max, bucket_count, \
+ docstring); \
+ QUIC_SERVER_HISTOGRAM_TIMES_IMPL(name, sample, min, max, bucket_count, \
+ docstring); \
+ } while (0)
+
+//------------------------------------------------------------------------------
+// Count histograms. These are used for collecting numeric data.
+
+// These macros default to exponential histograms - i.e. the lengths of the
+// bucket ranges exponentially increase as the sample range increases.
+
+// All of these macros must be called with |name| as a runtime constant.
+
+// Sample usage:
+// QUIC_HISTOGRAM_COUNTS("My.Histogram",
+// sample, // Number of something in this event.
+// 1000, // Record up to 1K of something.
+// "Number of something.");
+
+#define QUIC_HISTOGRAM_COUNTS(name, sample, min, max, bucket_count, docstring) \
+ do { \
+ QUIC_CLIENT_HISTOGRAM_COUNTS_IMPL(name, sample, min, max, bucket_count, \
+ docstring); \
+ QUIC_SERVER_HISTOGRAM_COUNTS_IMPL(name, sample, min, max, bucket_count, \
+ docstring); \
+ } while (0)
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_EXPORTED_STATS_H_
diff --git a/quic/platform/api/quic_fallthrough.h b/quic/platform/api/quic_fallthrough.h
new file mode 100644
index 0000000..499b61a
--- /dev/null
+++ b/quic/platform/api/quic_fallthrough.h
@@ -0,0 +1,12 @@
+// Copyright (c) 2018 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_QUIC_PLATFORM_API_QUIC_FALLTHROUGH_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_FALLTHROUGH_H_
+
+#include "net/quic/platform/impl/quic_fallthrough_impl.h"
+
+#define QUIC_FALLTHROUGH_INTENDED QUIC_FALLTHROUGH_INTENDED_IMPL
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_FALLTHROUGH_H_
diff --git a/quic/platform/api/quic_file_utils.cc b/quic/platform/api/quic_file_utils.cc
new file mode 100644
index 0000000..5492b83
--- /dev/null
+++ b/quic/platform/api/quic_file_utils.cc
@@ -0,0 +1,22 @@
+// Copyright (c) 2019 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 "net/third_party/quiche/src/quic/platform/api/quic_file_utils.h"
+
+#include "net/quic/platform/impl/quic_file_utils_impl.h"
+
+namespace quic {
+
+// Traverses the directory |dirname| and retuns all of the files
+// it contains.
+std::vector<QuicString> ReadFileContents(const QuicString& dirname) {
+ return ReadFileContentsImpl(dirname);
+}
+
+// Reads the contents of |filename| as a string into |contents|.
+void ReadFileContents(QuicStringPiece filename, QuicString* contents) {
+ ReadFileContentsImpl(filename, contents);
+}
+
+} // namespace quic
diff --git a/quic/platform/api/quic_file_utils.h b/quic/platform/api/quic_file_utils.h
new file mode 100644
index 0000000..0f270ef
--- /dev/null
+++ b/quic/platform/api/quic_file_utils.h
@@ -0,0 +1,27 @@
+// Copyright (c) 2018 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_QUIC_PLATFORM_API_QUIC_FILE_UTILS_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_FILE_UTILS_H_
+
+#include <vector>
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_string.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+
+namespace quic {
+
+// Traverses the directory |dirname| and retuns all of the files
+// it contains.
+QUIC_EXPORT_PRIVATE std::vector<QuicString> ReadFileContents(
+ const QuicString& dirname);
+
+// Reads the contents of |filename| as a string into |contents|.
+QUIC_EXPORT_PRIVATE void ReadFileContents(QuicStringPiece filename,
+ QuicString* contents);
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_FILE_UTILS_H_
diff --git a/quic/platform/api/quic_flag_utils.h b/quic/platform/api/quic_flag_utils.h
new file mode 100644
index 0000000..bec9b39
--- /dev/null
+++ b/quic/platform/api/quic_flag_utils.h
@@ -0,0 +1,19 @@
+// Copyright (c) 2017 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_QUIC_PLATFORM_API_QUIC_FLAG_UTILS_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_FLAG_UTILS_H_
+
+#include "net/quic/platform/impl/quic_flag_utils_impl.h"
+
+#define QUIC_RELOADABLE_FLAG_COUNT QUIC_RELOADABLE_FLAG_COUNT_IMPL
+#define QUIC_RELOADABLE_FLAG_COUNT_N QUIC_RELOADABLE_FLAG_COUNT_N_IMPL
+
+#define QUIC_RESTART_FLAG_COUNT QUIC_RESTART_FLAG_COUNT_IMPL
+#define QUIC_RESTART_FLAG_COUNT_N QUIC_RESTART_FLAG_COUNT_N_IMPL
+
+#define QUIC_CODE_COUNT QUIC_CODE_COUNT_IMPL
+#define QUIC_CODE_COUNT_N QUIC_CODE_COUNT_N_IMPL
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_FLAG_UTILS_H_
diff --git a/quic/platform/api/quic_flags.h b/quic/platform/api/quic_flags.h
new file mode 100644
index 0000000..45145a7
--- /dev/null
+++ b/quic/platform/api/quic_flags.h
@@ -0,0 +1,48 @@
+// Copyright (c) 2017 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_QUIC_PLATFORM_API_QUIC_FLAGS_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_FLAGS_H_
+
+#include <vector>
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_string.h"
+#include "net/quic/platform/impl/quic_flags_impl.h"
+
+// Define a command-line flag that can be automatically set via
+// QuicParseCommandLineFlags().
+#define DEFINE_QUIC_COMMAND_LINE_FLAG(type, name, default_value, help) \
+ DEFINE_QUIC_COMMAND_LINE_FLAG_IMPL(type, name, default_value, help)
+
+#define GetQuicReloadableFlag(flag) GetQuicReloadableFlagImpl(flag)
+#define SetQuicReloadableFlag(flag, value) \
+ SetQuicReloadableFlagImpl(flag, value)
+#define GetQuicRestartFlag(flag) GetQuicRestartFlagImpl(flag)
+#define SetQuicRestartFlag(flag, value) SetQuicRestartFlagImpl(flag, value)
+#define GetQuicFlag(flag) GetQuicFlagImpl(flag)
+#define SetQuicFlag(flag, value) SetQuicFlagImpl(flag, value)
+
+namespace quic {
+
+// Parses command-line flags, setting flag variables defined using
+// DEFINE_QUIC_COMMAND_LINE_FLAG if they appear in the command line, and
+// returning a list of any non-flag arguments specified in the command line. If
+// the command line specifies '-h' or '--help', prints a usage message with flag
+// descriptions to stdout and exits with status 0. If a flag has an unparsable
+// value, writes an error message to stderr and exits with status 1.
+inline std::vector<QuicString> QuicParseCommandLineFlags(
+ const char* usage,
+ int argc,
+ const char* const* argv) {
+ return QuicParseCommandLineFlagsImpl(usage, argc, argv);
+}
+
+// Prints a usage message with flag descriptions to stdout.
+inline void QuicPrintCommandLineFlagHelp(const char* usage) {
+ QuicPrintCommandLineFlagHelpImpl(usage);
+}
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_FLAGS_H_
diff --git a/quic/platform/api/quic_fuzzed_data_provider.h b/quic/platform/api/quic_fuzzed_data_provider.h
new file mode 100644
index 0000000..ef565e2
--- /dev/null
+++ b/quic/platform/api/quic_fuzzed_data_provider.h
@@ -0,0 +1,16 @@
+// Copyright 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_QUIC_PLATFORM_API_QUIC_FUZZED_DATA_PROVIDER_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_FUZZED_DATA_PROVIDER_H_
+
+#include "net/quic/platform/impl/quic_fuzzed_data_provider_impl.h"
+
+namespace quic {
+
+using QuicFuzzedDataProvider = QuicFuzzedDataProviderImpl;
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_FUZZED_DATA_PROVIDER_H_
diff --git a/quic/platform/api/quic_hostname_utils.cc b/quic/platform/api/quic_hostname_utils.cc
new file mode 100644
index 0000000..d02529f
--- /dev/null
+++ b/quic/platform/api/quic_hostname_utils.cc
@@ -0,0 +1,19 @@
+// Copyright (c) 2017 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 "net/third_party/quiche/src/quic/platform/api/quic_hostname_utils.h"
+
+namespace quic {
+
+// static
+bool QuicHostnameUtils::IsValidSNI(QuicStringPiece sni) {
+ return QuicHostnameUtilsImpl::IsValidSNI(sni);
+}
+
+// static
+QuicString QuicHostnameUtils::NormalizeHostname(QuicStringPiece hostname) {
+ return QuicHostnameUtilsImpl::NormalizeHostname(hostname);
+}
+
+} // namespace quic
diff --git a/quic/platform/api/quic_hostname_utils.h b/quic/platform/api/quic_hostname_utils.h
new file mode 100644
index 0000000..7f2b98a
--- /dev/null
+++ b/quic/platform/api/quic_hostname_utils.h
@@ -0,0 +1,33 @@
+// Copyright (c) 2017 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_QUIC_PLATFORM_API_QUIC_HOSTNAME_UTILS_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_HOSTNAME_UTILS_H_
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_string.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+#include "net/quic/platform/impl/quic_hostname_utils_impl.h"
+
+namespace quic {
+
+class QUIC_EXPORT_PRIVATE QuicHostnameUtils {
+ public:
+ QuicHostnameUtils() = delete;
+
+ // Returns true if the sni is valid, false otherwise.
+ // (1) disallow IP addresses;
+ // (2) check that the hostname contains valid characters only; and
+ // (3) contains at least one dot.
+ static bool IsValidSNI(QuicStringPiece sni);
+
+ // Canonicalizes the specified hostname. This involves a wide variety of
+ // transformations, including lowercasing, removing trailing dots and IDNA
+ // conversion.
+ static QuicString NormalizeHostname(QuicStringPiece hostname);
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_HOSTNAME_UTILS_H_
diff --git a/quic/platform/api/quic_hostname_utils_test.cc b/quic/platform/api/quic_hostname_utils_test.cc
new file mode 100644
index 0000000..8523384
--- /dev/null
+++ b/quic/platform/api/quic_hostname_utils_test.cc
@@ -0,0 +1,88 @@
+// Copyright (c) 2017 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 "net/third_party/quiche/src/quic/platform/api/quic_hostname_utils.h"
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_string.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
+
+namespace quic {
+namespace test {
+namespace {
+
+class QuicHostnameUtilsTest : public QuicTest {};
+
+TEST_F(QuicHostnameUtilsTest, IsValidSNI) {
+ // IP as SNI.
+ EXPECT_FALSE(QuicHostnameUtils::IsValidSNI("192.168.0.1"));
+ // SNI without any dot.
+ EXPECT_FALSE(QuicHostnameUtils::IsValidSNI("somedomain"));
+ // Invalid by RFC2396 but unfortunately domains of this form exist.
+ EXPECT_TRUE(QuicHostnameUtils::IsValidSNI("some_domain.com"));
+ // An empty string must be invalid otherwise the QUIC client will try sending
+ // it.
+ EXPECT_FALSE(QuicHostnameUtils::IsValidSNI(""));
+
+ // Valid SNI
+ EXPECT_TRUE(QuicHostnameUtils::IsValidSNI("test.google.com"));
+}
+
+TEST_F(QuicHostnameUtilsTest, NormalizeHostname) {
+ // clang-format off
+ struct {
+ const char *input, *expected;
+ } tests[] = {
+ {
+ "www.google.com",
+ "www.google.com",
+ },
+ {
+ "WWW.GOOGLE.COM",
+ "www.google.com",
+ },
+ {
+ "www.google.com.",
+ "www.google.com",
+ },
+ {
+ "www.google.COM.",
+ "www.google.com",
+ },
+ {
+ "www.google.com..",
+ "www.google.com",
+ },
+ {
+ "www.google.com........",
+ "www.google.com",
+ },
+ {
+ "",
+ "",
+ },
+ {
+ ".",
+ "",
+ },
+ {
+ "........",
+ "",
+ },
+ {
+ "\xe5\x85\x89.google.com",
+ "xn--54q.google.com",
+ },
+ };
+ // clang-format on
+
+ for (size_t i = 0; i < QUIC_ARRAYSIZE(tests); ++i) {
+ EXPECT_EQ(QuicString(tests[i].expected),
+ QuicHostnameUtils::NormalizeHostname(tests[i].input));
+ }
+}
+
+} // namespace
+} // namespace test
+} // namespace quic
diff --git a/quic/platform/api/quic_iovec.h b/quic/platform/api/quic_iovec.h
new file mode 100644
index 0000000..97202cd
--- /dev/null
+++ b/quic/platform/api/quic_iovec.h
@@ -0,0 +1,27 @@
+// Copyright (c) 2018 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_QUIC_PLATFORM_API_QUIC_IOVEC_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_IOVEC_H_
+
+#include <cstddef>
+#include <type_traits>
+
+#include "net/quic/platform/impl/quic_iovec_impl.h"
+
+namespace quic {
+
+// The impl header has to export struct iovec, or a POSIX-compatible polyfill.
+// Below, we mostly assert that what we have is appropriate.
+static_assert(std::is_standard_layout<struct iovec>::value,
+ "iovec has to be a standard-layout struct");
+
+static_assert(offsetof(struct iovec, iov_base) < sizeof(struct iovec),
+ "iovec has to have iov_base");
+static_assert(offsetof(struct iovec, iov_len) < sizeof(struct iovec),
+ "iovec has to have iov_len");
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_IOVEC_H_
diff --git a/quic/platform/api/quic_ip_address.cc b/quic/platform/api/quic_ip_address.cc
new file mode 100644
index 0000000..bf184dd
--- /dev/null
+++ b/quic/platform/api/quic_ip_address.cc
@@ -0,0 +1,85 @@
+// 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.
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_ip_address.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_string.h"
+
+namespace quic {
+
+QuicIpAddress QuicIpAddress::Loopback4() {
+ return QuicIpAddress(QuicIpAddressImpl::Loopback4());
+}
+
+QuicIpAddress QuicIpAddress::Loopback6() {
+ return QuicIpAddress(QuicIpAddressImpl::Loopback6());
+}
+
+QuicIpAddress QuicIpAddress::Any4() {
+ return QuicIpAddress(QuicIpAddressImpl::Any4());
+}
+
+QuicIpAddress QuicIpAddress::Any6() {
+ return QuicIpAddress(QuicIpAddressImpl::Any6());
+}
+
+QuicIpAddress::QuicIpAddress(const QuicIpAddressImpl& impl) : impl_(impl) {}
+
+bool operator==(QuicIpAddress lhs, QuicIpAddress rhs) {
+ return lhs.impl_ == rhs.impl_;
+}
+
+bool operator!=(QuicIpAddress lhs, QuicIpAddress rhs) {
+ return !(lhs == rhs);
+}
+
+bool QuicIpAddress::IsInitialized() const {
+ return impl_.IsInitialized();
+}
+
+IpAddressFamily QuicIpAddress::address_family() const {
+ return impl_.address_family();
+}
+
+int QuicIpAddress::AddressFamilyToInt() const {
+ return impl_.AddressFamilyToInt();
+}
+
+QuicString QuicIpAddress::ToPackedString() const {
+ return impl_.ToPackedString();
+}
+
+QuicString QuicIpAddress::ToString() const {
+ return impl_.ToString();
+}
+
+QuicIpAddress QuicIpAddress::Normalized() const {
+ return QuicIpAddress(impl_.Normalized());
+}
+
+QuicIpAddress QuicIpAddress::DualStacked() const {
+ return QuicIpAddress(impl_.DualStacked());
+}
+
+bool QuicIpAddress::FromPackedString(const char* data, size_t length) {
+ return impl_.FromPackedString(data, length);
+}
+
+bool QuicIpAddress::FromString(QuicString str) {
+ return impl_.FromString(str);
+}
+
+bool QuicIpAddress::IsIPv4() const {
+ return impl_.IsIPv4();
+}
+
+bool QuicIpAddress::IsIPv6() const {
+ return impl_.IsIPv6();
+}
+
+bool QuicIpAddress::InSameSubnet(const QuicIpAddress& other,
+ int subnet_length) {
+ return impl_.InSameSubnet(other.impl(), subnet_length);
+}
+
+} // namespace quic
diff --git a/quic/platform/api/quic_ip_address.h b/quic/platform/api/quic_ip_address.h
new file mode 100644
index 0000000..a8951df
--- /dev/null
+++ b/quic/platform/api/quic_ip_address.h
@@ -0,0 +1,72 @@
+// 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_QUIC_PLATFORM_API_QUIC_IP_ADDRESS_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_IP_ADDRESS_H_
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_string.h"
+#include "net/quic/platform/impl/quic_ip_address_impl.h"
+
+namespace quic {
+
+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:
+ enum : size_t {
+ kIPv4AddressSize = QuicIpAddressImpl::kIPv4AddressSize,
+ kIPv6AddressSize = QuicIpAddressImpl::kIPv6AddressSize
+ };
+
+ // TODO(fayang): Remove Loopback*() and use TestLoopback*() in tests.
+ static QuicIpAddress Loopback4();
+ static QuicIpAddress Loopback6();
+ static QuicIpAddress Any4();
+ static QuicIpAddress Any6();
+
+ QuicIpAddress() = default;
+ QuicIpAddress(const QuicIpAddress& other) = default;
+ explicit QuicIpAddress(const QuicIpAddressImpl& impl);
+ 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.
+ QuicString ToPackedString() const;
+ // Returns string representation of the address.
+ QuicString 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(QuicString str);
+ bool IsIPv4() const;
+ bool IsIPv6() const;
+ bool InSameSubnet(const QuicIpAddress& other, int subnet_length);
+
+ const QuicIpAddressImpl& impl() const { return impl_; }
+
+ private:
+ QuicIpAddressImpl impl_;
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_IP_ADDRESS_H_
diff --git a/quic/platform/api/quic_ip_address_family.h b/quic/platform/api/quic_ip_address_family.h
new file mode 100644
index 0000000..dad2cb9
--- /dev/null
+++ b/quic/platform/api/quic_ip_address_family.h
@@ -0,0 +1,20 @@
+// 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_QUIC_PLATFORM_API_QUIC_IP_ADDRESS_FAMILY_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_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,
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_IP_ADDRESS_FAMILY_H_
diff --git a/quic/platform/api/quic_logging.h b/quic/platform/api/quic_logging.h
new file mode 100644
index 0000000..ba48dc1
--- /dev/null
+++ b/quic/platform/api/quic_logging.h
@@ -0,0 +1,39 @@
+// Copyright (c) 2017 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_QUIC_PLATFORM_API_QUIC_LOGGING_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_LOGGING_H_
+
+#include "net/quic/platform/impl/quic_logging_impl.h"
+
+// Please note following QUIC_LOG are platform dependent:
+// INFO severity can be degraded (to VLOG(1) or DVLOG(1)).
+// Some platforms may not support QUIC_LOG_FIRST_N or QUIC_LOG_EVERY_N_SEC, and
+// they would simply be translated to LOG.
+
+#define QUIC_DVLOG(verbose_level) QUIC_DVLOG_IMPL(verbose_level)
+#define QUIC_DVLOG_IF(verbose_level, condition) \
+ QUIC_DVLOG_IF_IMPL(verbose_level, condition)
+#define QUIC_DLOG(severity) QUIC_DLOG_IMPL(severity)
+#define QUIC_DLOG_IF(severity, condition) QUIC_DLOG_IF_IMPL(severity, condition)
+#define QUIC_VLOG(verbose_level) QUIC_VLOG_IMPL(verbose_level)
+#define QUIC_LOG(severity) QUIC_LOG_IMPL(severity)
+#define QUIC_LOG_FIRST_N(severity, n) QUIC_LOG_FIRST_N_IMPL(severity, n)
+#define QUIC_LOG_EVERY_N_SEC(severity, seconds) \
+ QUIC_LOG_EVERY_N_SEC_IMPL(severity, seconds)
+#define QUIC_LOG_IF(severity, condition) QUIC_LOG_IF_IMPL(severity, condition)
+
+#define QUIC_PREDICT_FALSE(x) QUIC_PREDICT_FALSE_IMPL(x)
+
+// This is a noop in release build.
+#define QUIC_NOTREACHED() QUIC_NOTREACHED_IMPL()
+
+#define QUIC_PLOG(severity) QUIC_PLOG_IMPL(severity)
+
+#define QUIC_DLOG_INFO_IS_ON() QUIC_DLOG_INFO_IS_ON_IMPL()
+#define QUIC_LOG_INFO_IS_ON() QUIC_LOG_INFO_IS_ON_IMPL()
+#define QUIC_LOG_WARNING_IS_ON() QUIC_LOG_WARNING_IS_ON_IMPL()
+#define QUIC_LOG_ERROR_IS_ON() QUIC_LOG_ERROR_IS_ON_IMPL()
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_LOGGING_H_
diff --git a/quic/platform/api/quic_macros.h b/quic/platform/api/quic_macros.h
new file mode 100644
index 0000000..9dee2e9
--- /dev/null
+++ b/quic/platform/api/quic_macros.h
@@ -0,0 +1,13 @@
+// Copyright (c) 2019 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_QUIC_PLATFORM_API_QUIC_MACROS_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_MACROS_H_
+
+#include "net/quic/platform/impl/quic_macros_impl.h"
+
+#define QUIC_MUST_USE_RESULT QUIC_MUST_USE_RESULT_IMPL
+#define QUIC_UNUSED QUIC_UNUSED_IMPL
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_MACROS_H_
diff --git a/quic/platform/api/quic_map_util.h b/quic/platform/api/quic_map_util.h
new file mode 100644
index 0000000..95daec8
--- /dev/null
+++ b/quic/platform/api/quic_map_util.h
@@ -0,0 +1,24 @@
+// Copyright (c) 2017 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_QUIC_PLATFORM_API_QUIC_MAP_UTIL_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_MAP_UTIL_H_
+
+#include "net/quic/platform/impl/quic_map_util_impl.h"
+
+namespace quic {
+
+template <class Collection, class Key>
+bool QuicContainsKey(const Collection& collection, const Key& key) {
+ return QuicContainsKeyImpl(collection, key);
+}
+
+template <typename Collection, typename Value>
+bool QuicContainsValue(const Collection& collection, const Value& value) {
+ return QuicContainsValueImpl(collection, value);
+}
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_MAP_UTIL_H_
diff --git a/quic/platform/api/quic_mem_slice.h b/quic/platform/api/quic_mem_slice.h
new file mode 100644
index 0000000..a4318ad
--- /dev/null
+++ b/quic/platform/api/quic_mem_slice.h
@@ -0,0 +1,62 @@
+// Copyright 2017 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_QUIC_PLATFORM_API_QUIC_MEM_SLICE_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_MEM_SLICE_H_
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
+#include "net/quic/platform/impl/quic_mem_slice_impl.h"
+
+namespace quic {
+
+// QuicMemSlice is an internally reference counted data buffer used as the
+// source buffers for write operations. QuicMemSlice implicitly maintains a
+// reference count and will free the underlying data buffer when the reference
+// count reaches zero.
+class QUIC_EXPORT_PRIVATE QuicMemSlice {
+ public:
+ // Constructs a empty QuicMemSlice with no underlying data and 0 reference
+ // count.
+ QuicMemSlice() = default;
+ // Let |allocator| allocate a data buffer of |length|, then construct
+ // QuicMemSlice with reference count 1 from the allocated data buffer.
+ // Once all of the references to the allocated data buffer are released,
+ // |allocator| is responsible to free the memory. |allocator| must
+ // not be null, and |length| must not be 0. To construct an empty
+ // QuicMemSlice, use the zero-argument constructor instead.
+ QuicMemSlice(QuicBufferAllocator* allocator, size_t length)
+ : impl_(allocator, length) {}
+
+ // Constructs QuicMemSlice from |impl|. It takes the reference away from
+ // |impl|.
+ explicit QuicMemSlice(QuicMemSliceImpl impl) : impl_(std::move(impl)) {}
+
+ QuicMemSlice(const QuicMemSlice& other) = delete;
+ QuicMemSlice& operator=(const QuicMemSlice& other) = delete;
+
+ // Move constructors. |other| will not hold a reference to the data buffer
+ // after this call completes.
+ QuicMemSlice(QuicMemSlice&& other) = default;
+ QuicMemSlice& operator=(QuicMemSlice&& other) = default;
+
+ ~QuicMemSlice() = default;
+
+ // Release the underlying reference. Further access the memory will result in
+ // undefined behavior.
+ void Reset() { impl_.Reset(); }
+
+ // Returns a const char pointer to underlying data buffer.
+ const char* data() const { return impl_.data(); }
+ // Returns the length of underlying data buffer.
+ size_t length() const { return impl_.length(); }
+
+ bool empty() const { return impl_.empty(); }
+
+ private:
+ QuicMemSliceImpl impl_;
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_MEM_SLICE_H_
diff --git a/quic/platform/api/quic_mem_slice_span.h b/quic/platform/api/quic_mem_slice_span.h
new file mode 100644
index 0000000..781382e
--- /dev/null
+++ b/quic/platform/api/quic_mem_slice_span.h
@@ -0,0 +1,61 @@
+// Copyright 2017 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_QUIC_PLATFORM_API_QUIC_MEM_SLICE_SPAN_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_MEM_SLICE_SPAN_H_
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
+#include "net/quic/platform/impl/quic_mem_slice_span_impl.h"
+
+namespace quic {
+
+// QuicMemSliceSpan is effectively wrapper around an array of data structures
+// used as QuicMemSlice. So it could implemented with:
+// QuicMemSlice* slices_;
+// size_t num_slices_;
+// But for efficiency reasons, the actual implementation is an array of
+// platform-specific objects. This could avoid the translation from
+// platform-specific object to QuicMemSlice.
+// QuicMemSliceSpan does not own the underling data buffers.
+class QUIC_EXPORT_PRIVATE QuicMemSliceSpan {
+ public:
+ explicit QuicMemSliceSpan(QuicMemSliceSpanImpl impl) : impl_(impl) {}
+
+ QuicMemSliceSpan(const QuicMemSliceSpan& other) = default;
+ QuicMemSliceSpan& operator=(const QuicMemSliceSpan& other) = default;
+ QuicMemSliceSpan(QuicMemSliceSpan&& other) = default;
+ QuicMemSliceSpan& operator=(QuicMemSliceSpan&& other) = default;
+
+ ~QuicMemSliceSpan() = default;
+
+ // Save data buffers to |send_buffer| and returns the amount of saved data.
+ // |send_buffer| will hold a reference to all data buffer.
+ QuicByteCount SaveMemSlicesInSendBuffer(QuicStreamSendBuffer* send_buffer) {
+ return impl_.SaveMemSlicesInSendBuffer(send_buffer);
+ }
+
+ // Save data buffers as message data in |message_frame|. |message_frame| will
+ // hold a reference to all data buffers.
+ void SaveMemSlicesAsMessageData(QuicMessageFrame* message_frame) {
+ impl_.SaveMemSlicesAsMessageData(message_frame);
+ }
+
+ // Return data of the span at |index| by the form of a QuicStringPiece.
+ QuicStringPiece GetData(int index) { return impl_.GetData(index); }
+
+ // Return the total length of the data inside the span.
+ QuicByteCount total_length() { return impl_.total_length(); }
+
+ // Return total number of slices in the span.
+ size_t NumSlices() { return impl_.NumSlices(); }
+
+ bool empty() const { return impl_.empty(); }
+
+ private:
+ QuicMemSliceSpanImpl impl_;
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_MEM_SLICE_SPAN_H_
diff --git a/quic/platform/api/quic_mem_slice_span_test.cc b/quic/platform/api/quic_mem_slice_span_test.cc
new file mode 100644
index 0000000..b4c5e51
--- /dev/null
+++ b/quic/platform/api/quic_mem_slice_span_test.cc
@@ -0,0 +1,50 @@
+// Copyright 2017 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 "net/third_party/quiche/src/quic/platform/api/quic_mem_slice_span.h"
+
+#include "net/third_party/quiche/src/quic/core/quic_simple_buffer_allocator.h"
+#include "net/third_party/quiche/src/quic/core/quic_stream_send_buffer.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_test_mem_slice_vector.h"
+
+namespace quic {
+namespace test {
+namespace {
+
+class QuicMemSliceSpanImplTest : public QuicTest {
+ public:
+ QuicMemSliceSpanImplTest() {
+ for (size_t i = 0; i < 10; ++i) {
+ buffers_.push_back(std::make_pair(data_, 1024));
+ }
+ }
+
+ char data_[1024];
+ std::vector<std::pair<char*, size_t>> buffers_;
+};
+
+TEST_F(QuicMemSliceSpanImplTest, SaveDataInSendBuffer) {
+ SimpleBufferAllocator allocator;
+ QuicStreamSendBuffer send_buffer(&allocator);
+ QuicTestMemSliceVector vector(buffers_);
+
+ EXPECT_EQ(10 * 1024u, vector.span().SaveMemSlicesInSendBuffer(&send_buffer));
+ EXPECT_EQ(10u, send_buffer.size());
+}
+
+TEST_F(QuicMemSliceSpanImplTest, SaveEmptyMemSliceInSendBuffer) {
+ SimpleBufferAllocator allocator;
+ QuicStreamSendBuffer send_buffer(&allocator);
+ buffers_.push_back(std::make_pair(nullptr, 0));
+ QuicTestMemSliceVector vector(buffers_);
+ EXPECT_EQ(10 * 1024u, vector.span().SaveMemSlicesInSendBuffer(&send_buffer));
+ // Verify the empty slice does not get saved.
+ EXPECT_EQ(10u, send_buffer.size());
+}
+
+} // namespace
+} // namespace test
+} // namespace quic
diff --git a/quic/platform/api/quic_mem_slice_storage.h b/quic/platform/api/quic_mem_slice_storage.h
new file mode 100644
index 0000000..dc48a43
--- /dev/null
+++ b/quic/platform/api/quic_mem_slice_storage.h
@@ -0,0 +1,39 @@
+// Copyright 2017 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_QUIC_PLATFORM_API_QUIC_MEM_SLICE_STORAGE_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_MEM_SLICE_STORAGE_H_
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
+#include "net/quic/platform/impl/quic_mem_slice_storage_impl.h"
+
+namespace quic {
+
+// QuicMemSliceStorage is a container class that store QuicMemSlices for further
+// use cases such as turning into QuicMemSliceSpan.
+class QUIC_EXPORT_PRIVATE QuicMemSliceStorage {
+ public:
+ QuicMemSliceStorage(const struct iovec* iov,
+ int iov_count,
+ QuicBufferAllocator* allocator,
+ const QuicByteCount max_slice_len)
+ : impl_(iov, iov_count, allocator, max_slice_len) {}
+
+ QuicMemSliceStorage(const QuicMemSliceStorage& other) = default;
+ QuicMemSliceStorage& operator=(const QuicMemSliceStorage& other) = default;
+ QuicMemSliceStorage(QuicMemSliceStorage&& other) = default;
+ QuicMemSliceStorage& operator=(QuicMemSliceStorage&& other) = default;
+
+ ~QuicMemSliceStorage() = default;
+
+ // Return a QuicMemSliceSpan form of the storage.
+ QuicMemSliceSpan ToSpan() { return impl_.ToSpan(); }
+
+ private:
+ QuicMemSliceStorageImpl impl_;
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_MEM_SLICE_STORAGE_H_
diff --git a/quic/platform/api/quic_mem_slice_storage_test.cc b/quic/platform/api/quic_mem_slice_storage_test.cc
new file mode 100644
index 0000000..72623e1
--- /dev/null
+++ b/quic/platform/api/quic_mem_slice_storage_test.cc
@@ -0,0 +1,60 @@
+// Copyright 2017 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 "net/third_party/quiche/src/quic/platform/api/quic_mem_slice_storage.h"
+#include "net/third_party/quiche/src/quic/core/quic_simple_buffer_allocator.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
+
+namespace quic {
+namespace test {
+namespace {
+
+class QuicMemSliceStorageImplTest : public QuicTest {
+ public:
+ QuicMemSliceStorageImplTest() = default;
+};
+
+TEST_F(QuicMemSliceStorageImplTest, EmptyIov) {
+ QuicMemSliceStorage storage(nullptr, 0, nullptr, 1024);
+ EXPECT_TRUE(storage.ToSpan().empty());
+}
+
+TEST_F(QuicMemSliceStorageImplTest, SingleIov) {
+ SimpleBufferAllocator allocator;
+ QuicString body(3, 'c');
+ struct iovec iov = {const_cast<char*>(body.data()), body.length()};
+ QuicMemSliceStorage storage(&iov, 1, &allocator, 1024);
+ auto span = storage.ToSpan();
+ EXPECT_EQ("ccc", span.GetData(0));
+ EXPECT_NE(static_cast<const void*>(span.GetData(0).data()), body.data());
+}
+
+TEST_F(QuicMemSliceStorageImplTest, MultipleIovInSingleSlice) {
+ SimpleBufferAllocator allocator;
+ QuicString body1(3, 'a');
+ QuicString body2(4, 'b');
+ struct iovec iov[] = {{const_cast<char*>(body1.data()), body1.length()},
+ {const_cast<char*>(body2.data()), body2.length()}};
+
+ QuicMemSliceStorage storage(iov, 2, &allocator, 1024);
+ auto span = storage.ToSpan();
+ EXPECT_EQ("aaabbbb", span.GetData(0));
+}
+
+TEST_F(QuicMemSliceStorageImplTest, MultipleIovInMultipleSlice) {
+ SimpleBufferAllocator allocator;
+ QuicString body1(4, 'a');
+ QuicString body2(4, 'b');
+ struct iovec iov[] = {{const_cast<char*>(body1.data()), body1.length()},
+ {const_cast<char*>(body2.data()), body2.length()}};
+
+ QuicMemSliceStorage storage(iov, 2, &allocator, 4);
+ auto span = storage.ToSpan();
+ EXPECT_EQ("aaaa", span.GetData(0));
+ EXPECT_EQ("bbbb", span.GetData(1));
+}
+
+} // namespace
+} // namespace test
+} // namespace quic
diff --git a/quic/platform/api/quic_mem_slice_test.cc b/quic/platform/api/quic_mem_slice_test.cc
new file mode 100644
index 0000000..185f536
--- /dev/null
+++ b/quic/platform/api/quic_mem_slice_test.cc
@@ -0,0 +1,50 @@
+// Copyright 2017 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 "net/third_party/quiche/src/quic/platform/api/quic_mem_slice.h"
+
+#include "net/third_party/quiche/src/quic/core/quic_simple_buffer_allocator.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
+
+namespace quic {
+namespace test {
+namespace {
+
+class QuicMemSliceTest : public QuicTest {
+ public:
+ QuicMemSliceTest() {
+ size_t length = 1024;
+ slice_ = QuicMemSlice(&allocator_, length);
+ orig_data_ = slice_.data();
+ orig_length_ = slice_.length();
+ }
+
+ SimpleBufferAllocator allocator_;
+ QuicMemSlice slice_;
+ const char* orig_data_;
+ size_t orig_length_;
+};
+
+TEST_F(QuicMemSliceTest, MoveConstruct) {
+ QuicMemSlice moved(std::move(slice_));
+ EXPECT_EQ(moved.data(), orig_data_);
+ EXPECT_EQ(moved.length(), orig_length_);
+ EXPECT_EQ(nullptr, slice_.data());
+ EXPECT_EQ(0u, slice_.length());
+ EXPECT_TRUE(slice_.empty());
+}
+
+TEST_F(QuicMemSliceTest, MoveAssign) {
+ QuicMemSlice moved;
+ moved = std::move(slice_);
+ EXPECT_EQ(moved.data(), orig_data_);
+ EXPECT_EQ(moved.length(), orig_length_);
+ EXPECT_EQ(nullptr, slice_.data());
+ EXPECT_EQ(0u, slice_.length());
+ EXPECT_TRUE(slice_.empty());
+}
+
+} // namespace
+} // namespace test
+} // namespace quic
diff --git a/quic/platform/api/quic_mock_log.h b/quic/platform/api/quic_mock_log.h
new file mode 100644
index 0000000..d1c2693
--- /dev/null
+++ b/quic/platform/api/quic_mock_log.h
@@ -0,0 +1,18 @@
+// Copyright (c) 2017 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_QUIC_PLATFORM_API_QUIC_MOCK_LOG_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_MOCK_LOG_H_
+
+#include "net/quic/platform/impl/quic_mock_log_impl.h"
+
+using QuicMockLog = QuicMockLogImpl;
+#define CREATE_QUIC_MOCK_LOG(log) CREATE_QUIC_MOCK_LOG_IMPL(log)
+
+#define EXPECT_QUIC_LOG_CALL(log) EXPECT_QUIC_LOG_CALL_IMPL(log)
+
+#define EXPECT_QUIC_LOG_CALL_CONTAINS(log, level, content) \
+ EXPECT_QUIC_LOG_CALL_CONTAINS_IMPL(log, level, content)
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_MOCK_LOG_H_
diff --git a/quic/platform/api/quic_mutex.cc b/quic/platform/api/quic_mutex.cc
new file mode 100644
index 0000000..fc0c9b5
--- /dev/null
+++ b/quic/platform/api/quic_mutex.cc
@@ -0,0 +1,45 @@
+// 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.
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_mutex.h"
+
+namespace quic {
+
+void QuicMutex::WriterLock() {
+ impl_.WriterLock();
+}
+
+void QuicMutex::WriterUnlock() {
+ impl_.WriterUnlock();
+}
+
+void QuicMutex::ReaderLock() {
+ impl_.ReaderLock();
+}
+
+void QuicMutex::ReaderUnlock() {
+ impl_.ReaderUnlock();
+}
+
+void QuicMutex::AssertReaderHeld() const {
+ impl_.AssertReaderHeld();
+}
+
+QuicReaderMutexLock::QuicReaderMutexLock(QuicMutex* lock) : lock_(lock) {
+ lock->ReaderLock();
+}
+
+QuicReaderMutexLock::~QuicReaderMutexLock() {
+ lock_->ReaderUnlock();
+}
+
+QuicWriterMutexLock::QuicWriterMutexLock(QuicMutex* lock) : lock_(lock) {
+ lock->WriterLock();
+}
+
+QuicWriterMutexLock::~QuicWriterMutexLock() {
+ lock_->WriterUnlock();
+}
+
+} // namespace quic
diff --git a/quic/platform/api/quic_mutex.h b/quic/platform/api/quic_mutex.h
new file mode 100644
index 0000000..162863a
--- /dev/null
+++ b/quic/platform/api/quic_mutex.h
@@ -0,0 +1,88 @@
+// 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_QUIC_PLATFORM_API_QUIC_MUTEX_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_MUTEX_H_
+
+#include "net/quic/platform/impl/quic_mutex_impl.h"
+
+namespace quic {
+
+// A class representing a non-reentrant mutex in QUIC.
+class LOCKABLE QUIC_EXPORT_PRIVATE QuicMutex {
+ public:
+ QuicMutex() = default;
+ QuicMutex(const QuicMutex&) = delete;
+ QuicMutex& operator=(const QuicMutex&) = delete;
+
+ // Block until this Mutex is free, then acquire it exclusively.
+ void WriterLock() EXCLUSIVE_LOCK_FUNCTION();
+
+ // Release this Mutex. Caller must hold it exclusively.
+ void WriterUnlock() UNLOCK_FUNCTION();
+
+ // Block until this Mutex is free or shared, then acquire a share of it.
+ void ReaderLock() SHARED_LOCK_FUNCTION();
+
+ // Release this Mutex. Caller could hold it in shared mode.
+ void ReaderUnlock() UNLOCK_FUNCTION();
+
+ // Returns immediately if current thread holds the Mutex in at least shared
+ // mode. Otherwise, may report an error (typically by crashing with a
+ // diagnostic), or may return immediately.
+ void AssertReaderHeld() const ASSERT_SHARED_LOCK();
+
+ private:
+ QuicLockImpl impl_;
+};
+
+// A helper class that acquires the given QuicMutex shared lock while the
+// QuicReaderMutexLock is in scope.
+class SCOPED_LOCKABLE QUIC_EXPORT_PRIVATE QuicReaderMutexLock {
+ public:
+ explicit QuicReaderMutexLock(QuicMutex* lock) SHARED_LOCK_FUNCTION(lock);
+ QuicReaderMutexLock(const QuicReaderMutexLock&) = delete;
+ QuicReaderMutexLock& operator=(const QuicReaderMutexLock&) = delete;
+
+ ~QuicReaderMutexLock() UNLOCK_FUNCTION();
+
+ private:
+ QuicMutex* const lock_;
+};
+
+// A helper class that acquires the given QuicMutex exclusive lock while the
+// QuicWriterMutexLock is in scope.
+class SCOPED_LOCKABLE QUIC_EXPORT_PRIVATE QuicWriterMutexLock {
+ public:
+ explicit QuicWriterMutexLock(QuicMutex* lock) EXCLUSIVE_LOCK_FUNCTION(lock);
+ QuicWriterMutexLock(const QuicWriterMutexLock&) = delete;
+ QuicWriterMutexLock& operator=(const QuicWriterMutexLock&) = delete;
+
+ ~QuicWriterMutexLock() UNLOCK_FUNCTION();
+
+ private:
+ QuicMutex* const lock_;
+};
+
+// A Notification allows threads to receive notification of a single occurrence
+// of a single event.
+class QUIC_EXPORT_PRIVATE QuicNotification {
+ public:
+ QuicNotification() = default;
+ QuicNotification(const QuicNotification&) = delete;
+ QuicNotification& operator=(const QuicNotification&) = delete;
+
+ bool HasBeenNotified() { return impl_.HasBeenNotified(); }
+
+ void Notify() { impl_.Notify(); }
+
+ void WaitForNotification() { impl_.WaitForNotification(); }
+
+ private:
+ QuicNotificationImpl impl_;
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_MUTEX_H_
diff --git a/quic/platform/api/quic_pcc_sender.h b/quic/platform/api/quic_pcc_sender.h
new file mode 100644
index 0000000..201a3d1
--- /dev/null
+++ b/quic/platform/api/quic_pcc_sender.h
@@ -0,0 +1,28 @@
+// 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.
+
+#ifndef QUICHE_QUIC_PLATFORM_API_QUIC_PCC_SENDER_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_PCC_SENDER_H_
+
+#include "net/third_party/quiche/src/quic/core/congestion_control/send_algorithm_interface.h"
+#include "net/quic/platform/impl/quic_pcc_sender_impl.h"
+
+namespace quic {
+
+// Interface for creating a PCC SendAlgorithmInterface
+SendAlgorithmInterface* CreatePccSender(
+ const QuicClock* clock,
+ const RttStats* rtt_stats,
+ const QuicUnackedPacketMap* unacked_packets,
+ QuicRandom* random,
+ QuicConnectionStats* stats,
+ QuicPacketCount initial_congestion_window,
+ QuicPacketCount max_congestion_window) {
+ return CreatePccSenderImpl(clock, rtt_stats, unacked_packets, random, stats,
+ initial_congestion_window, max_congestion_window);
+}
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_PCC_SENDER_H_
diff --git a/quic/platform/api/quic_port_utils.h b/quic/platform/api/quic_port_utils.h
new file mode 100644
index 0000000..aa85fc5
--- /dev/null
+++ b/quic/platform/api/quic_port_utils.h
@@ -0,0 +1,26 @@
+// Copyright (c) 2019 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_QUIC_PLATFORM_API_QUIC_PORT_UTILS_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_PORT_UTILS_H_
+
+#include "net/quic/platform/impl/quic_port_utils_impl.h"
+
+namespace quic {
+
+// Returns a UDP port that is currently unused. Check-fails if none are
+// available.
+inline int QuicPickUnusedPortOrDie() {
+ return QuicPickUnusedPortOrDieImpl();
+}
+
+// Indicates that a specified port previously returned by
+// QuicPickUnusedPortOrDie is no longer used.
+inline void QuicRecyclePort(int port) {
+ return QuicRecyclePortImpl(port);
+}
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_PORT_UTILS_H_
diff --git a/quic/platform/api/quic_prefetch.h b/quic/platform/api/quic_prefetch.h
new file mode 100644
index 0000000..49dbe48
--- /dev/null
+++ b/quic/platform/api/quic_prefetch.h
@@ -0,0 +1,39 @@
+// Copyright 2017 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_QUIC_PLATFORM_API_QUIC_PREFETCH_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_PREFETCH_H_
+
+#include "net/quic/platform/impl/quic_prefetch_impl.h"
+
+namespace quic {
+
+// Move data into the cache before it is read, or "prefetch" it.
+//
+// The value of `addr` is the address of the memory to prefetch. If
+// the target and compiler support it, data prefetch instructions are
+// generated. If the prefetch is done some time before the memory is
+// read, it may be in the cache by the time the read occurs.
+//
+// The function names specify the temporal locality heuristic applied,
+// using the names of Intel prefetch instructions:
+//
+// T0 - high degree of temporal locality; data should be left in as
+// many levels of the cache possible
+// T1 - moderate degree of temporal locality
+// T2 - low degree of temporal locality
+// Nta - no temporal locality, data need not be left in the cache
+// after the read
+//
+// Incorrect or gratuitous use of these functions can degrade
+// performance, so use them only when representative benchmarks show
+// an improvement.
+
+inline void QuicPrefetchT0(const void* addr) {
+ return QuicPrefetchT0Impl(addr);
+}
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_PREFETCH_H_
diff --git a/quic/platform/api/quic_ptr_util.h b/quic/platform/api/quic_ptr_util.h
new file mode 100644
index 0000000..d0ed460
--- /dev/null
+++ b/quic/platform/api/quic_ptr_util.h
@@ -0,0 +1,27 @@
+// Copyright (c) 2017 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_QUIC_PLATFORM_API_QUIC_PTR_UTIL_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_PTR_UTIL_H_
+
+#include <memory>
+#include <utility>
+
+#include "net/quic/platform/impl/quic_ptr_util_impl.h"
+
+namespace quic {
+
+template <typename T, typename... Args>
+std::unique_ptr<T> QuicMakeUnique(Args&&... args) {
+ return QuicMakeUniqueImpl<T>(std::forward<Args>(args)...);
+}
+
+template <typename T>
+std::unique_ptr<T> QuicWrapUnique(T* ptr) {
+ return QuicWrapUniqueImpl<T>(ptr);
+}
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_PTR_UTIL_H_
diff --git a/quic/platform/api/quic_reference_counted.h b/quic/platform/api/quic_reference_counted.h
new file mode 100644
index 0000000..6cb4378
--- /dev/null
+++ b/quic/platform/api/quic_reference_counted.h
@@ -0,0 +1,161 @@
+// 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_QUIC_PLATFORM_API_QUIC_REFERENCE_COUNTED_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_REFERENCE_COUNTED_H_
+
+#include "net/quic/platform/impl/quic_reference_counted_impl.h"
+
+namespace quic {
+
+// Base class for explicitly reference-counted objects in QUIC.
+class QUIC_EXPORT_PRIVATE QuicReferenceCounted
+ : public QuicReferenceCountedImpl {
+ public:
+ QuicReferenceCounted() {}
+
+ protected:
+ ~QuicReferenceCounted() override {}
+};
+
+// A class representing a reference counted pointer in QUIC.
+//
+// Construct or initialize QuicReferenceCountedPointer from raw pointer. Here
+// raw pointer MUST be a newly created object. Reference count of a newly
+// created object is undefined, but that will be 1 after being added to
+// QuicReferenceCountedPointer.
+// QuicReferenceCountedPointer is used as a local variable.
+// QuicReferenceCountedPointer<T> r_ptr(new T());
+// or, equivalently:
+// QuicReferenceCountedPointer<T> r_ptr;
+// T* p = new T();
+// r_ptr = T;
+//
+// QuicReferenceCountedPointer is used as a member variable:
+// MyClass::MyClass() : r_ptr(new T()) {}
+//
+// This is WRONG, since *p is not guaranteed to be newly created:
+// MyClass::MyClass(T* p) : r_ptr(p) {}
+//
+// Given an existing QuicReferenceCountedPointer, create a duplicate that has
+// its own reference on the object:
+// QuicReferenceCountedPointer<T> r_ptr_b(r_ptr_a);
+// or, equivalently:
+// QuicReferenceCountedPointer<T> r_ptr_b = r_ptr_a;
+//
+// Given an existing QuicReferenceCountedPointer, create a
+// QuicReferenceCountedPointer that adopts the reference:
+// QuicReferenceCountedPointer<T> r_ptr_b(std::move(r_ptr_a));
+// or, equivalently:
+// QuicReferenceCountedPointer<T> r_ptr_b = std::move(r_ptr_a);
+
+template <class T>
+class QuicReferenceCountedPointer {
+ public:
+ QuicReferenceCountedPointer() = default;
+
+ // Constructor from raw pointer |p|. This guarantees the reference count of *p
+ // is 1. This should only be used when a new object is created, calling this
+ // on an already existent object is undefined behavior.
+ explicit QuicReferenceCountedPointer(T* p) : impl_(p) {}
+
+ // Allows implicit conversion from nullptr.
+ QuicReferenceCountedPointer(std::nullptr_t) : impl_(nullptr) {} // NOLINT
+
+ // Copy and copy conversion constructors. It does not take the reference away
+ // from |other| and they each end up with their own reference.
+ template <typename U>
+ QuicReferenceCountedPointer( // NOLINT
+ const QuicReferenceCountedPointer<U>& other)
+ : impl_(other.impl()) {}
+ QuicReferenceCountedPointer(const QuicReferenceCountedPointer& other)
+ : impl_(other.impl()) {}
+
+ // Move constructors. After move, It adopts the reference from |other|.
+ template <typename U>
+ QuicReferenceCountedPointer(QuicReferenceCountedPointer<U>&& other) // NOLINT
+ : impl_(std::move(other.impl())) {}
+ QuicReferenceCountedPointer(QuicReferenceCountedPointer&& other)
+ : impl_(std::move(other.impl())) {}
+
+ ~QuicReferenceCountedPointer() = default;
+
+ // Copy assignments.
+ QuicReferenceCountedPointer& operator=(
+ const QuicReferenceCountedPointer& other) {
+ impl_ = other.impl();
+ return *this;
+ }
+ template <typename U>
+ QuicReferenceCountedPointer<T>& operator=(
+ const QuicReferenceCountedPointer<U>& other) {
+ impl_ = other.impl();
+ return *this;
+ }
+
+ // Move assignments.
+ QuicReferenceCountedPointer& operator=(QuicReferenceCountedPointer&& other) {
+ impl_ = std::move(other.impl());
+ return *this;
+ }
+ template <typename U>
+ QuicReferenceCountedPointer<T>& operator=(
+ QuicReferenceCountedPointer<U>&& other) {
+ impl_ = std::move(other.impl());
+ return *this;
+ }
+
+ // Accessors for the referenced object.
+ // operator* and operator-> will assert() if there is no current object.
+ T& operator*() const { return *impl_; }
+ T* operator->() const { return impl_.get(); }
+
+ explicit operator bool() const { return static_cast<bool>(impl_); }
+
+ // Assignment operator on raw pointer. Drops a reference to current pointee,
+ // if any, and replaces it with |p|. This guarantees the reference count of *p
+ // is 1. This should only be used when a new object is created, calling this
+ // on a already existent object is undefined behavior.
+ QuicReferenceCountedPointer<T>& operator=(T* p) {
+ impl_ = p;
+ return *this;
+ }
+
+ // Returns the raw pointer with no change in reference.
+ T* get() const { return impl_.get(); }
+
+ QuicReferenceCountedPointerImpl<T>& impl() { return impl_; }
+ const QuicReferenceCountedPointerImpl<T>& impl() const { return impl_; }
+
+ // Comparisons against same type.
+ friend bool operator==(const QuicReferenceCountedPointer& a,
+ const QuicReferenceCountedPointer& b) {
+ return a.get() == b.get();
+ }
+ friend bool operator!=(const QuicReferenceCountedPointer& a,
+ const QuicReferenceCountedPointer& b) {
+ return a.get() != b.get();
+ }
+
+ // Comparisons against nullptr.
+ friend bool operator==(const QuicReferenceCountedPointer& a, std::nullptr_t) {
+ return a.get() == nullptr;
+ }
+ friend bool operator==(std::nullptr_t, const QuicReferenceCountedPointer& b) {
+ return nullptr == b.get();
+ }
+ friend bool operator!=(const QuicReferenceCountedPointer& a, std::nullptr_t) {
+ return a.get() != nullptr;
+ }
+ friend bool operator!=(std::nullptr_t, const QuicReferenceCountedPointer& b) {
+ return nullptr != b.get();
+ }
+
+ private:
+ QuicReferenceCountedPointerImpl<T> impl_;
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_REFERENCE_COUNTED_H_
diff --git a/quic/platform/api/quic_reference_counted_test.cc b/quic/platform/api/quic_reference_counted_test.cc
new file mode 100644
index 0000000..a1932ed
--- /dev/null
+++ b/quic/platform/api/quic_reference_counted_test.cc
@@ -0,0 +1,173 @@
+// 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.
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_reference_counted.h"
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
+
+namespace quic {
+namespace test {
+namespace {
+
+class Base : public QuicReferenceCounted {
+ public:
+ explicit Base(bool* destroyed) : destroyed_(destroyed) {
+ *destroyed_ = false;
+ }
+
+ protected:
+ ~Base() override { *destroyed_ = true; }
+
+ private:
+ bool* destroyed_;
+};
+
+class Derived : public Base {
+ public:
+ explicit Derived(bool* destroyed) : Base(destroyed) {}
+
+ private:
+ ~Derived() override {}
+};
+
+class QuicReferenceCountedTest : public QuicTest {};
+
+TEST_F(QuicReferenceCountedTest, DefaultConstructor) {
+ QuicReferenceCountedPointer<Base> a;
+ EXPECT_EQ(nullptr, a);
+ EXPECT_EQ(nullptr, a.get());
+ EXPECT_FALSE(a);
+}
+
+TEST_F(QuicReferenceCountedTest, ConstructFromRawPointer) {
+ bool destroyed = false;
+ {
+ QuicReferenceCountedPointer<Base> a(new Base(&destroyed));
+ EXPECT_FALSE(destroyed);
+ }
+ EXPECT_TRUE(destroyed);
+}
+
+TEST_F(QuicReferenceCountedTest, RawPointerAssignment) {
+ bool destroyed = false;
+ {
+ QuicReferenceCountedPointer<Base> a;
+ Base* rct = new Base(&destroyed);
+ a = rct;
+ EXPECT_FALSE(destroyed);
+ }
+ EXPECT_TRUE(destroyed);
+}
+
+TEST_F(QuicReferenceCountedTest, PointerCopy) {
+ bool destroyed = false;
+ {
+ QuicReferenceCountedPointer<Base> a(new Base(&destroyed));
+ {
+ QuicReferenceCountedPointer<Base> b(a);
+ EXPECT_EQ(a, b);
+ EXPECT_FALSE(destroyed);
+ }
+ EXPECT_FALSE(destroyed);
+ }
+ EXPECT_TRUE(destroyed);
+}
+
+TEST_F(QuicReferenceCountedTest, PointerCopyAssignment) {
+ bool destroyed = false;
+ {
+ QuicReferenceCountedPointer<Base> a(new Base(&destroyed));
+ {
+ QuicReferenceCountedPointer<Base> b = a;
+ EXPECT_EQ(a, b);
+ EXPECT_FALSE(destroyed);
+ }
+ EXPECT_FALSE(destroyed);
+ }
+ EXPECT_TRUE(destroyed);
+}
+
+TEST_F(QuicReferenceCountedTest, PointerCopyFromOtherType) {
+ bool destroyed = false;
+ {
+ QuicReferenceCountedPointer<Derived> a(new Derived(&destroyed));
+ {
+ QuicReferenceCountedPointer<Base> b(a);
+ EXPECT_EQ(a.get(), b.get());
+ EXPECT_FALSE(destroyed);
+ }
+ EXPECT_FALSE(destroyed);
+ }
+ EXPECT_TRUE(destroyed);
+}
+
+TEST_F(QuicReferenceCountedTest, PointerCopyAssignmentFromOtherType) {
+ bool destroyed = false;
+ {
+ QuicReferenceCountedPointer<Derived> a(new Derived(&destroyed));
+ {
+ QuicReferenceCountedPointer<Base> b = a;
+ EXPECT_EQ(a.get(), b.get());
+ EXPECT_FALSE(destroyed);
+ }
+ EXPECT_FALSE(destroyed);
+ }
+ EXPECT_TRUE(destroyed);
+}
+
+TEST_F(QuicReferenceCountedTest, PointerMove) {
+ bool destroyed = false;
+ QuicReferenceCountedPointer<Base> a(new Derived(&destroyed));
+ EXPECT_FALSE(destroyed);
+ QuicReferenceCountedPointer<Base> b(std::move(a));
+ EXPECT_FALSE(destroyed);
+ EXPECT_NE(nullptr, b);
+ EXPECT_EQ(nullptr, a); // NOLINT
+
+ b = nullptr;
+ EXPECT_TRUE(destroyed);
+}
+
+TEST_F(QuicReferenceCountedTest, PointerMoveAssignment) {
+ bool destroyed = false;
+ QuicReferenceCountedPointer<Base> a(new Derived(&destroyed));
+ EXPECT_FALSE(destroyed);
+ QuicReferenceCountedPointer<Base> b = std::move(a);
+ EXPECT_FALSE(destroyed);
+ EXPECT_NE(nullptr, b);
+ EXPECT_EQ(nullptr, a); // NOLINT
+
+ b = nullptr;
+ EXPECT_TRUE(destroyed);
+}
+
+TEST_F(QuicReferenceCountedTest, PointerMoveFromOtherType) {
+ bool destroyed = false;
+ QuicReferenceCountedPointer<Derived> a(new Derived(&destroyed));
+ EXPECT_FALSE(destroyed);
+ QuicReferenceCountedPointer<Base> b(std::move(a));
+ EXPECT_FALSE(destroyed);
+ EXPECT_NE(nullptr, b);
+ EXPECT_EQ(nullptr, a); // NOLINT
+
+ b = nullptr;
+ EXPECT_TRUE(destroyed);
+}
+
+TEST_F(QuicReferenceCountedTest, PointerMoveAssignmentFromOtherType) {
+ bool destroyed = false;
+ QuicReferenceCountedPointer<Derived> a(new Derived(&destroyed));
+ EXPECT_FALSE(destroyed);
+ QuicReferenceCountedPointer<Base> b = std::move(a);
+ EXPECT_FALSE(destroyed);
+ EXPECT_NE(nullptr, b);
+ EXPECT_EQ(nullptr, a); // NOLINT
+
+ b = nullptr;
+ EXPECT_TRUE(destroyed);
+}
+
+} // namespace
+} // namespace test
+} // namespace quic
diff --git a/quic/platform/api/quic_server_stats.h b/quic/platform/api/quic_server_stats.h
new file mode 100644
index 0000000..3c4223e
--- /dev/null
+++ b/quic/platform/api/quic_server_stats.h
@@ -0,0 +1,82 @@
+// Copyright 2018 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_QUIC_PLATFORM_API_QUIC_SERVER_STATS_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_SERVER_STATS_H_
+
+#include "net/quic/platform/impl/quic_server_stats_impl.h"
+
+namespace quic {
+
+//------------------------------------------------------------------------------
+// Enumeration histograms.
+//
+// Sample usage:
+// // In Chrome, these values are persisted to logs. Entries should not be
+// // renumbered and numeric values should never be reused.
+// enum class MyEnum {
+// FIRST_VALUE = 0,
+// SECOND_VALUE = 1,
+// ...
+// FINAL_VALUE = N,
+// COUNT
+// };
+// QUIC_SERVER_HISTOGRAM_ENUM("My.Enumeration", MyEnum::SOME_VALUE,
+// MyEnum::COUNT, "Number of time $foo equals to some enum value");
+//
+// Note: The value in |sample| must be strictly less than |enum_size|.
+
+#define QUIC_SERVER_HISTOGRAM_ENUM(name, sample, enum_size, docstring) \
+ QUIC_SERVER_HISTOGRAM_ENUM_IMPL(name, sample, enum_size, docstring)
+
+//------------------------------------------------------------------------------
+// Histogram for boolean values.
+
+// Sample usage:
+// QUIC_SERVER_HISTOGRAM_BOOL("My.Boolean", bool,
+// "Number of times $foo is true or false");
+#define QUIC_SERVER_HISTOGRAM_BOOL(name, sample, docstring) \
+ QUIC_SERVER_HISTOGRAM_BOOL_IMPL(name, sample, docstring)
+
+//------------------------------------------------------------------------------
+// Timing histograms. These are used for collecting timing data (generally
+// latencies).
+
+// These macros create exponentially sized histograms (lengths of the bucket
+// ranges exponentially increase as the sample range increases). The units for
+// sample and max are unspecified, but they must be the same for one histogram.
+
+// Sample usage:
+// QUIC_SERVER_HISTOGRAM_TIMES("Very.Long.Timing.Histogram", time_delta,
+// QuicTime::Delta::FromSeconds(1), QuicTime::Delta::FromSecond(3600 *
+// 24), 100, "Time spent in doing operation.");
+#define QUIC_SERVER_HISTOGRAM_TIMES(name, sample, min, max, bucket_count, \
+ docstring) \
+ QUIC_SERVER_HISTOGRAM_TIMES_IMPL(name, sample, min, max, bucket_count, \
+ docstring)
+
+//------------------------------------------------------------------------------
+// Count histograms. These are used for collecting numeric data.
+
+// These macros default to exponential histograms - i.e. the lengths of the
+// bucket ranges exponentially increase as the sample range increases.
+
+// All of these macros must be called with |name| as a runtime constant.
+
+// Any data outside the range here will be put in underflow and overflow
+// buckets. Min values should be >=1 as emitted 0s will still go into the
+// underflow bucket.
+
+// Sample usage:
+// QUIC_SERVER_SERVER_HISTOGRAM_CUSTOM_COUNTS("My.Histogram", 1, 100000000,
+// 100, "Counters of hitting certian code.");
+
+#define QUIC_SERVER_HISTOGRAM_COUNTS(name, sample, min, max, bucket_count, \
+ docstring) \
+ QUIC_SERVER_HISTOGRAM_COUNTS_IMPL(name, sample, min, max, bucket_count, \
+ docstring)
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_SERVER_STATS_H_
diff --git a/quic/platform/api/quic_sleep.h b/quic/platform/api/quic_sleep.h
new file mode 100644
index 0000000..12c20df
--- /dev/null
+++ b/quic/platform/api/quic_sleep.h
@@ -0,0 +1,19 @@
+// Copyright 2018 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_QUIC_PLATFORM_API_QUIC_SLEEP_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_SLEEP_H_
+
+#include "net/third_party/quiche/src/quic/core/quic_time.h"
+#include "net/quic/platform/impl/quic_sleep_impl.h"
+
+namespace quic {
+
+inline void QuicSleep(QuicTime::Delta duration) {
+ QuicSleepImpl(duration);
+}
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_SLEEP_H_
diff --git a/quic/platform/api/quic_socket_address.cc b/quic/platform/api/quic_socket_address.cc
new file mode 100644
index 0000000..fd428e5
--- /dev/null
+++ b/quic/platform/api/quic_socket_address.cc
@@ -0,0 +1,58 @@
+// 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.
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_string.h"
+
+namespace quic {
+
+QuicSocketAddress::QuicSocketAddress(QuicIpAddress address, uint16_t port)
+ : impl_(address.impl(), port) {}
+
+QuicSocketAddress::QuicSocketAddress(const struct sockaddr_storage& saddr)
+ : impl_(saddr) {}
+
+QuicSocketAddress::QuicSocketAddress(const struct sockaddr& saddr)
+ : impl_(saddr) {}
+
+QuicSocketAddress::QuicSocketAddress(const QuicSocketAddressImpl& impl)
+ : impl_(impl) {}
+
+bool operator==(const QuicSocketAddress& lhs, const QuicSocketAddress& rhs) {
+ return lhs.impl_ == rhs.impl_;
+}
+
+bool operator!=(const QuicSocketAddress& lhs, const QuicSocketAddress& rhs) {
+ return lhs.impl_ != rhs.impl_;
+}
+
+bool QuicSocketAddress::IsInitialized() const {
+ return impl_.IsInitialized();
+}
+
+QuicString QuicSocketAddress::ToString() const {
+ return impl_.ToString();
+}
+
+int QuicSocketAddress::FromSocket(int fd) {
+ return impl_.FromSocket(fd);
+}
+
+QuicSocketAddress QuicSocketAddress::Normalized() const {
+ return QuicSocketAddress(impl_.Normalized());
+}
+
+QuicIpAddress QuicSocketAddress::host() const {
+ return QuicIpAddress(impl_.host());
+}
+
+uint16_t QuicSocketAddress::port() const {
+ return impl_.port();
+}
+
+sockaddr_storage QuicSocketAddress::generic_address() const {
+ return impl_.generic_address();
+}
+
+} // namespace quic
diff --git a/quic/platform/api/quic_socket_address.h b/quic/platform/api/quic_socket_address.h
new file mode 100644
index 0000000..297387f
--- /dev/null
+++ b/quic/platform/api/quic_socket_address.h
@@ -0,0 +1,49 @@
+// 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_QUIC_PLATFORM_API_QUIC_SOCKET_ADDRESS_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_SOCKET_ADDRESS_H_
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_ip_address.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_string.h"
+#include "net/quic/platform/impl/quic_socket_address_impl.h"
+
+namespace quic {
+
+class QUIC_EXPORT_PRIVATE QuicSocketAddress {
+ // A class representing a socket endpoint address (i.e., IP address plus a
+ // port) in QUIC. The actual implementation (platform dependent) of a socket
+ // address is in QuicSocketAddressImpl.
+ public:
+ QuicSocketAddress() = default;
+ QuicSocketAddress(QuicIpAddress address, uint16_t port);
+ explicit QuicSocketAddress(const struct sockaddr_storage& saddr);
+ explicit QuicSocketAddress(const struct sockaddr& saddr);
+ explicit QuicSocketAddress(const QuicSocketAddressImpl& impl);
+ QuicSocketAddress(const QuicSocketAddress& other) = default;
+ QuicSocketAddress& operator=(const QuicSocketAddress& other) = default;
+ QuicSocketAddress& operator=(QuicSocketAddress&& other) = default;
+ QUIC_EXPORT_PRIVATE friend bool operator==(const QuicSocketAddress& lhs,
+ const QuicSocketAddress& rhs);
+ QUIC_EXPORT_PRIVATE friend bool operator!=(const QuicSocketAddress& lhs,
+ const QuicSocketAddress& rhs);
+
+ bool IsInitialized() const;
+ QuicString ToString() const;
+ int FromSocket(int fd);
+ QuicSocketAddress Normalized() const;
+
+ QuicIpAddress host() const;
+ uint16_t port() const;
+ sockaddr_storage generic_address() const;
+ const QuicSocketAddressImpl& impl() const { return impl_; }
+
+ private:
+ QuicSocketAddressImpl impl_;
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_SOCKET_ADDRESS_H_
diff --git a/quic/platform/api/quic_stack_trace.h b/quic/platform/api/quic_stack_trace.h
new file mode 100644
index 0000000..1a1a10c
--- /dev/null
+++ b/quic/platform/api/quic_stack_trace.h
@@ -0,0 +1,19 @@
+// Copyright (c) 2017 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_QUIC_PLATFORM_API_QUIC_STACK_TRACE_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_STACK_TRACE_H_
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_string.h"
+#include "net/quic/platform/impl/quic_stack_trace_impl.h"
+
+namespace quic {
+
+inline QuicString QuicStackTrace() {
+ return QuicStackTraceImpl();
+}
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_STACK_TRACE_H_
diff --git a/quic/platform/api/quic_str_cat.h b/quic/platform/api/quic_str_cat.h
new file mode 100644
index 0000000..1720cfd
--- /dev/null
+++ b/quic/platform/api/quic_str_cat.h
@@ -0,0 +1,28 @@
+// 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_QUIC_PLATFORM_API_QUIC_STR_CAT_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_STR_CAT_H_
+
+#include <utility>
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_string.h"
+#include "net/quic/platform/impl/quic_str_cat_impl.h"
+
+namespace quic {
+
+// Merges given strings or numbers with no delimiter.
+template <typename... Args>
+inline QuicString QuicStrCat(const Args&... args) {
+ return QuicStrCatImpl(std::forward<const Args&>(args)...);
+}
+
+template <typename... Args>
+inline QuicString QuicStringPrintf(const Args&... args) {
+ return QuicStringPrintfImpl(std::forward<const Args&>(args)...);
+}
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_STR_CAT_H_
diff --git a/quic/platform/api/quic_str_cat_test.cc b/quic/platform/api/quic_str_cat_test.cc
new file mode 100644
index 0000000..c8f1724
--- /dev/null
+++ b/quic/platform/api/quic_str_cat_test.cc
@@ -0,0 +1,167 @@
+// 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.
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_string.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
+
+namespace quic {
+namespace test {
+namespace {
+
+class QuicStrCatTest : public QuicTest {};
+
+TEST_F(QuicStrCatTest, Ints) {
+ const int16_t s = -1;
+ const uint16_t us = 2;
+ const int i = -3;
+ const uint32_t ui = 4;
+ const int64_t l = -5;
+ const uint64_t ul = 6;
+ const ptrdiff_t ptrdiff = -7;
+ const size_t size = 8;
+ const intptr_t intptr = -9;
+ const uintptr_t uintptr = 10;
+ QuicString answer;
+ answer = QuicStrCat(s, us);
+ EXPECT_EQ(answer, "-12");
+ answer = QuicStrCat(i, ui);
+ EXPECT_EQ(answer, "-34");
+ answer = QuicStrCat(l, ul);
+ EXPECT_EQ(answer, "-56");
+ answer = QuicStrCat(ptrdiff, size);
+ EXPECT_EQ(answer, "-78");
+ answer = QuicStrCat(size, intptr);
+ EXPECT_EQ(answer, "8-9");
+ answer = QuicStrCat(uintptr, 0);
+ EXPECT_EQ(answer, "100");
+}
+
+TEST_F(QuicStrCatTest, Basics) {
+ QuicString result;
+
+ QuicString strs[] = {"Hello", "Cruel", "World"};
+
+ QuicStringPiece pieces[] = {"Hello", "Cruel", "World"};
+
+ const char* c_strs[] = {"Hello", "Cruel", "World"};
+
+ int32_t i32s[] = {'H', 'C', 'W'};
+ uint64_t ui64s[] = {12345678910LL, 10987654321LL};
+
+ result = QuicStrCat(false, true, 2, 3);
+ EXPECT_EQ(result, "0123");
+
+ result = QuicStrCat(-1);
+ EXPECT_EQ(result, "-1");
+
+ result = QuicStrCat(0.5);
+ EXPECT_EQ(result, "0.5");
+
+ result = QuicStrCat(strs[1], pieces[2]);
+ EXPECT_EQ(result, "CruelWorld");
+
+ result = QuicStrCat(strs[0], ", ", pieces[2]);
+ EXPECT_EQ(result, "Hello, World");
+
+ result = QuicStrCat(strs[0], ", ", strs[1], " ", strs[2], "!");
+ EXPECT_EQ(result, "Hello, Cruel World!");
+
+ result = QuicStrCat(pieces[0], ", ", pieces[1], " ", pieces[2]);
+ EXPECT_EQ(result, "Hello, Cruel World");
+
+ result = QuicStrCat(c_strs[0], ", ", c_strs[1], " ", c_strs[2]);
+ EXPECT_EQ(result, "Hello, Cruel World");
+
+ result = QuicStrCat("ASCII ", i32s[0], ", ", i32s[1], " ", i32s[2], "!");
+ EXPECT_EQ(result, "ASCII 72, 67 87!");
+
+ result = QuicStrCat(ui64s[0], ", ", ui64s[1], "!");
+ EXPECT_EQ(result, "12345678910, 10987654321!");
+
+ QuicString one = "1";
+ result = QuicStrCat("And a ", one.size(), " and a ", &result[2] - &result[0],
+ " and a ", one, " 2 3 4", "!");
+ EXPECT_EQ(result, "And a 1 and a 2 and a 1 2 3 4!");
+
+ result =
+ QuicStrCat("To output a char by ASCII/numeric value, use +: ", '!' + 0);
+ EXPECT_EQ(result, "To output a char by ASCII/numeric value, use +: 33");
+
+ float f = 10000.5;
+ result = QuicStrCat("Ten K and a half is ", f);
+ EXPECT_EQ(result, "Ten K and a half is 10000.5");
+
+ double d = 99999.9;
+ result = QuicStrCat("This double number is ", d);
+ EXPECT_EQ(result, "This double number is 99999.9");
+
+ result =
+ QuicStrCat(1, 22, 333, 4444, 55555, 666666, 7777777, 88888888, 999999999);
+ EXPECT_EQ(result, "122333444455555666666777777788888888999999999");
+}
+
+TEST_F(QuicStrCatTest, MaxArgs) {
+ QuicString result;
+ // Test 10 up to 26 arguments, the current maximum
+ result = QuicStrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a");
+ EXPECT_EQ(result, "123456789a");
+ result = QuicStrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b");
+ EXPECT_EQ(result, "123456789ab");
+ result = QuicStrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c");
+ EXPECT_EQ(result, "123456789abc");
+ result = QuicStrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d");
+ EXPECT_EQ(result, "123456789abcd");
+ result = QuicStrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e");
+ EXPECT_EQ(result, "123456789abcde");
+ result = QuicStrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f");
+ EXPECT_EQ(result, "123456789abcdef");
+ result =
+ QuicStrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f", "g");
+ EXPECT_EQ(result, "123456789abcdefg");
+ result = QuicStrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f",
+ "g", "h");
+ EXPECT_EQ(result, "123456789abcdefgh");
+ result = QuicStrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f",
+ "g", "h", "i");
+ EXPECT_EQ(result, "123456789abcdefghi");
+ result = QuicStrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f",
+ "g", "h", "i", "j");
+ EXPECT_EQ(result, "123456789abcdefghij");
+ result = QuicStrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f",
+ "g", "h", "i", "j", "k");
+ EXPECT_EQ(result, "123456789abcdefghijk");
+ result = QuicStrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f",
+ "g", "h", "i", "j", "k", "l");
+ EXPECT_EQ(result, "123456789abcdefghijkl");
+ result = QuicStrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f",
+ "g", "h", "i", "j", "k", "l", "m");
+ EXPECT_EQ(result, "123456789abcdefghijklm");
+ result = QuicStrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f",
+ "g", "h", "i", "j", "k", "l", "m", "n");
+ EXPECT_EQ(result, "123456789abcdefghijklmn");
+ result = QuicStrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f",
+ "g", "h", "i", "j", "k", "l", "m", "n", "o");
+ EXPECT_EQ(result, "123456789abcdefghijklmno");
+ result = QuicStrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f",
+ "g", "h", "i", "j", "k", "l", "m", "n", "o", "p");
+ EXPECT_EQ(result, "123456789abcdefghijklmnop");
+ result = QuicStrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f",
+ "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q");
+ EXPECT_EQ(result, "123456789abcdefghijklmnopq");
+ // No limit thanks to C++11's variadic templates
+ result = QuicStrCat(
+ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, "a", "b", "c", "d", "e", "f", "g", "h",
+ "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w",
+ "x", "y", "z", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L",
+ "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z");
+ EXPECT_EQ(result,
+ "12345678910abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
+}
+
+} // namespace
+} // namespace test
+} // namespace quic
diff --git a/quic/platform/api/quic_stream_buffer_allocator.h b/quic/platform/api/quic_stream_buffer_allocator.h
new file mode 100644
index 0000000..ea1cc9f
--- /dev/null
+++ b/quic/platform/api/quic_stream_buffer_allocator.h
@@ -0,0 +1,16 @@
+// Copyright (c) 2019 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_QUIC_PLATFORM_API_QUIC_STREAM_BUFFER_ALLOCATOR_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_STREAM_BUFFER_ALLOCATOR_H_
+
+#include "net/quic/platform/impl/quic_stream_buffer_allocator_impl.h"
+
+namespace quic {
+
+using QuicStreamBufferAllocator = QuicStreamBufferAllocatorImpl;
+
+}
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_STREAM_BUFFER_ALLOCATOR_H_
diff --git a/quic/platform/api/quic_string.h b/quic/platform/api/quic_string.h
new file mode 100644
index 0000000..e911fa7
--- /dev/null
+++ b/quic/platform/api/quic_string.h
@@ -0,0 +1,16 @@
+// Copyright 2017 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_QUIC_PLATFORM_API_QUIC_STRING_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_STRING_H_
+
+#include "net/quic/platform/impl/quic_string_impl.h"
+
+namespace quic {
+
+using QuicString = QuicStringImpl;
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_STRING_H_
diff --git a/quic/platform/api/quic_string_piece.h b/quic/platform/api/quic_string_piece.h
new file mode 100644
index 0000000..91cb183
--- /dev/null
+++ b/quic/platform/api/quic_string_piece.h
@@ -0,0 +1,16 @@
+// Copyright (c) 2017 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_QUIC_PLATFORM_API_QUIC_STRING_PIECE_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_STRING_PIECE_H_
+
+#include "net/quic/platform/impl/quic_string_piece_impl.h"
+
+namespace quic {
+
+using QuicStringPiece = QuicStringPieceImpl;
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_STRING_PIECE_H_
diff --git a/quic/platform/api/quic_string_utils.h b/quic/platform/api/quic_string_utils.h
new file mode 100644
index 0000000..ce54d61
--- /dev/null
+++ b/quic/platform/api/quic_string_utils.h
@@ -0,0 +1,23 @@
+// Copyright 2017 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_QUIC_PLATFORM_API_QUIC_STRING_UTILS_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_STRING_UTILS_H_
+
+#include <utility>
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_string.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+#include "net/quic/platform/impl/quic_string_utils_impl.h"
+
+namespace quic {
+
+template <typename... Args>
+inline void QuicStrAppend(QuicString* output, const Args&... args) {
+ QuicStrAppendImpl(output, std::forward<const Args&>(args)...);
+}
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_STRING_UTILS_H_
diff --git a/quic/platform/api/quic_string_utils_test.cc b/quic/platform/api/quic_string_utils_test.cc
new file mode 100644
index 0000000..0d3567c
--- /dev/null
+++ b/quic/platform/api/quic_string_utils_test.cc
@@ -0,0 +1,178 @@
+// Copyright 2017 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 "net/third_party/quiche/src/quic/platform/api/quic_string_utils.h"
+
+#include <cstdint>
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+
+namespace quic {
+namespace test {
+namespace {
+
+TEST(QuicStringUtilsTest, QuicStrCat) {
+ // No arguments.
+ EXPECT_EQ("", QuicStrCat());
+
+ // Single string-like argument.
+ const char kFoo[] = "foo";
+ const QuicString string_foo(kFoo);
+ const QuicStringPiece stringpiece_foo(string_foo);
+ EXPECT_EQ("foo", QuicStrCat(kFoo));
+ EXPECT_EQ("foo", QuicStrCat(string_foo));
+ EXPECT_EQ("foo", QuicStrCat(stringpiece_foo));
+
+ // Two string-like arguments.
+ const char kBar[] = "bar";
+ const QuicStringPiece stringpiece_bar(kBar);
+ const QuicString string_bar(kBar);
+ EXPECT_EQ("foobar", QuicStrCat(kFoo, kBar));
+ EXPECT_EQ("foobar", QuicStrCat(kFoo, string_bar));
+ EXPECT_EQ("foobar", QuicStrCat(kFoo, stringpiece_bar));
+ EXPECT_EQ("foobar", QuicStrCat(string_foo, kBar));
+ EXPECT_EQ("foobar", QuicStrCat(string_foo, string_bar));
+ EXPECT_EQ("foobar", QuicStrCat(string_foo, stringpiece_bar));
+ EXPECT_EQ("foobar", QuicStrCat(stringpiece_foo, kBar));
+ EXPECT_EQ("foobar", QuicStrCat(stringpiece_foo, string_bar));
+ EXPECT_EQ("foobar", QuicStrCat(stringpiece_foo, stringpiece_bar));
+
+ // Many-many arguments.
+ EXPECT_EQ(
+ "foobarbazquxquuxquuzcorgegraultgarplywaldofredplughxyzzythud",
+ QuicStrCat("foo", "bar", "baz", "qux", "quux", "quuz", "corge", "grault",
+ "garply", "waldo", "fred", "plugh", "xyzzy", "thud"));
+
+ // Numerical arguments.
+ const int16_t i = 1;
+ const uint64_t u = 8;
+ const double d = 3.1415;
+
+ EXPECT_EQ("1 8", QuicStrCat(i, " ", u));
+ EXPECT_EQ("3.14151181", QuicStrCat(d, i, i, u, i));
+ EXPECT_EQ("i: 1, u: 8, d: 3.1415",
+ QuicStrCat("i: ", i, ", u: ", u, ", d: ", d));
+
+ // Boolean arguments.
+ const bool t = true;
+ const bool f = false;
+
+ EXPECT_EQ("1", QuicStrCat(t));
+ EXPECT_EQ("0", QuicStrCat(f));
+ EXPECT_EQ("0110", QuicStrCat(f, t, t, f));
+
+ // Mixed string-like, numerical, and Boolean arguments.
+ EXPECT_EQ("foo1foo081bar3.14151",
+ QuicStrCat(kFoo, i, string_foo, f, u, t, stringpiece_bar, d, t));
+ EXPECT_EQ("3.141511bar18bar13.14150",
+ QuicStrCat(d, t, t, string_bar, i, u, kBar, t, d, f));
+}
+
+TEST(QuicStringUtilsTest, QuicStrAppend) {
+ // No arguments on empty string.
+ QuicString output;
+ QuicStrAppend(&output);
+ EXPECT_TRUE(output.empty());
+
+ // Single string-like argument.
+ const char kFoo[] = "foo";
+ const QuicString string_foo(kFoo);
+ const QuicStringPiece stringpiece_foo(string_foo);
+ QuicStrAppend(&output, kFoo);
+ EXPECT_EQ("foo", output);
+ QuicStrAppend(&output, string_foo);
+ EXPECT_EQ("foofoo", output);
+ QuicStrAppend(&output, stringpiece_foo);
+ EXPECT_EQ("foofoofoo", output);
+
+ // No arguments on non-empty string.
+ QuicStrAppend(&output);
+ EXPECT_EQ("foofoofoo", output);
+
+ output.clear();
+
+ // Two string-like arguments.
+ const char kBar[] = "bar";
+ const QuicStringPiece stringpiece_bar(kBar);
+ const QuicString string_bar(kBar);
+ QuicStrAppend(&output, kFoo, kBar);
+ EXPECT_EQ("foobar", output);
+ QuicStrAppend(&output, kFoo, string_bar);
+ EXPECT_EQ("foobarfoobar", output);
+ QuicStrAppend(&output, kFoo, stringpiece_bar);
+ EXPECT_EQ("foobarfoobarfoobar", output);
+ QuicStrAppend(&output, string_foo, kBar);
+ EXPECT_EQ("foobarfoobarfoobarfoobar", output);
+
+ output.clear();
+
+ QuicStrAppend(&output, string_foo, string_bar);
+ EXPECT_EQ("foobar", output);
+ QuicStrAppend(&output, string_foo, stringpiece_bar);
+ EXPECT_EQ("foobarfoobar", output);
+ QuicStrAppend(&output, stringpiece_foo, kBar);
+ EXPECT_EQ("foobarfoobarfoobar", output);
+ QuicStrAppend(&output, stringpiece_foo, string_bar);
+ EXPECT_EQ("foobarfoobarfoobarfoobar", output);
+
+ output.clear();
+
+ QuicStrAppend(&output, stringpiece_foo, stringpiece_bar);
+ EXPECT_EQ("foobar", output);
+
+ // Many-many arguments.
+ QuicStrAppend(&output, "foo", "bar", "baz", "qux", "quux", "quuz", "corge",
+ "grault", "garply", "waldo", "fred", "plugh", "xyzzy", "thud");
+ EXPECT_EQ(
+ "foobarfoobarbazquxquuxquuzcorgegraultgarplywaldofredplughxyzzythud",
+ output);
+
+ output.clear();
+
+ // Numerical arguments.
+ const int16_t i = 1;
+ const uint64_t u = 8;
+ const double d = 3.1415;
+
+ QuicStrAppend(&output, i, " ", u);
+ EXPECT_EQ("1 8", output);
+ QuicStrAppend(&output, d, i, i, u, i);
+ EXPECT_EQ("1 83.14151181", output);
+ QuicStrAppend(&output, "i: ", i, ", u: ", u, ", d: ", d);
+ EXPECT_EQ("1 83.14151181i: 1, u: 8, d: 3.1415", output);
+
+ output.clear();
+
+ // Boolean arguments.
+ const bool t = true;
+ const bool f = false;
+
+ QuicStrAppend(&output, t);
+ EXPECT_EQ("1", output);
+ QuicStrAppend(&output, f);
+ EXPECT_EQ("10", output);
+ QuicStrAppend(&output, f, t, t, f);
+ EXPECT_EQ("100110", output);
+
+ output.clear();
+
+ // Mixed string-like, numerical, and Boolean arguments.
+ QuicStrAppend(&output, kFoo, i, string_foo, f, u, t, stringpiece_bar, d, t);
+ EXPECT_EQ("foo1foo081bar3.14151", output);
+ QuicStrAppend(&output, d, t, t, string_bar, i, u, kBar, t, d, f);
+ EXPECT_EQ("foo1foo081bar3.141513.141511bar18bar13.14150", output);
+}
+
+TEST(QuicStringUtilsTest, QuicStringPrintf) {
+ EXPECT_EQ("", QuicStringPrintf("%s", ""));
+ EXPECT_EQ("foobar", QuicStringPrintf("%sbar", "foo"));
+ EXPECT_EQ("foobar", QuicStringPrintf("%s%s", "foo", "bar"));
+ EXPECT_EQ("foo: 1, bar: 2.0", QuicStringPrintf("foo: %d, bar: %.1f", 1, 2.0));
+}
+
+} // namespace
+} // namespace test
+} // namespace quic
diff --git a/quic/platform/api/quic_system_event_loop.h b/quic/platform/api/quic_system_event_loop.h
new file mode 100644
index 0000000..3103d4e
--- /dev/null
+++ b/quic/platform/api/quic_system_event_loop.h
@@ -0,0 +1,16 @@
+// Copyright (c) 2019 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_QUIC_PLATFORM_API_QUIC_SYSTEM_EVENT_LOOP_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_SYSTEM_EVENT_LOOP_H_
+
+#include "net/quic/platform/impl/quic_system_event_loop_impl.h"
+
+inline void QuicRunSystemEventLoopIteration() {
+ QuicRunSystemEventLoopIterationImpl();
+}
+
+using QuicSystemEventLoop = QuicSystemEventLoopImpl;
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_SYSTEM_EVENT_LOOP_H_
diff --git a/quic/platform/api/quic_test.h b/quic/platform/api/quic_test.h
new file mode 100644
index 0000000..f4d255a
--- /dev/null
+++ b/quic/platform/api/quic_test.h
@@ -0,0 +1,27 @@
+// Copyright (c) 2017 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_QUIC_PLATFORM_API_QUIC_TEST_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_TEST_H_
+
+#include "net/quic/platform/impl/quic_test_impl.h"
+
+using QuicFlagSaver = QuicFlagSaverImpl;
+
+// Defines the base classes to be used in QUIC tests.
+using QuicTest = QuicTestImpl;
+template <class T>
+using QuicTestWithParam = QuicTestWithParamImpl<T>;
+
+// Class which needs to be instantiated in tests which use threads.
+using ScopedEnvironmentForThreads = ScopedEnvironmentForThreadsImpl;
+
+#define QUIC_TEST_DISABLED_IN_CHROME(name) \
+ QUIC_TEST_DISABLED_IN_CHROME_IMPL(name)
+
+inline std::string QuicGetTestMemoryCachePath() {
+ return QuicGetTestMemoryCachePathImpl();
+}
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_TEST_H_
diff --git a/quic/platform/api/quic_test_loopback.cc b/quic/platform/api/quic_test_loopback.cc
new file mode 100644
index 0000000..febcf37
--- /dev/null
+++ b/quic/platform/api/quic_test_loopback.cc
@@ -0,0 +1,29 @@
+// Copyright (c) 2017 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 "net/third_party/quiche/src/quic/platform/api/quic_test_loopback.h"
+
+namespace quic {
+
+IpAddressFamily AddressFamilyUnderTest() {
+ return AddressFamilyUnderTestImpl();
+}
+
+QuicIpAddress TestLoopback4() {
+ return TestLoopback4Impl();
+}
+
+QuicIpAddress TestLoopback6() {
+ return TestLoopback6Impl();
+}
+
+QuicIpAddress TestLoopback() {
+ return TestLoopbackImpl();
+}
+
+QuicIpAddress TestLoopback(int index) {
+ return TestLoopbackImpl(index);
+}
+
+} // namespace quic
diff --git a/quic/platform/api/quic_test_loopback.h b/quic/platform/api/quic_test_loopback.h
new file mode 100644
index 0000000..708e766
--- /dev/null
+++ b/quic/platform/api/quic_test_loopback.h
@@ -0,0 +1,32 @@
+// Copyright (c) 2017 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_QUIC_PLATFORM_API_QUIC_TEST_LOOPBACK_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_TEST_LOOPBACK_H_
+
+#include "net/quic/platform/impl/quic_test_loopback_impl.h"
+
+namespace quic {
+
+// Returns the address family (IPv4 or IPv6) used to run test under.
+IpAddressFamily AddressFamilyUnderTest();
+
+// Returns an IPv4 loopback address.
+QuicIpAddress TestLoopback4();
+
+// Returns the only IPv6 loopback address.
+QuicIpAddress TestLoopback6();
+
+// Returns an appropriate IPv4/Ipv6 loopback address based upon whether the
+// test's environment.
+QuicIpAddress TestLoopback();
+
+// If address family under test is IPv4, returns an indexed IPv4 loopback
+// address. If address family under test is IPv6, the address returned is
+// platform-dependent.
+QuicIpAddress TestLoopback(int index);
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_TEST_LOOPBACK_H_
diff --git a/quic/platform/api/quic_test_mem_slice_vector.h b/quic/platform/api/quic_test_mem_slice_vector.h
new file mode 100644
index 0000000..06be8f7
--- /dev/null
+++ b/quic/platform/api/quic_test_mem_slice_vector.h
@@ -0,0 +1,35 @@
+// Copyright 2017 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_QUIC_PLATFORM_API_QUIC_TEST_MEM_SLICE_VECTOR_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_TEST_MEM_SLICE_VECTOR_H_
+
+#include <utility>
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_mem_slice_span.h"
+#include "net/quic/platform/impl/quic_test_mem_slice_vector_impl.h"
+
+namespace quic {
+namespace test {
+// QuicTestMemSliceVector is a test only class which creates a vector of
+// platform-specific data structure (used as QuicMemSlice) from an array of data
+// buffers. QuicTestMemSliceVector does not own the underlying data buffer.
+// Tests using QuicTestMemSliceVector need to make sure the actual data buffers
+// outlive QuicTestMemSliceVector, and QuicTestMemSliceVector outlive the
+// returned QuicMemSliceSpan.
+class QuicTestMemSliceVector {
+ public:
+ explicit QuicTestMemSliceVector(std::vector<std::pair<char*, size_t>> buffers)
+ : impl_(std::move(buffers)) {}
+
+ QuicMemSliceSpan span() { return QuicMemSliceSpan(impl_.span()); }
+
+ private:
+ QuicTestMemSliceVectorImpl impl_;
+};
+
+} // namespace test
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_TEST_MEM_SLICE_VECTOR_H_
diff --git a/quic/platform/api/quic_test_output.h b/quic/platform/api/quic_test_output.h
new file mode 100644
index 0000000..3cb1393
--- /dev/null
+++ b/quic/platform/api/quic_test_output.h
@@ -0,0 +1,25 @@
+// Copyright (c) 2018 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_QUIC_PLATFORM_API_QUIC_TEST_OUTPUT_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_TEST_OUTPUT_H_
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+#include "net/quic/platform/impl/quic_test_output_impl.h"
+
+namespace quic {
+
+// Records a QUIC test output file into a directory specified by QUIC_TRACE_DIR
+// environment variable. Assumes that it's called from a unit test.
+//
+// The |identifier| is a human-readable identifier that will be combined with
+// the name of the unit test and a timestamp. |data| is the test output data
+// that is being recorded into the file.
+inline void QuicRecordTestOutput(QuicStringPiece identifier,
+ QuicStringPiece data) {
+ QuicRecordTestOutputImpl(identifier, data);
+}
+
+} // namespace quic
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_TEST_OUTPUT_H_
diff --git a/quic/platform/api/quic_text_utils.h b/quic/platform/api/quic_text_utils.h
new file mode 100644
index 0000000..5bf9890
--- /dev/null
+++ b/quic/platform/api/quic_text_utils.h
@@ -0,0 +1,119 @@
+// Copyright 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_QUIC_PLATFORM_API_QUIC_TEXT_UTILS_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_TEXT_UTILS_H_
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_string.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+#include "net/quic/platform/impl/quic_text_utils_impl.h"
+
+namespace quic {
+
+// Various utilities for manipulating text.
+class QuicTextUtils {
+ public:
+ // Returns true if |data| starts with |prefix|, case sensitively.
+ static bool StartsWith(QuicStringPiece data, QuicStringPiece prefix) {
+ return QuicTextUtilsImpl::StartsWith(data, prefix);
+ }
+
+ // Returns true if |data| ends with |suffix|, case insensitively.
+ static bool EndsWithIgnoreCase(QuicStringPiece data, QuicStringPiece suffix) {
+ return QuicTextUtilsImpl::EndsWithIgnoreCase(data, suffix);
+ }
+
+ // Returns a new string in which |data| has been converted to lower case.
+ static QuicString ToLower(QuicStringPiece data) {
+ return QuicTextUtilsImpl::ToLower(data);
+ }
+
+ // Removes leading and trailing whitespace from |data|.
+ static void RemoveLeadingAndTrailingWhitespace(QuicStringPiece* data) {
+ QuicTextUtilsImpl::RemoveLeadingAndTrailingWhitespace(data);
+ }
+
+ // Returns true if |in| represents a valid uint64, and stores that value in
+ // |out|.
+ static bool StringToUint64(QuicStringPiece in, uint64_t* out) {
+ return QuicTextUtilsImpl::StringToUint64(in, out);
+ }
+
+ // Returns true if |in| represents a valid int, and stores that value in
+ // |out|.
+ static bool StringToInt(QuicStringPiece in, int* out) {
+ return QuicTextUtilsImpl::StringToInt(in, out);
+ }
+
+ // Returns true if |in| represents a valid uint32, and stores that value in
+ // |out|.
+ static bool StringToUint32(QuicStringPiece in, uint32_t* out) {
+ return QuicTextUtilsImpl::StringToUint32(in, out);
+ }
+
+ // Returns true if |in| represents a valid size_t, and stores that value in
+ // |out|.
+ static bool StringToSizeT(QuicStringPiece in, size_t* out) {
+ return QuicTextUtilsImpl::StringToSizeT(in, out);
+ }
+
+ // Returns a new string representing |in|.
+ static QuicString Uint64ToString(uint64_t in) {
+ return QuicTextUtilsImpl::Uint64ToString(in);
+ }
+
+ // This converts |length| bytes of binary to a 2*|length|-character
+ // hexadecimal representation.
+ // Return value: 2*|length| characters of ASCII string.
+ static QuicString HexEncode(const char* data, size_t length) {
+ return HexEncode(QuicStringPiece(data, length));
+ }
+
+ // This converts |data.length()| bytes of binary to a
+ // 2*|data.length()|-character hexadecimal representation.
+ // Return value: 2*|data.length()| characters of ASCII string.
+ static QuicString HexEncode(QuicStringPiece data) {
+ return QuicTextUtilsImpl::HexEncode(data);
+ }
+
+ // This converts a uint32 into an 8-character hexidecimal
+ // representation. Return value: 8 characters of ASCII string.
+ static QuicString Hex(uint32_t v) { return QuicTextUtilsImpl::Hex(v); }
+
+ // Converts |data| from a hexadecimal ASCII string to a binary string
+ // that is |data.length()/2| bytes long.
+ static QuicString HexDecode(QuicStringPiece data) {
+ return QuicTextUtilsImpl::HexDecode(data);
+ }
+
+ // Base64 encodes with no padding |data_len| bytes of |data| into |output|.
+ static void Base64Encode(const uint8_t* data,
+ size_t data_len,
+ QuicString* output) {
+ return QuicTextUtilsImpl::Base64Encode(data, data_len, output);
+ }
+
+ // Returns a string containing hex and ASCII representations of |binary|,
+ // side-by-side in the style of hexdump. Non-printable characters will be
+ // printed as '.' in the ASCII output.
+ // For example, given the input "Hello, QUIC!\01\02\03\04", returns:
+ // "0x0000: 4865 6c6c 6f2c 2051 5549 4321 0102 0304 Hello,.QUIC!...."
+ static QuicString HexDump(QuicStringPiece binary_data) {
+ return QuicTextUtilsImpl::HexDump(binary_data);
+ }
+
+ // Returns true if |data| contains any uppercase characters.
+ static bool ContainsUpperCase(QuicStringPiece data) {
+ return QuicTextUtilsImpl::ContainsUpperCase(data);
+ }
+
+ // Splits |data| into a vector of pieces delimited by |delim|.
+ static std::vector<QuicStringPiece> Split(QuicStringPiece data, char delim) {
+ return QuicTextUtilsImpl::Split(data, delim);
+ }
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_TEXT_UTILS_H_
diff --git a/quic/platform/api/quic_text_utils_test.cc b/quic/platform/api/quic_text_utils_test.cc
new file mode 100644
index 0000000..820343c
--- /dev/null
+++ b/quic/platform/api/quic_text_utils_test.cc
@@ -0,0 +1,206 @@
+// Copyright 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.
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_string.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
+
+namespace quic {
+namespace test {
+
+class QuicTextUtilsTest : public QuicTest {};
+
+TEST_F(QuicTextUtilsTest, StartsWith) {
+ EXPECT_TRUE(QuicTextUtils::StartsWith("hello world", "hello"));
+ EXPECT_TRUE(QuicTextUtils::StartsWith("hello world", "hello world"));
+ EXPECT_TRUE(QuicTextUtils::StartsWith("hello world", ""));
+ EXPECT_FALSE(QuicTextUtils::StartsWith("hello world", "Hello"));
+ EXPECT_FALSE(QuicTextUtils::StartsWith("hello world", "world"));
+ EXPECT_FALSE(QuicTextUtils::StartsWith("hello world", "bar"));
+}
+
+TEST_F(QuicTextUtilsTest, EndsWithIgnoreCase) {
+ EXPECT_TRUE(QuicTextUtils::EndsWithIgnoreCase("hello world", "world"));
+ EXPECT_TRUE(QuicTextUtils::EndsWithIgnoreCase("hello world", "hello world"));
+ EXPECT_TRUE(QuicTextUtils::EndsWithIgnoreCase("hello world", ""));
+ EXPECT_TRUE(QuicTextUtils::EndsWithIgnoreCase("hello world", "WORLD"));
+ EXPECT_FALSE(QuicTextUtils::EndsWithIgnoreCase("hello world", "hello"));
+}
+
+TEST_F(QuicTextUtilsTest, ToLower) {
+ EXPECT_EQ("lower", QuicTextUtils::ToLower("LOWER"));
+ EXPECT_EQ("lower", QuicTextUtils::ToLower("lower"));
+ EXPECT_EQ("lower", QuicTextUtils::ToLower("lOwEr"));
+ EXPECT_EQ("123", QuicTextUtils::ToLower("123"));
+ EXPECT_EQ("", QuicTextUtils::ToLower(""));
+}
+
+TEST_F(QuicTextUtilsTest, RemoveLeadingAndTrailingWhitespace) {
+ QuicString input;
+
+ for (auto* input : {"text", " text", " text", "text ", "text ", " text ",
+ " text ", "\r\n\ttext", "text\n\r\t"}) {
+ QuicStringPiece piece(input);
+ QuicTextUtils::RemoveLeadingAndTrailingWhitespace(&piece);
+ EXPECT_EQ("text", piece);
+ }
+}
+
+TEST_F(QuicTextUtilsTest, StringToNumbers) {
+ const QuicString kMaxInt32Plus1 = "2147483648";
+ const QuicString kMinInt32Minus1 = "-2147483649";
+ const QuicString kMaxUint32Plus1 = "4294967296";
+
+ {
+ // StringToUint64
+ uint64_t uint64_val = 0;
+ EXPECT_TRUE(QuicTextUtils::StringToUint64("123", &uint64_val));
+ EXPECT_EQ(123u, uint64_val);
+ EXPECT_TRUE(QuicTextUtils::StringToUint64("1234", &uint64_val));
+ EXPECT_EQ(1234u, uint64_val);
+ EXPECT_FALSE(QuicTextUtils::StringToUint64("", &uint64_val));
+ EXPECT_FALSE(QuicTextUtils::StringToUint64("-123", &uint64_val));
+ EXPECT_FALSE(QuicTextUtils::StringToUint64("-123.0", &uint64_val));
+ EXPECT_TRUE(QuicTextUtils::StringToUint64(kMaxUint32Plus1, &uint64_val));
+ EXPECT_EQ(4294967296u, uint64_val);
+ }
+
+ {
+ // StringToint
+ int int_val = 0;
+ EXPECT_TRUE(QuicTextUtils::StringToInt("123", &int_val));
+ EXPECT_EQ(123, int_val);
+ EXPECT_TRUE(QuicTextUtils::StringToInt("1234", &int_val));
+ EXPECT_EQ(1234, int_val);
+ EXPECT_FALSE(QuicTextUtils::StringToInt("", &int_val));
+ EXPECT_TRUE(QuicTextUtils::StringToInt("-123", &int_val));
+ EXPECT_EQ(-123, int_val);
+ EXPECT_FALSE(QuicTextUtils::StringToInt("-123.0", &int_val));
+ if (sizeof(int) > 4) {
+ EXPECT_TRUE(QuicTextUtils::StringToInt(kMinInt32Minus1, &int_val));
+ EXPECT_EQ(-2147483649ll, int_val);
+ EXPECT_TRUE(QuicTextUtils::StringToInt(kMaxInt32Plus1, &int_val));
+ EXPECT_EQ(2147483648ll, int_val);
+ } else {
+ EXPECT_FALSE(QuicTextUtils::StringToInt(kMinInt32Minus1, &int_val));
+ EXPECT_FALSE(QuicTextUtils::StringToInt(kMaxInt32Plus1, &int_val));
+ }
+ }
+
+ {
+ // StringToUint32
+ uint32_t uint32_val = 0;
+ EXPECT_TRUE(QuicTextUtils::StringToUint32("123", &uint32_val));
+ EXPECT_EQ(123u, uint32_val);
+ EXPECT_TRUE(QuicTextUtils::StringToUint32("1234", &uint32_val));
+ EXPECT_EQ(1234u, uint32_val);
+ EXPECT_FALSE(QuicTextUtils::StringToUint32("", &uint32_val));
+ EXPECT_FALSE(QuicTextUtils::StringToUint32("-123", &uint32_val));
+ EXPECT_FALSE(QuicTextUtils::StringToUint32("-123.0", &uint32_val));
+ EXPECT_FALSE(QuicTextUtils::StringToUint32(kMaxUint32Plus1, &uint32_val));
+ }
+
+ {
+ // StringToSizeT
+ size_t size_t_val = 0;
+ EXPECT_TRUE(QuicTextUtils::StringToSizeT("123", &size_t_val));
+ EXPECT_EQ(123u, size_t_val);
+ EXPECT_TRUE(QuicTextUtils::StringToSizeT("1234", &size_t_val));
+ EXPECT_EQ(1234u, size_t_val);
+ EXPECT_FALSE(QuicTextUtils::StringToSizeT("", &size_t_val));
+ EXPECT_FALSE(QuicTextUtils::StringToSizeT("-123", &size_t_val));
+ EXPECT_FALSE(QuicTextUtils::StringToSizeT("-123.0", &size_t_val));
+ if (sizeof(size_t) > 4) {
+ EXPECT_TRUE(QuicTextUtils::StringToSizeT(kMaxUint32Plus1, &size_t_val));
+ EXPECT_EQ(4294967296ull, size_t_val);
+ } else {
+ EXPECT_FALSE(QuicTextUtils::StringToSizeT(kMaxUint32Plus1, &size_t_val));
+ }
+ }
+}
+
+TEST_F(QuicTextUtilsTest, Uint64ToString) {
+ EXPECT_EQ("123", QuicTextUtils::Uint64ToString(123));
+ EXPECT_EQ("1234", QuicTextUtils::Uint64ToString(1234));
+}
+
+TEST_F(QuicTextUtilsTest, HexEncode) {
+ EXPECT_EQ("48656c6c6f", QuicTextUtils::HexEncode("Hello", 5));
+ EXPECT_EQ("48656c6c6f", QuicTextUtils::HexEncode("Hello World", 5));
+ EXPECT_EQ("48656c6c6f", QuicTextUtils::HexEncode("Hello"));
+ EXPECT_EQ("0102779cfa", QuicTextUtils::HexEncode("\x01\x02\x77\x9c\xfa"));
+}
+
+TEST_F(QuicTextUtilsTest, HexDecode) {
+ EXPECT_EQ("Hello", QuicTextUtils::HexDecode("48656c6c6f"));
+ EXPECT_EQ("", QuicTextUtils::HexDecode(""));
+ EXPECT_EQ("\x01\x02\x77\x9c\xfa", QuicTextUtils::HexDecode("0102779cfa"));
+}
+
+TEST_F(QuicTextUtilsTest, HexDump) {
+ // Verify output of the HexDump method is as expected.
+ char packet[] = {
+ 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x2c, 0x20, 0x51, 0x55, 0x49, 0x43, 0x21,
+ 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
+ 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x6c,
+ 0x6f, 0x6e, 0x67, 0x20, 0x65, 0x6e, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x74,
+ 0x6f, 0x20, 0x73, 0x70, 0x61, 0x6e, 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69,
+ 0x70, 0x6c, 0x65, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x6f, 0x66,
+ 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x2e, 0x01, 0x02, 0x03, 0x00,
+ };
+ EXPECT_EQ(
+ QuicTextUtils::HexDump(packet),
+ "0x0000: 4865 6c6c 6f2c 2051 5549 4321 2054 6869 Hello,.QUIC!.Thi\n"
+ "0x0010: 7320 7374 7269 6e67 2073 686f 756c 6420 s.string.should.\n"
+ "0x0020: 6265 206c 6f6e 6720 656e 6f75 6768 2074 be.long.enough.t\n"
+ "0x0030: 6f20 7370 616e 206d 756c 7469 706c 6520 o.span.multiple.\n"
+ "0x0040: 6c69 6e65 7320 6f66 206f 7574 7075 742e lines.of.output.\n"
+ "0x0050: 0102 03 ...\n");
+ // Verify that 0x21 and 0x7e are printable, 0x20 and 0x7f are not.
+ EXPECT_EQ("0x0000: 2021 7e7f .!~.\n",
+ QuicTextUtils::HexDump(QuicTextUtils::HexDecode("20217e7f")));
+ // Verify that values above numeric_limits<unsigned char>::max() are formatted
+ // properly on platforms where char is unsigned.
+ EXPECT_EQ("0x0000: 90aa ff ...\n",
+ QuicTextUtils::HexDump(QuicTextUtils::HexDecode("90aaff")));
+}
+
+TEST_F(QuicTextUtilsTest, Base64Encode) {
+ QuicString output;
+ QuicString input = "Hello";
+ QuicTextUtils::Base64Encode(reinterpret_cast<const uint8_t*>(input.data()),
+ input.length(), &output);
+ EXPECT_EQ("SGVsbG8", output);
+
+ input =
+ "Hello, QUIC! This string should be long enough to span"
+ "multiple lines of output\n";
+ QuicTextUtils::Base64Encode(reinterpret_cast<const uint8_t*>(input.data()),
+ input.length(), &output);
+ EXPECT_EQ(
+ "SGVsbG8sIFFVSUMhIFRoaXMgc3RyaW5nIHNob3VsZCBiZSBsb25n"
+ "IGVub3VnaCB0byBzcGFubXVsdGlwbGUgbGluZXMgb2Ygb3V0cHV0Cg",
+ output);
+}
+
+TEST_F(QuicTextUtilsTest, ContainsUpperCase) {
+ EXPECT_FALSE(QuicTextUtils::ContainsUpperCase("abc"));
+ EXPECT_FALSE(QuicTextUtils::ContainsUpperCase(""));
+ EXPECT_FALSE(QuicTextUtils::ContainsUpperCase("123"));
+ EXPECT_TRUE(QuicTextUtils::ContainsUpperCase("ABC"));
+ EXPECT_TRUE(QuicTextUtils::ContainsUpperCase("aBc"));
+}
+
+TEST_F(QuicTextUtilsTest, Split) {
+ EXPECT_EQ(std::vector<QuicStringPiece>({"a", "b", "c"}),
+ QuicTextUtils::Split("a,b,c", ','));
+ EXPECT_EQ(std::vector<QuicStringPiece>({"a", "b", "c"}),
+ QuicTextUtils::Split("a:b:c", ':'));
+ EXPECT_EQ(std::vector<QuicStringPiece>({"a:b:c"}),
+ QuicTextUtils::Split("a:b:c", ','));
+}
+
+} // namespace test
+} // namespace quic
diff --git a/quic/platform/api/quic_thread.h b/quic/platform/api/quic_thread.h
new file mode 100644
index 0000000..75d541c
--- /dev/null
+++ b/quic/platform/api/quic_thread.h
@@ -0,0 +1,26 @@
+// Copyright (c) 2018 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_QUIC_PLATFORM_API_QUIC_THREAD_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_THREAD_H_
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_string.h"
+#include "net/quic/platform/impl/quic_thread_impl.h"
+
+namespace quic {
+
+// A class representing a thread of execution in QUIC.
+class QuicThread : public QuicThreadImpl {
+ public:
+ QuicThread(const QuicString& string) : QuicThreadImpl(string) {}
+ QuicThread(const QuicThread&) = delete;
+ QuicThread& operator=(const QuicThread&) = delete;
+
+ // Impl defines a virtual void Run() method which subclasses
+ // must implement.
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_THREAD_H_
diff --git a/quic/platform/api/quic_uint128.h b/quic/platform/api/quic_uint128.h
new file mode 100644
index 0000000..4f333ae
--- /dev/null
+++ b/quic/platform/api/quic_uint128.h
@@ -0,0 +1,19 @@
+// Copyright 2018 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_QUIC_PLATFORM_API_QUIC_UINT128_H_
+#define QUICHE_QUIC_PLATFORM_API_QUIC_UINT128_H_
+
+#include "net/quic/platform/impl/quic_uint128_impl.h"
+
+namespace quic {
+
+using QuicUint128 = QuicUint128Impl;
+#define MakeQuicUint128(hi, lo) MakeQuicUint128Impl(hi, lo)
+#define QuicUint128Low64(x) QuicUint128Low64Impl(x)
+#define QuicUint128High64(x) QuicUint128High64Impl(x)
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_PLATFORM_API_QUIC_UINT128_H_
