diff --git a/spdy/core/spdy_simple_arena.cc b/spdy/core/spdy_simple_arena.cc
new file mode 100644
index 0000000..08cdc62
--- /dev/null
+++ b/spdy/core/spdy_simple_arena.cc
@@ -0,0 +1,103 @@
+// 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/spdy/core/spdy_simple_arena.h"
+
+#include "net/third_party/quiche/src/spdy/platform/api/spdy_logging.h"
+
+namespace spdy {
+
+SpdySimpleArena::SpdySimpleArena(size_t block_size) : block_size_(block_size) {}
+
+SpdySimpleArena::~SpdySimpleArena() = default;
+
+SpdySimpleArena::SpdySimpleArena(SpdySimpleArena&& other) = default;
+SpdySimpleArena& SpdySimpleArena::operator=(SpdySimpleArena&& other) = default;
+
+char* SpdySimpleArena::Alloc(size_t size) {
+  Reserve(size);
+  Block& b = blocks_.back();
+  DCHECK_GE(b.size, b.used + size);
+  char* out = b.data.get() + b.used;
+  b.used += size;
+  return out;
+}
+
+char* SpdySimpleArena::Realloc(char* original, size_t oldsize, size_t newsize) {
+  DCHECK(!blocks_.empty());
+  Block& last = blocks_.back();
+  if (last.data.get() <= original && original < last.data.get() + last.size) {
+    // (original, oldsize) is in the last Block.
+    DCHECK_GE(last.data.get() + last.used, original + oldsize);
+    if (original + oldsize == last.data.get() + last.used) {
+      // (original, oldsize) was the most recent allocation,
+      if (original + newsize < last.data.get() + last.size) {
+        // (original, newsize) fits in the same Block.
+        last.used += newsize - oldsize;
+        return original;
+      }
+    }
+  }
+  char* out = Alloc(newsize);
+  memcpy(out, original, oldsize);
+  return out;
+}
+
+char* SpdySimpleArena::Memdup(const char* data, size_t size) {
+  char* out = Alloc(size);
+  memcpy(out, data, size);
+  return out;
+}
+
+void SpdySimpleArena::Free(char* data, size_t size) {
+  if (blocks_.empty()) {
+    return;
+  }
+  Block& b = blocks_.back();
+  if (size <= b.used && data + size == b.data.get() + b.used) {
+    // The memory region passed by the caller was the most recent allocation
+    // from the final block in this arena.
+    b.used -= size;
+  }
+}
+
+void SpdySimpleArena::Reset() {
+  blocks_.clear();
+  status_.bytes_allocated_ = 0;
+}
+
+void SpdySimpleArena::Reserve(size_t additional_space) {
+  if (blocks_.empty()) {
+    AllocBlock(std::max(additional_space, block_size_));
+  } else {
+    const Block& last = blocks_.back();
+    if (last.size < last.used + additional_space) {
+      AllocBlock(std::max(additional_space, block_size_));
+    }
+  }
+}
+
+void SpdySimpleArena::AllocBlock(size_t size) {
+  blocks_.push_back(Block(size));
+  status_.bytes_allocated_ += size;
+}
+
+SpdySimpleArena::Block::Block(size_t s) : data(new char[s]), size(s), used(0) {}
+
+SpdySimpleArena::Block::~Block() = default;
+
+SpdySimpleArena::Block::Block(SpdySimpleArena::Block&& other)
+    : size(other.size), used(other.used) {
+  data = std::move(other.data);
+}
+
+SpdySimpleArena::Block& SpdySimpleArena::Block::operator=(
+    SpdySimpleArena::Block&& other) {
+  size = other.size;
+  used = other.used;
+  data = std::move(other.data);
+  return *this;
+}
+
+}  // namespace spdy
diff --git a/spdy/core/spdy_simple_arena.h b/spdy/core/spdy_simple_arena.h
new file mode 100644
index 0000000..4cd48ce
--- /dev/null
+++ b/spdy/core/spdy_simple_arena.h
@@ -0,0 +1,77 @@
+// 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_SPDY_CORE_SPDY_SIMPLE_ARENA_H_
+#define QUICHE_SPDY_CORE_SPDY_SIMPLE_ARENA_H_
+
+#include <memory>
+#include <vector>
+
+#include "net/third_party/quiche/src/spdy/platform/api/spdy_export.h"
+
+namespace spdy {
+
+// Allocates large blocks of memory, and doles them out in smaller chunks.
+// Not thread-safe.
+class SPDY_EXPORT_PRIVATE SpdySimpleArena {
+ public:
+  class Status {
+   private:
+    friend class SpdySimpleArena;
+    size_t bytes_allocated_;
+
+   public:
+    Status() : bytes_allocated_(0) {}
+    size_t bytes_allocated() const { return bytes_allocated_; }
+  };
+
+  // Blocks allocated by this arena will be at least |block_size| bytes.
+  explicit SpdySimpleArena(size_t block_size);
+  ~SpdySimpleArena();
+
+  // Copy and assign are not allowed.
+  SpdySimpleArena() = delete;
+  SpdySimpleArena(const SpdySimpleArena&) = delete;
+  SpdySimpleArena& operator=(const SpdySimpleArena&) = delete;
+
+  // Move is allowed.
+  SpdySimpleArena(SpdySimpleArena&& other);
+  SpdySimpleArena& operator=(SpdySimpleArena&& other);
+
+  char* Alloc(size_t size);
+  char* Realloc(char* original, size_t oldsize, size_t newsize);
+  char* Memdup(const char* data, size_t size);
+
+  // If |data| and |size| describe the most recent allocation made from this
+  // arena, the memory is reclaimed. Otherwise, this method is a no-op.
+  void Free(char* data, size_t size);
+
+  void Reset();
+
+  Status status() const { return status_; }
+
+ private:
+  struct Block {
+    std::unique_ptr<char[]> data;
+    size_t size = 0;
+    size_t used = 0;
+
+    explicit Block(size_t s);
+    ~Block();
+
+    Block(Block&& other);
+    Block& operator=(Block&& other);
+  };
+
+  void Reserve(size_t additional_space);
+  void AllocBlock(size_t size);
+
+  size_t block_size_;
+  std::vector<Block> blocks_;
+  Status status_;
+};
+
+}  // namespace spdy
+
+#endif  // QUICHE_SPDY_CORE_SPDY_SIMPLE_ARENA_H_
diff --git a/spdy/core/spdy_simple_arena_test.cc b/spdy/core/spdy_simple_arena_test.cc
new file mode 100644
index 0000000..fc4b130
--- /dev/null
+++ b/spdy/core/spdy_simple_arena_test.cc
@@ -0,0 +1,136 @@
+// 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/spdy/core/spdy_simple_arena.h"
+
+#include <vector>
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "net/third_party/quiche/src/spdy/platform/api/spdy_string.h"
+#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
+
+namespace spdy {
+namespace {
+
+size_t kDefaultBlockSize = 2048;
+const char kTestString[] = "This is a decently long test string.";
+
+TEST(SpdySimpleArenaTest, Memdup) {
+  SpdySimpleArena arena(kDefaultBlockSize);
+  const size_t length = strlen(kTestString);
+  char* c = arena.Memdup(kTestString, length);
+  EXPECT_NE(nullptr, c);
+  EXPECT_NE(c, kTestString);
+  EXPECT_EQ(SpdyStringPiece(c, length), kTestString);
+}
+
+TEST(SpdySimpleArenaTest, MemdupLargeString) {
+  SpdySimpleArena arena(10 /* block size */);
+  const size_t length = strlen(kTestString);
+  char* c = arena.Memdup(kTestString, length);
+  EXPECT_NE(nullptr, c);
+  EXPECT_NE(c, kTestString);
+  EXPECT_EQ(SpdyStringPiece(c, length), kTestString);
+}
+
+TEST(SpdySimpleArenaTest, MultipleBlocks) {
+  SpdySimpleArena arena(40 /* block size */);
+  std::vector<SpdyString> strings = {
+      "One decently long string.", "Another string.",
+      "A third string that will surely go in a different block."};
+  std::vector<SpdyStringPiece> copies;
+  for (const SpdyString& s : strings) {
+    SpdyStringPiece sp(arena.Memdup(s.data(), s.size()), s.size());
+    copies.push_back(sp);
+  }
+  EXPECT_EQ(strings.size(), copies.size());
+  for (size_t i = 0; i < strings.size(); ++i) {
+    EXPECT_EQ(copies[i], strings[i]);
+  }
+}
+
+TEST(SpdySimpleArenaTest, UseAfterReset) {
+  SpdySimpleArena arena(kDefaultBlockSize);
+  const size_t length = strlen(kTestString);
+  char* c = arena.Memdup(kTestString, length);
+  arena.Reset();
+  c = arena.Memdup(kTestString, length);
+  EXPECT_NE(nullptr, c);
+  EXPECT_NE(c, kTestString);
+  EXPECT_EQ(SpdyStringPiece(c, length), kTestString);
+}
+
+TEST(SpdySimpleArenaTest, Free) {
+  SpdySimpleArena arena(kDefaultBlockSize);
+  const size_t length = strlen(kTestString);
+  // Freeing memory not owned by the arena should be a no-op, and freeing
+  // before any allocations from the arena should be a no-op.
+  arena.Free(const_cast<char*>(kTestString), length);
+  char* c1 = arena.Memdup("Foo", 3);
+  char* c2 = arena.Memdup(kTestString, length);
+  arena.Free(const_cast<char*>(kTestString), length);
+  char* c3 = arena.Memdup("Bar", 3);
+  char* c4 = arena.Memdup(kTestString, length);
+  EXPECT_NE(c1, c2);
+  EXPECT_NE(c1, c3);
+  EXPECT_NE(c1, c4);
+  EXPECT_NE(c2, c3);
+  EXPECT_NE(c2, c4);
+  EXPECT_NE(c3, c4);
+  // Freeing c4 should succeed, since it was the most recent allocation.
+  arena.Free(c4, length);
+  // Freeing c2 should be a no-op.
+  arena.Free(c2, length);
+  // c5 should reuse memory that was previously used by c4.
+  char* c5 = arena.Memdup("Baz", 3);
+  EXPECT_EQ(c4, c5);
+}
+
+TEST(SpdySimpleArenaTest, Alloc) {
+  SpdySimpleArena arena(kDefaultBlockSize);
+  const size_t length = strlen(kTestString);
+  char* c1 = arena.Alloc(length);
+  char* c2 = arena.Alloc(2 * length);
+  char* c3 = arena.Alloc(3 * length);
+  char* c4 = arena.Memdup(kTestString, length);
+  EXPECT_EQ(c1 + length, c2);
+  EXPECT_EQ(c2 + 2 * length, c3);
+  EXPECT_EQ(c3 + 3 * length, c4);
+  EXPECT_EQ(SpdyStringPiece(c4, length), kTestString);
+}
+
+TEST(SpdySimpleArenaTest, Realloc) {
+  SpdySimpleArena arena(kDefaultBlockSize);
+  const size_t length = strlen(kTestString);
+  // Simple realloc that fits in the block.
+  char* c1 = arena.Memdup(kTestString, length);
+  char* c2 = arena.Realloc(c1, length, 2 * length);
+  EXPECT_TRUE(c1);
+  EXPECT_EQ(c1, c2);
+  EXPECT_EQ(SpdyStringPiece(c1, length), kTestString);
+  // Multiple reallocs.
+  char* c3 = arena.Memdup(kTestString, length);
+  EXPECT_EQ(c2 + 2 * length, c3);
+  EXPECT_EQ(SpdyStringPiece(c3, length), kTestString);
+  char* c4 = arena.Realloc(c3, length, 2 * length);
+  EXPECT_EQ(c3, c4);
+  EXPECT_EQ(SpdyStringPiece(c4, length), kTestString);
+  char* c5 = arena.Realloc(c4, 2 * length, 3 * length);
+  EXPECT_EQ(c4, c5);
+  EXPECT_EQ(SpdyStringPiece(c5, length), kTestString);
+  char* c6 = arena.Memdup(kTestString, length);
+  EXPECT_EQ(c5 + 3 * length, c6);
+  EXPECT_EQ(SpdyStringPiece(c6, length), kTestString);
+  // Realloc that does not fit in the remainder of the first block.
+  char* c7 = arena.Realloc(c6, length, kDefaultBlockSize);
+  EXPECT_EQ(SpdyStringPiece(c7, length), kTestString);
+  arena.Free(c7, kDefaultBlockSize);
+  char* c8 = arena.Memdup(kTestString, length);
+  EXPECT_NE(c6, c7);
+  EXPECT_EQ(c7, c8);
+  EXPECT_EQ(SpdyStringPiece(c8, length), kTestString);
+}
+
+}  // namespace
+}  // namespace spdy