Reland "Fix Shared Buffer 64 bit truncations"

This is a reland of 44fcad8b

It was speculatively reverted for a build failure which turned out
to be something else.

Original change's description:
> Fix Shared Buffer 64 bit truncations
>
> Segments are always 4k and indexed by a WTF::Vector
>
> BUG=879657
>
> Change-Id: Ibe922cc6736fed0ba04e99aee0f04eb470f7fecf
> Reviewed-on: https://chromium-review.googlesource.com/c/1355884
> Reviewed-by: Kentaro Hara <haraken@chromium.org>
> Commit-Queue: Dave Tapuska <dtapuska@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#612659}

TBR=haraken@chromium.org

Bug: 879657
Change-Id: I60299fc856a6dc987c8f4460b2bf3a339bcb5837
Reviewed-on: https://chromium-review.googlesource.com/c/1357302Reviewed-by: Dave Tapuska <dtapuska@chromium.org>
Commit-Queue: Dave Tapuska <dtapuska@chromium.org>
Cr-Commit-Position: refs/heads/master@{#612727}

third_party/blink/renderer/platform/shared_buffer.cc

@@ -81,7 +81,7 @@ SharedBuffer::Iterator::Iterator(size_t offset, const SharedBuffer* buffer)
   Init(offset);
 }
 
