Move gif image decoder to SkCodec

third_party/WebKit/Source/platform/image-decoders/SegmentStreamTest.cpp

Index: third_party/WebKit/Source/platform/image-decoders/SegmentStreamTest.cpp
diff --git a/third_party/WebKit/Source/platform/image-decoders/SegmentStreamTest.cpp b/third_party/WebKit/Source/platform/image-decoders/SegmentStreamTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ebdfae5647eb8af9c455560fd5dee3e502b39138
--- /dev/null
+++ b/third_party/WebKit/Source/platform/image-decoders/SegmentStreamTest.cpp
@@ -0,0 +1,644 @@
+// 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 "platform/image-decoders/SegmentStream.h"
+
+#include <memory>
+#include "platform/SharedBuffer.h"
+#include "platform/wtf/PtrUtil.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+// SegmentStream has 4 accessors which do not alter state:
+// - isCleared()
+// - isAtEnd()
+// - getPosition()
+// - getLength()
+//
+// For every operation which changes state we can test:
+// - the operation completed as expected,
+// - the accessors did not change, and/or
+// - the accessors changed in the way we expected.
+//
+// There are actually 2 more accessors:
+// - hasPosition()
+// - hasLength()
+// but these should always return true to indicate that we can call getLength()
+// for example. So let's not add them to every state changing operation and add
+// needless complexity.
+
+namespace {
+
+constexpr size_t kBufferAllocationSize = 20;
+constexpr size_t kInsideBufferPosition = 10;
+constexpr size_t kPastEndOfBufferPosition = 30;
+
+testing::AssertionResult IsCleared(const blink::SegmentStream&);
+testing::AssertionResult IsAtEnd(const blink::SegmentStream&);
+testing::AssertionResult PositionIsZero(const blink::SegmentStream&);
+testing::AssertionResult PositionIsInsideBuffer(const blink::SegmentStream&);
+testing::AssertionResult PositionIsAtEndOfBuffer(const blink::SegmentStream&);
+testing::AssertionResult LengthIsZero(const blink::SegmentStream&);
+testing::AssertionResult LengthIsAllocationSize(const blink::SegmentStream&);
+
+// Many of these tests require a SegmentStream that can be read from.
+// This means the stream must have a buffer and contents.
+//
+// This function creates a buffer of size |kBufferAllocationSize|
+// and prepares a SegmentStream with that buffer.
+blink::SegmentStream CreatePopulatedSegmentStreamReadable();

[cblume, 2017/04/26 21:48:12]

Oops. This wasn't supposed to end in ___Readable(). Please disregard.

+RefPtr<blink::SegmentReader> CreateSegmentReader();
+
+}  // namespace
+
+namespace blink {
+
+TEST(SegmentStreamTest, DefaultConstructorShouldSetIsCleared) {
+  SegmentStream segment_stream;
+
+  ASSERT_TRUE(IsCleared(segment_stream));
+}
+
+TEST(SegmentStreamTest, DefaultConstructorShouldSetIsAtEnd) {
+  SegmentStream segment_stream;
+
+  ASSERT_TRUE(IsAtEnd(segment_stream));
+}
+
+TEST(SegmentStreamTest, DefaultContructorShouldClearPosition) {
+  SegmentStream segment_stream;
+
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+}
+
+TEST(SegmentStreamTest, DefaultConstructorShouldHaveZeroLength) {
+  SegmentStream segment_stream;
+
+  ASSERT_TRUE(LengthIsZero(segment_stream));
+}
+
+TEST(SegmentStreamTest, MoveConstructorShouldSetIsClearedWhenRhsIsCleared) {
+  SegmentStream cleared_segment_stream;
+  ASSERT_TRUE(IsCleared(cleared_segment_stream));
+
+  SegmentStream move_constructed_segment_stream(
+      std::move(cleared_segment_stream));
+
+  ASSERT_TRUE(IsCleared(move_constructed_segment_stream));
+}
+
+TEST(SegmentStreamTest,
+     MoveConstructorShouldUnsetIsClearedWhenRhsIsNotCleared) {
+  SegmentStream uncleared_segment_stream =
+      CreatePopulatedSegmentStreamReadable();
+  ASSERT_FALSE(IsCleared(uncleared_segment_stream));
+
+  SegmentStream move_constructed_segment_stream =
+      std::move(uncleared_segment_stream);
+
+  ASSERT_FALSE(IsCleared(move_constructed_segment_stream));
+}
+
+TEST(SegmentStreamTest, MoveConstructorShouldSetIsAtEndWhenRhsIsAtEnd) {
+  SegmentStream at_end_segment_stream;
+  ASSERT_TRUE(IsAtEnd(at_end_segment_stream));
+
+  SegmentStream move_constructed_segment_stream =
+      std::move(at_end_segment_stream);
+
+  ASSERT_TRUE(IsAtEnd(move_constructed_segment_stream));
+}
+
+TEST(SegmentStreamTest, MoveConstructorShouldUnsetIsAtEndWhenRhsIsNotAtEnd) {
+  SegmentStream not_at_end_segment_stream =
+      CreatePopulatedSegmentStreamReadable();
+  ASSERT_FALSE(IsAtEnd(not_at_end_segment_stream));
+
+  SegmentStream move_constructed_segment_stream =
+      std::move(not_at_end_segment_stream);
+
+  ASSERT_FALSE(IsAtEnd(move_constructed_segment_stream));
+}
+
+TEST(SegmentStreamTest, MoveContructorShouldCopyRhsPosition) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+  segment_stream.seek(kInsideBufferPosition);
+  ASSERT_EQ(kInsideBufferPosition, segment_stream.getPosition());
+
+  SegmentStream move_constructed_segment_stream = std::move(segment_stream);
+
+  ASSERT_EQ(kInsideBufferPosition,
+            move_constructed_segment_stream.getPosition());
+}
+
+TEST(SegmentStreamTest, MoveConstructorShouldCopyRhsLength) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+  ASSERT_EQ(kBufferAllocationSize, segment_stream.getLength());
+
+  SegmentStream move_constructed_segment_stream = std::move(segment_stream);
+
+  ASSERT_EQ(kBufferAllocationSize, move_constructed_segment_stream.getLength());
+}
+
+TEST(SegmentStreamTest, SetReaderShouldUnsetIsCleared) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  ASSERT_FALSE(IsCleared(segment_stream));
+}
+
+TEST(SegmentStreamTest, SetReaderShouldUnsetIsAtEnd) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+}
+
+TEST(SegmentStreamTest, SetReaderShouldNotChangePosition) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+}
+
+TEST(SegmentStreamTest, SetReaderShouldUpdateLength) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  ASSERT_TRUE(LengthIsAllocationSize(segment_stream));
+}
+
+TEST(SegmentStreamTest, SetReaderShouldSetIsClearedWhenSetToNull) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+  ASSERT_FALSE(IsCleared(segment_stream));
+
+  segment_stream.SetReader(nullptr);
+  ASSERT_TRUE(IsCleared(segment_stream));
+}
+
+TEST(SegmentStreamTest, SetReaderShouldSetIsClearedWhenReaderSizeNotBigEnough) {
+  SegmentStream segment_stream;
+  segment_stream.seek(kPastEndOfBufferPosition);
+  RefPtr<blink::SegmentReader> segment_reader = CreateSegmentReader();
+
+  segment_stream.SetReader(segment_reader);
+
+  ASSERT_TRUE(IsCleared(segment_stream));
+}
+
+TEST(SegmentStreamTest, SetReaderShouldSetIsAtEndWhenReaderSizeNotBigEnough) {
+  SegmentStream segment_stream;
+  segment_stream.seek(kPastEndOfBufferPosition);
+  RefPtr<blink::SegmentReader> segment_reader = CreateSegmentReader();
+
+  segment_stream.SetReader(segment_reader);
+
+  ASSERT_TRUE(IsAtEnd(segment_stream));
+}
+
+TEST(SegmentStreamTest,
+     SetReaderShouldNotChangePositionWhenReaderSizeNotBigEnough) {
+  SegmentStream segment_stream;
+  segment_stream.seek(kPastEndOfBufferPosition);
+  RefPtr<blink::SegmentReader> segment_reader = CreateSegmentReader();
+
+  segment_stream.SetReader(segment_reader);
+
+  ASSERT_EQ(kPastEndOfBufferPosition, segment_stream.getPosition());
+}
+
+TEST(SegmentStreamTest, SetReaderShouldChangeLengthWhenReaderSizeNotBigEnough) {
+  SegmentStream segment_stream;
+  segment_stream.seek(kPastEndOfBufferPosition);
+  RefPtr<blink::SegmentReader> segment_reader = CreateSegmentReader();
+
+  segment_stream.SetReader(segment_reader);
+
+  ASSERT_TRUE(LengthIsAllocationSize(segment_stream));
+}
+
+TEST(SegmentStreamTest, SetReaderShouldSetIsAtEndWhenSetToNull) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+
+  segment_stream.SetReader(nullptr);
+  ASSERT_TRUE(IsAtEnd(segment_stream));
+}
+
+TEST(SegmentStreamTest, SetReaderShouldNotChangePositionWhenSetToNull) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  std::array<char, kInsideBufferPosition> read_buffer;
+  const size_t amount_read =
+      segment_stream.read(read_buffer.data(), kInsideBufferPosition);
+  ASSERT_EQ(kInsideBufferPosition, amount_read);
+  const size_t pre_nulled_position = segment_stream.getPosition();
+  ASSERT_EQ(amount_read, pre_nulled_position);
+
+  segment_stream.SetReader(nullptr);
+  ASSERT_EQ(pre_nulled_position, segment_stream.getPosition());
+}
+
+TEST(SegmentStreamTest, SetReaderShouldClearLengthWhenSetToNull) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  segment_stream.SetReader(nullptr);
+  ASSERT_TRUE(LengthIsZero(segment_stream));
+}
+
+TEST(SegmentStreamTest, ReadShouldConsumeBuffer) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  std::array<char, kInsideBufferPosition> read_buffer;
+  const size_t amount_read =
+      segment_stream.read(read_buffer.data(), kInsideBufferPosition);
+  ASSERT_EQ(kInsideBufferPosition, amount_read);
+}
+
+TEST(SegmentStreamTest, ReadShouldNotClear) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  std::array<char, kInsideBufferPosition> read_buffer;
+  segment_stream.read(read_buffer.data(), kInsideBufferPosition);
+  ASSERT_FALSE(IsCleared(segment_stream));
+}
+
+TEST(SegmentStreamTest, ReadShouldUpdateIsAtEnd) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+
+  std::array<char, kBufferAllocationSize> read_buffer;
+  const size_t amount_read =
+      segment_stream.read(read_buffer.data(), kBufferAllocationSize);
+  ASSERT_EQ(kBufferAllocationSize, amount_read);
+  ASSERT_TRUE(IsAtEnd(segment_stream));
+}
+
+TEST(SegmentStreamTest, ReadShouldUpdatePosition) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+
+  std::array<char, kInsideBufferPosition> read_buffer;
+  const size_t amount_read =
+      segment_stream.read(read_buffer.data(), kInsideBufferPosition);
+  ASSERT_EQ(amount_read, segment_stream.getPosition());
+  ASSERT_TRUE(PositionIsInsideBuffer(segment_stream));
+}
+
+TEST(SegmentStreamTest, ReadShouldNotChangeLength) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  const size_t length = segment_stream.getLength();
+  std::array<char, kInsideBufferPosition> read_buffer;
+  segment_stream.read(read_buffer.data(), kInsideBufferPosition);
+  ASSERT_EQ(segment_stream.getLength(), length);
+}
+
+TEST(SegmentStreamTest, ReadShouldNotConsumeBufferWhenCleared) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  std::array<char, kInsideBufferPosition> read_buffer;
+  const auto read_buffer_as_void_ptr =
+      reinterpret_cast<void*>(read_buffer.data());
+
+  segment_stream.SetReader(nullptr);
+  ASSERT_TRUE(IsCleared(segment_stream));
+
+  ASSERT_EQ(
+      0u, segment_stream.read(read_buffer_as_void_ptr, kInsideBufferPosition));
+}
+
+TEST(SegmentStreamTest, ReadShouldConsumeBufferWithoutGoingPastTheEnd) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  std::array<char, kPastEndOfBufferPosition> read_buffer;
+  const size_t amount_read =
+      segment_stream.read(read_buffer.data(), kPastEndOfBufferPosition);
+  ASSERT_EQ(amount_read, segment_stream.getLength());
+}
+
+TEST(SegmentStreamTest, ReadShouldSetIsAtEndWhenPastEnd) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+
+  std::array<char, kPastEndOfBufferPosition> read_buffer;
+  segment_stream.read(read_buffer.data(), kPastEndOfBufferPosition);
+  ASSERT_TRUE(IsAtEnd(segment_stream));
+}
+
+TEST(SegmentStreamTest, ReadShouldTruncatePositionWhenPastEnd) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+
+  std::array<char, kPastEndOfBufferPosition> read_buffer;
+  const size_t amount_read =
+      segment_stream.read(read_buffer.data(), kPastEndOfBufferPosition);
+  ASSERT_EQ(amount_read, segment_stream.getPosition());
+  ASSERT_TRUE(PositionIsAtEndOfBuffer(segment_stream));
+}
+
+TEST(SegmentStreamTest, PeekShouldConsumeBuffer) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  std::array<char, kInsideBufferPosition> peek_buffer;
+  const size_t amount_peeked =
+      segment_stream.peek(peek_buffer.data(), kInsideBufferPosition);
+  ASSERT_EQ(kInsideBufferPosition, amount_peeked);
+}
+
+TEST(SegmentStreamTest, PeekShouldNotClear) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  std::array<char, kInsideBufferPosition> peek_buffer;
+  segment_stream.peek(peek_buffer.data(), kInsideBufferPosition);
+  ASSERT_FALSE(IsCleared(segment_stream));
+}
+
+TEST(SegmentStreamTest, PeekShouldNotUpdateIsAtEnd) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+
+  std::array<char, kBufferAllocationSize> peek_buffer;
+  const size_t amount_peeked =
+      segment_stream.peek(peek_buffer.data(), kBufferAllocationSize);
+  ASSERT_EQ(kBufferAllocationSize, amount_peeked);
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+}
+
+TEST(SegmentStreamTest, PeekShouldNotUpdatePosition) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+
+  std::array<char, kInsideBufferPosition> peek_buffer;
+  segment_stream.peek(peek_buffer.data(), kInsideBufferPosition);
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+}
+
+TEST(SegmentStreamTest, PeekShouldNotChangeLength) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  const size_t length = segment_stream.getLength();
+  std::array<char, kInsideBufferPosition> peek_buffer;
+  segment_stream.peek(peek_buffer.data(), kInsideBufferPosition);
+  ASSERT_EQ(length, segment_stream.getLength());
+}
+
+TEST(SegmentStreamTest, PeekShouldNotConsumeBufferWhenCleared) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  std::array<char, kInsideBufferPosition> peek_buffer;
+  const auto peek_buffer_as_void_ptr =
+      reinterpret_cast<void*>(peek_buffer.data());
+
+  segment_stream.SetReader(nullptr);
+  ASSERT_TRUE(IsCleared(segment_stream));
+
+  ASSERT_EQ(
+      0u, segment_stream.peek(peek_buffer_as_void_ptr, kInsideBufferPosition));
+}
+
+TEST(SegmentStreamTest, PeekShouldConsumeBufferWithoutGoingPastTheEnd) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  std::array<char, kPastEndOfBufferPosition> peek_buffer;
+  const size_t amount_peeked =
+      segment_stream.peek(peek_buffer.data(), kPastEndOfBufferPosition);
+  ASSERT_EQ(amount_peeked, segment_stream.getLength());
+}
+
+TEST(SegmentStreamTest, PeekShouldNotSetIsAtEndWhenPastEnd) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+
+  std::array<char, kPastEndOfBufferPosition> peek_buffer;
+  segment_stream.peek(peek_buffer.data(), kPastEndOfBufferPosition);
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+}
+
+TEST(SegmentStreamTest, PeekShouldNotTruncatePositionWhenPastEnd) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+
+  std::array<char, kPastEndOfBufferPosition> peek_buffer;
+  segment_stream.peek(peek_buffer.data(), kPastEndOfBufferPosition);
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+}
+
+TEST(SegmentStreamTest, RewindShouldNotClear) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  std::array<char, kInsideBufferPosition> read_buffer;
+  segment_stream.read(read_buffer.data(), kInsideBufferPosition);
+  ASSERT_FALSE(IsCleared(segment_stream));
+
+  segment_stream.rewind();
+  ASSERT_FALSE(IsCleared(segment_stream));
+}
+
+TEST(SegmentStreamTest, RewindShouldNotSetAtEnd) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  std::array<char, kInsideBufferPosition> read_buffer;
+  segment_stream.read(read_buffer.data(), kInsideBufferPosition);
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+
+  segment_stream.rewind();
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+}
+
+TEST(SegmentStreamTest, RewindShouldResetPosition) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  std::array<char, kInsideBufferPosition> read_buffer;
+  segment_stream.read(read_buffer.data(), kInsideBufferPosition);
+  ASSERT_TRUE(PositionIsInsideBuffer(segment_stream));
+
+  segment_stream.rewind();
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+}
+
+TEST(SegmentStreamTest, RewindShouldNotChangeLength) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  std::array<char, kInsideBufferPosition> read_buffer;
+  segment_stream.read(read_buffer.data(), kInsideBufferPosition);
+  const size_t pre_rewind_length = segment_stream.getLength();
+
+  segment_stream.rewind();
+  ASSERT_EQ(pre_rewind_length, segment_stream.getLength());
+}
+
+TEST(SegmentStreamTest, HasPositionShouldBeSupported) {
+  blink::SegmentStream segment_stream;
+  ASSERT_TRUE(segment_stream.hasPosition());
+}
+
+TEST(SegmentStreamTest, SeekShouldNotSetIsCleared) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+  ASSERT_FALSE(IsCleared(segment_stream));
+
+  segment_stream.seek(kInsideBufferPosition);
+  ASSERT_FALSE(IsCleared(segment_stream));
+}
+
+TEST(SegmentStreamTest, SeekShouldNotSetIsAtEndWhenSeekingInsideTheBuffer) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+
+  segment_stream.seek(kInsideBufferPosition);
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+}
+
+TEST(SegmentStreamTest, SeekShouldSetIsAtEndWhenSeekingToTheEndOfTheBuffer) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+
+  segment_stream.seek(kBufferAllocationSize);
+  ASSERT_TRUE(IsAtEnd(segment_stream));
+}
+
+TEST(SegmentStreamTest, SeekShouldUpdatePosition) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+
+  segment_stream.seek(kInsideBufferPosition);
+  ASSERT_EQ(kInsideBufferPosition, segment_stream.getPosition());
+}
+
+TEST(SegmentStreamTest, SeekShouldNotTruncatePositionWhenPastEnd) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+
+  segment_stream.seek(kPastEndOfBufferPosition);
+  ASSERT_EQ(kPastEndOfBufferPosition, segment_stream.getPosition());
+}
+
+TEST(SegmentStreamTest, SeekShouldNotUpdateLength) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  segment_stream.seek(kInsideBufferPosition);
+  ASSERT_EQ(kBufferAllocationSize, segment_stream.getLength());
+}
+
+TEST(SegmentStreamTest, MoveShouldNotSetCleared) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  segment_stream.move(kInsideBufferPosition);
+  ASSERT_FALSE(IsCleared(segment_stream));
+}
+
+TEST(SegmentStreamTest, MoveShouldUpdatePosition) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  segment_stream.move(kInsideBufferPosition);
+  ASSERT_EQ(kInsideBufferPosition, segment_stream.getPosition());
+}
+
+TEST(SegmentStreamTest, MoveShouldNotTruncatePositionWhenPastEnd) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  segment_stream.move(kPastEndOfBufferPosition);
+  ASSERT_EQ(kPastEndOfBufferPosition, segment_stream.getPosition());
+}
+
+TEST(SegmentStreamTest, MoveShouldClampPositionToZeroWhenGoingNegative) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+
+  // Move the position off of 0
+  std::array<char, 1> read_buffer;
+  segment_stream.read(read_buffer.data(), 1);
+  ASSERT_FALSE(PositionIsZero(segment_stream));
+
+  segment_stream.move(-2);
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+}
+
+TEST(SegmentStreamTest, MoveShouldNotChangeLength) {
+  SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable();
+  ASSERT_TRUE(LengthIsAllocationSize(segment_stream));
+
+  segment_stream.move(kInsideBufferPosition);
+  ASSERT_TRUE(LengthIsAllocationSize(segment_stream));
+}
+
+TEST(SegmentStreamTest, HasLengthShouldBeSupported) {
+  blink::SegmentStream segment_stream;
+  ASSERT_TRUE(segment_stream.hasLength());
+}
+
+}  // namespace blink
+
+namespace {
+
+testing::AssertionResult IsCleared(const blink::SegmentStream& segment_stream) {
+  if (segment_stream.IsCleared())
+    return testing::AssertionSuccess();
+
+  return testing::AssertionFailure() << "SegmentStream is not clear";
+}
+
+testing::AssertionResult IsAtEnd(const blink::SegmentStream& segment_stream) {
+  if (segment_stream.isAtEnd())
+    return testing::AssertionSuccess();
+
+  return testing::AssertionFailure() << "SegmentStream is not at the end";
+}
+
+testing::AssertionResult PositionIsZero(
+    const blink::SegmentStream& segment_stream) {
+  if (segment_stream.getPosition() == 0ul)
+    return testing::AssertionSuccess();
+
+  return testing::AssertionFailure() << "SegmentStream position is not 0";
+}
+
+testing::AssertionResult PositionIsInsideBuffer(
+    const blink::SegmentStream& segment_stream) {
+  if (segment_stream.getPosition() == kInsideBufferPosition)
+    return testing::AssertionSuccess();
+
+  return testing::AssertionFailure()
+         << "SegmentStream position is not inside the buffer";
+}
+
+testing::AssertionResult PositionIsAtEndOfBuffer(
+    const blink::SegmentStream& segment_stream) {
+  if (segment_stream.getPosition() == kBufferAllocationSize)
+    return testing::AssertionSuccess();
+
+  return testing::AssertionFailure()
+         << "SegmentStream position is not at the end of the buffer";
+}
+
+testing::AssertionResult LengthIsZero(
+    const blink::SegmentStream& segment_stream) {
+  if (segment_stream.getLength() == 0ul)
+    return testing::AssertionSuccess();
+
+  return testing::AssertionFailure() << "SegmentStream length is not 0";
+}
+
+testing::AssertionResult LengthIsAllocationSize(
+    const blink::SegmentStream& segment_stream) {
+  if (segment_stream.getLength() == kBufferAllocationSize)
+    return testing::AssertionSuccess();
+
+  return testing::AssertionFailure()
+         << "SegmentStream length is not the allocation size";
+}
+
+blink::SegmentStream CreatePopulatedSegmentStreamReadable() {
+  blink::SegmentStream segment_stream;
+  segment_stream.SetReader(CreateSegmentReader());
+  return segment_stream;
+}
+
+RefPtr<blink::SegmentReader> CreateSegmentReader() {
+  std::array<char, kBufferAllocationSize> raw_buffer;
+
+  RefPtr<blink::SharedBuffer> shared_buffer =
+      blink::SharedBuffer::Create(raw_buffer.data(), kBufferAllocationSize);
+
+  RefPtr<blink::SegmentReader> segment_reader =
+      blink::SegmentReader::CreateFromSharedBuffer(std::move(shared_buffer));
+
+  return segment_reader;
+}
+
+}  // namespace