Fix potential bug in FastSharedBufferReader::getConsecutiveData

Source/platform/image-decoders/FastSharedBufferReaderTest.cpp

 /*
  * Copyright (C) 2015 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 20 matching lines @@
 #include "config.h"
 
 #include "platform/image-decoders/FastSharedBufferReader.h"
 
 #include <gtest/gtest.h>
 
 namespace blink {
 
 namespace {
 
+const unsigned kDefaultTestSize = 4 * SharedBuffer::kSegmentSize;
+
 void prepareReferenceData(char* buffer, size_t size)
 {
     for (size_t i = 0; i < size; ++i)
         buffer[i] = i;
 }
 
 } // namespace
 
 TEST(FastSharedBufferReaderTest, nonSequentialReads)
 {
-    // This is 4 times SharedBuffer's segment size.
-    char referenceData[16384];
+    char referenceData[kDefaultTestSize];
     prepareReferenceData(referenceData, sizeof(referenceData));
     RefPtr<SharedBuffer> data = SharedBuffer::create();
     data->append(referenceData, sizeof(referenceData));
 
     FastSharedBufferReader reader(data);
 
     // Read size is prime such there will be a segment-spanning
     // read eventually.
     char tempBuffer[17];
     for (size_t dataPosition = 0; dataPosition + sizeof(tempBuffer) < sizeof(referenceData); dataPosition += sizeof(tempBuffer)) {
         const char* block = reader.getConsecutiveData(
             dataPosition, sizeof(tempBuffer), tempBuffer);
         ASSERT_FALSE(memcmp(block, referenceData + dataPosition, sizeof(tempBuffer)));
     }
 }
 
 TEST(FastSharedBufferReaderTest, readBackwards)
 {
-    // This is 4 times SharedBuffer's segment size.
-    char referenceData[16384];
+    char referenceData[kDefaultTestSize];
     prepareReferenceData(referenceData, sizeof(referenceData));
     RefPtr<SharedBuffer> data = SharedBuffer::create();
     data->append(referenceData, sizeof(referenceData));
 
     FastSharedBufferReader reader(data);
 
     // Read size is prime such there will be a segment-spanning
     // read eventually.
     char tempBuffer[17];
     for (size_t dataOffset = sizeof(tempBuffer); dataOffset < sizeof(referenceData); dataOffset += sizeof(tempBuffer)) {
         const char* block = reader.getConsecutiveData(
             sizeof(referenceData) - dataOffset, sizeof(tempBuffer), tempBuffer);
         ASSERT_FALSE(memcmp(block, referenceData + sizeof(referenceData) - dataOffset, sizeof(tempBuffer)));
     }
 }
 
 TEST(FastSharedBufferReaderTest, byteByByte)
 {
-    // This is 4 times SharedBuffer's segment size.
-    char referenceData[16384];
+    char referenceData[kDefaultTestSize];
     prepareReferenceData(referenceData, sizeof(referenceData));
     RefPtr<SharedBuffer> data = SharedBuffer::create();
     data->append(referenceData, sizeof(referenceData));
 
     FastSharedBufferReader reader(data);
     for (size_t i = 0; i < sizeof(referenceData); ++i) {
         ASSERT_EQ(referenceData[i], reader.getOneByte(i));
     }
 }
 
+// Tests that a read starting from the one to last segment and goes to the end
+// of the last segment works correctly.

[Peter Kasting, 2015/03/25 19:53:11]

Nit: How about:

Tests that a read from inside the penultimate segment to the very end of the
buffer doesn't try to read off the end of the buffer.

+TEST(FastSharedBufferReaderTest, readAllOverlappingLastSegmentBoundary)
+{
+    const unsigned dataSize = 2 * SharedBuffer::kSegmentSize;
+    char referenceData[dataSize];
+    prepareReferenceData(referenceData, dataSize);
+    RefPtr<SharedBuffer> data = SharedBuffer::create();
+    data->append(referenceData, dataSize);
+
+    char buffer[dataSize];
+    FastSharedBufferReader reader(data);
+    reader.getConsecutiveData(0, dataSize, buffer);
+
+    ASSERT_FALSE(memcmp(buffer, referenceData, dataSize));
+}
+
 } // namespace blink