-SharedBuffer::Iterator::Iterator(size_t segment_index,
+SharedBuffer::Iterator::Iterator(wtf_size_t segment_index,
                                  size_t offset,
                                  const SharedBuffer* buffer)
     : index_(segment_index + 1), buffer_(buffer) {
@@ -111,13 +111,13 @@ void SharedBuffer::Iterator::Init(size_t offset) {
 
 SharedBuffer::SharedBuffer() : size_(0) {}
 
-SharedBuffer::SharedBuffer(size_t size) : size_(size), buffer_(size) {}
+SharedBuffer::SharedBuffer(wtf_size_t size) : size_(size), buffer_(size) {}
 
-SharedBuffer::SharedBuffer(const char* data, size_t size) : size_(size) {
+SharedBuffer::SharedBuffer(const char* data, wtf_size_t size) : size_(size) {
   buffer_.Append(data, size);
 }
 
-SharedBuffer::SharedBuffer(const unsigned char* data, size_t size)
+SharedBuffer::SharedBuffer(const unsigned char* data, wtf_size_t size)
     : SharedBuffer(reinterpret_cast<const char*>(data), size) {}
 
 SharedBuffer::~SharedBuffer() = default;
@@ -149,7 +149,7 @@ void SharedBuffer::AppendInternal(const char* data, size_t length) {
 
   if (size_ <= kSegmentSize) {
     // No need to use segments for small resource data.
-    buffer_.Append(data, length);
+    buffer_.Append(data, static_cast<wtf_size_t>(length));
     return;
   }
 
@@ -181,9 +181,9 @@ SharedBuffer::Iterator SharedBuffer::end() const {
 }
 
 void SharedBuffer::MergeSegmentsIntoBuffer() {
-  size_t bytes_left = size_ - buffer_.size();
+  wtf_size_t bytes_left = size_ - buffer_.size();
   for (const auto& segment : segments_) {
-    size_t bytes_to_copy = std::min<size_t>(bytes_left, kSegmentSize);
+    wtf_size_t bytes_to_copy = std::min<wtf_size_t>(bytes_left, kSegmentSize);
     buffer_.Append(segment.get(), bytes_to_copy);
     bytes_left -= bytes_to_copy;
   }
@@ -198,8 +198,9 @@ SharedBuffer::Iterator SharedBuffer::GetIteratorAtInternal(
   if (position < buffer_.size())
     return Iterator(position, this);
 
-  return Iterator(SegmentIndex(position - buffer_.size()),
-                  OffsetInSegment(position - buffer_.size()), this);
+  return Iterator(
+      SafeCast<uint32_t>(SegmentIndex(position - buffer_.size())),
+      SafeCast<uint32_t>(OffsetInSegment(position - buffer_.size())), this);
 }
 
 bool SharedBuffer::GetBytesInternal(void* dest, size_t dest_size) const {
@@ -261,9 +262,9 @@ SharedBuffer::DeprecatedFlatData::DeprecatedFlatData(
   }
 
   // Merge all segments.
-  flat_buffer_.ReserveInitialCapacity(buffer_->size());
+  flat_buffer_.ReserveInitialCapacity(SafeCast<wtf_size_t>(buffer_->size()));
   for (const auto& span : *buffer_)
-    flat_buffer_.Append(span.data(), span.size());
+    flat_buffer_.Append(span.data(), static_cast<wtf_size_t>(span.size()));
 
   data_ = flat_buffer_.data();
 }

third_party/blink/renderer/platform/shared_buffer.h

@@ -35,6 +35,7 @@
 #include "third_party/blink/renderer/platform/platform_export.h"
 #include "third_party/blink/renderer/platform/wtf/forward.h"
 #include "third_party/blink/renderer/platform/wtf/ref_counted.h"
+#include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
 #include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"
 #include "third_party/blink/renderer/platform/wtf/vector.h"
 
@@ -83,14 +84,16 @@ class PLATFORM_EXPORT SharedBuffer : public RefCounted<SharedBuffer> {
     // for the consecutive part
     Iterator(size_t offset, const SharedBuffer* buffer);
     // for the rest
-    Iterator(size_t segment_index, size_t offset, const SharedBuffer* buffer);
+    Iterator(wtf_size_t segment_index,
+             size_t offset,
+             const SharedBuffer* buffer);
 
     void Init(size_t offset);
     bool IsEnd() const { return index_ == buffer_->segments_.size() + 1; }
 
     // It represents |buffer_->buffer| if |index_| is 0, and
     // |buffer_->segments[index_ - 1]| otherwise.
-    size_t index_;
+    wtf_size_t index_;
     base::span<const char> value_;
     const SharedBuffer* buffer_;
   };
@@ -203,9 +206,9 @@ class PLATFORM_EXPORT SharedBuffer : public RefCounted<SharedBuffer> {
   class Segment;
 
   SharedBuffer();
-  explicit SharedBuffer(size_t);
-  SharedBuffer(const char*, size_t);
-  SharedBuffer(const unsigned char*, size_t);
+  explicit SharedBuffer(wtf_size_t);
+  SharedBuffer(const char*, wtf_size_t);
+  SharedBuffer(const unsigned char*, wtf_size_t);
 
   // See SharedBuffer::data().
   void MergeSegmentsIntoBuffer();
@@ -227,10 +230,10 @@ class PLATFORM_EXPORT SharedBuffer : public RefCounted<SharedBuffer> {
 template <>
 inline Vector<char> SharedBuffer::CopyAs() const {
   Vector<char> buffer;
-  buffer.ReserveInitialCapacity(size_);
+  buffer.ReserveInitialCapacity(SafeCast<wtf_size_t>(size_));
 
   for (const auto& span : *this)
-    buffer.Append(span.data(), span.size());
+    buffer.Append(span.data(), static_cast<wtf_size_t>(span.size()));
 
   DCHECK_EQ(buffer.size(), size_);
   return buffer;

third_party/blink/renderer/platform/shared_buffer_chunk_reader.cc

@@ -31,6 +31,7 @@
 #include "third_party/blink/renderer/platform/shared_buffer_chunk_reader.h"
 
 #include "third_party/blink/renderer/platform/shared_buffer.h"
+#include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
 
 namespace blink {
 
@@ -65,7 +66,7 @@ void SharedBufferChunkReader::SetSeparator(const Vector<char>& separator) {
 
 void SharedBufferChunkReader::SetSeparator(const char* separator) {
   separator_.clear();
-  separator_.Append(separator, strlen(separator));
+  separator_.Append(separator, SafeCast<wtf_size_t>(strlen(separator)));
 }
 
 bool SharedBufferChunkReader::NextChunk(Vector<char>& chunk,
@@ -108,7 +109,7 @@ bool SharedBufferChunkReader::NextChunk(Vector<char>& chunk,
       return !chunk.IsEmpty();
     }
     segment_ = it->data();
-    segment_length_ = it->size();
+    segment_length_ = SafeCast<uint32_t>(it->size());
   }
   NOTREACHED();
   return false;
@@ -125,15 +126,15 @@ String SharedBufferChunkReader::NextChunkAsUTF8StringWithLatin1Fallback(
              : g_empty_string;
 }
 
-size_t SharedBufferChunkReader::Peek(Vector<char>& data,
-                                     size_t requested_size) {
+uint32_t SharedBufferChunkReader::Peek(Vector<char>& data,
+                                       uint32_t requested_size) {
   data.clear();
   if (requested_size <= segment_length_ - segment_index_) {
     data.Append(segment_ + segment_index_, requested_size);
     return requested_size;
   }
 
-  size_t read_bytes_count = segment_length_ - segment_index_;
+  uint32_t read_bytes_count = segment_length_ - segment_index_;
   data.Append(segment_ + segment_index_, read_bytes_count);
 
   for (auto it = buffer_->GetIteratorAt(buffer_position_ + segment_length_);
@@ -143,7 +144,7 @@ size_t SharedBufferChunkReader::Peek(Vector<char>& data,
       read_bytes_count += (requested_size - read_bytes_count);
       break;
     }
-    data.Append(it->data(), it->size());
+    data.Append(it->data(), SafeCast<wtf_size_t>(it->size()));
     read_bytes_count += it->size();
   }
   return read_bytes_count;

third_party/blink/renderer/platform/shared_buffer_chunk_reader.h

@@ -65,17 +65,17 @@ class PLATFORM_EXPORT SharedBufferChunkReader final {
   // the buffer position.
   // Returns the number of bytes read. That number might be less than the
   // specified size if the end of the buffer was reached.
-  size_t Peek(Vector<char>&, size_t);
+  uint32_t Peek(Vector<char>&, uint32_t);
 
  private:
   scoped_refptr<const SharedBuffer> buffer_;
   size_t buffer_position_;
   const char* segment_;
-  size_t segment_length_;
-  size_t segment_index_;
+  uint32_t segment_length_;
+  uint32_t segment_index_;
   bool reached_end_of_file_;
   Vector<char> separator_;
-  size_t separator_index_;
+  uint32_t separator_index_;
 };
 
 }  // namespace blink