Fix 64 bit truncation warnings in renderer/core/fetch.

Use appropriate types in fetch code.

BUG=879657

Change-Id: I7f26d8a6651abafbb185193cc2670bcdb5eff05e
Reviewed-on: https://chromium-review.googlesource.com/c/1298329Reviewed-by: David Bokan <bokan@chromium.org>
Commit-Queue: Dave Tapuska <dtapuska@chromium.org>
Cr-Commit-Position: refs/heads/master@{#605685}

third_party/blink/renderer/core/fetch/body_stream_buffer.cc

@@ -22,6 +22,7 @@
 #include "third_party/blink/renderer/platform/network/encoded_form_data.h"
 #include "third_party/blink/renderer/platform/wtf/assertions.h"
 #include "third_party/blink/renderer/platform/wtf/functional.h"
+#include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
 
 namespace blink {
 
@@ -488,8 +489,9 @@ void BodyStreamBuffer::ProcessData() {
       return;
     DOMUint8Array* array = nullptr;
     if (result == BytesConsumer::Result::kOk) {
-      array = DOMUint8Array::Create(
-          reinterpret_cast<const unsigned char*>(buffer), available);
+      array =
+          DOMUint8Array::Create(reinterpret_cast<const unsigned char*>(buffer),
+                                SafeCast<uint32_t>(available));
       result = consumer_->EndRead(available);
     }
     switch (result) {

third_party/blink/renderer/core/fetch/bytes_consumer.cc

@@ -14,6 +14,7 @@
 #include "third_party/blink/renderer/platform/blob/blob_data.h"
 #include "third_party/blink/renderer/platform/heap/persistent.h"
 #include "third_party/blink/renderer/platform/wtf/functional.h"
+#include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
 #include "v8/include/v8.h"
 
 namespace blink {
@@ -62,7 +63,7 @@ class TeeHelper final : public GarbageCollectedFinalized<TeeHelper>,
       }
       Chunk* chunk = nullptr;
       if (result == Result::kOk) {
-        chunk = new Chunk(buffer, available);
+        chunk = new Chunk(buffer, SafeCast<wtf_size_t>(available));
         result = src_->EndRead(available);
       }
       switch (result) {
@@ -115,7 +116,7 @@ class TeeHelper final : public GarbageCollectedFinalized<TeeHelper>,
   using Result = BytesConsumer::Result;
   class Chunk final : public GarbageCollectedFinalized<Chunk> {
    public:
-    Chunk(const char* data, size_t size) {
+    Chunk(const char* data, wtf_size_t size) {
       buffer_.ReserveInitialCapacity(size);
       buffer_.Append(data, size);
       // Report buffer size to V8 so GC can be triggered appropriately.
@@ -127,7 +128,7 @@ class TeeHelper final : public GarbageCollectedFinalized<TeeHelper>,
           -static_cast<int64_t>(buffer_.size()));
     }
     const char* data() const { return buffer_.data(); }
-    size_t size() const { return buffer_.size(); }
+    wtf_size_t size() const { return buffer_.size(); }
 
     void Trace(blink::Visitor* visitor) {}
 

third_party/blink/renderer/core/fetch/bytes_consumer_test_util.cc

@@ -177,7 +177,8 @@ void BytesConsumerTestUtil::TwoPhaseReader::OnStateChange() {
       // We don't use |available| as-is to test cases where endRead
       // is called with a number smaller than |available|. We choose 3
       // because of the same reasons as Reader::onStateChange.
-      size_t read = std::min(static_cast<size_t>(3), available);
+      wtf_size_t read =
+          static_cast<wtf_size_t>(std::min(static_cast<size_t>(3), available));
       data_.Append(buffer, read);
       result = consumer_->EndRead(read);
     }

third_party/blink/renderer/core/fetch/bytes_consumer_test_util.h

@@ -93,10 +93,11 @@ class BytesConsumerTestUtil {
 
     explicit Command(Name name) : name_(name) {}
     Command(Name name, const Vector<char>& body) : name_(name), body_(body) {}
-    Command(Name name, const char* body, size_t size) : name_(name) {
+    Command(Name name, const char* body, wtf_size_t size) : name_(name) {
       body_.Append(body, size);
     }
-    Command(Name name, const char* body) : Command(name, body, strlen(body)) {}
+    Command(Name name, const char* body)
+        : Command(name, body, static_cast<wtf_size_t>(strlen(body))) {}
     Name GetName() const { return name_; }
     const Vector<char>& Body() const { return body_; }
 

third_party/blink/renderer/core/fetch/data_consumer_handle_test_util.h

@@ -347,10 +347,11 @@ class DataConsumerHandleTestUtil {
 
     Command(Name name) : name_(name) {}
     Command(Name name, const Vector<char>& body) : name_(name), body_(body) {}
-    Command(Name name, const char* body, size_t size) : name_(name) {
+    Command(Name name, const char* body, wtf_size_t size) : name_(name) {
       body_.Append(body, size);
     }
-    Command(Name name, const char* body) : Command(name, body, strlen(body)) {}
+    Command(Name name, const char* body)
+        : Command(name, body, static_cast<wtf_size_t>(strlen(body))) {}
     Name GetName() const { return name_; }
     const Vector<char>& Body() const { return body_; }
 

third_party/blink/renderer/core/fetch/fetch_data_loader.cc

@@ -16,6 +16,7 @@
 #include "third_party/blink/renderer/platform/network/http_names.h"
 #include "third_party/blink/renderer/platform/network/parsed_content_disposition.h"
 #include "third_party/blink/renderer/platform/wtf/functional.h"
+#include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
 #include "third_party/blink/renderer/platform/wtf/text/string_builder.h"
 #include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"
 #include "third_party/blink/renderer/platform/wtf/typed_arrays/array_buffer_builder.h"
@@ -140,7 +141,8 @@ class FetchDataLoaderAsArrayBuffer final : public FetchDataLoader,
         return;
       if (result == BytesConsumer::Result::kOk) {
         if (available > 0) {
-          unsigned bytes_appended = raw_data_->Append(buffer, available);
+          unsigned bytes_appended =
+              raw_data_->Append(buffer, SafeCast<wtf_size_t>(available));
           if (!bytes_appended) {
             auto unused = consumer_->EndRead(0);
             ALLOW_UNUSED_LOCAL(unused);
@@ -561,7 +563,7 @@ class FetchDataLoaderAsDataPipe final : public FetchDataLoader,
         if (available == 0) {
           result = consumer_->EndRead(0);
         } else {
-          uint32_t num_bytes = available;
+          uint32_t num_bytes = SafeCast<uint32_t>(available);
           MojoResult mojo_result = out_data_pipe_->WriteData(
               buffer, &num_bytes, MOJO_WRITE_DATA_FLAG_NONE);
           if (mojo_result == MOJO_RESULT_OK) {

third_party/blink/renderer/core/fetch/fetch_manager.cc

@@ -55,6 +55,7 @@
 #include "third_party/blink/renderer/platform/wtf/assertions.h"
 #include "third_party/blink/renderer/platform/wtf/functional.h"
 #include "third_party/blink/renderer/platform/wtf/hash_set.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"
 
@@ -274,7 +275,8 @@ class FetchManager::Loader final
         r = reader_->BeginRead(&buffer, WebDataConsumerHandle::kFlagNone,
                                &size);
         if (r == WebDataConsumerHandle::kOk) {
-          buffer_.Append(static_cast<const char*>(buffer), size);
+          buffer_.Append(static_cast<const char*>(buffer),
+                         SafeCast<wtf_size_t>(size));
           reader_->EndRead(size);
         }
       }

third_party/blink/renderer/core/fetch/fetch_response_data.cc

@@ -11,6 +11,7 @@
 #include "third_party/blink/renderer/platform/bindings/script_state.h"
 #include "third_party/blink/renderer/platform/loader/fetch/fetch_utils.h"
 #include "third_party/blink/renderer/platform/network/http_names.h"
+#include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
 
 using Type = network::mojom::FetchResponseType;
 
@@ -30,7 +31,7 @@ WebVector<WebString> HeaderSetToWebVector(const WebHTTPHeaderSet& headers) {
 
 Vector<String> HeaderSetToVector(const WebHTTPHeaderSet& headers) {
   Vector<String> result;
-  result.ReserveInitialCapacity(headers.size());
+  result.ReserveInitialCapacity(SafeCast<wtf_size_t>(headers.size()));
   // WebHTTPHeaderSet stores headers using Latin1 encoding.
   for (const auto& header : headers)
     result.push_back(String(header.data(), header.size()));

third_party/blink/renderer/core/fetch/form_data_bytes_consumer.cc

@@ -491,7 +491,7 @@ FormDataBytesConsumer::FormDataBytesConsumer(DOMArrayBuffer* buffer)
 FormDataBytesConsumer::FormDataBytesConsumer(DOMArrayBufferView* view)
     : FormDataBytesConsumer(view->BaseAddress(), view->byteLength()) {}
 
-FormDataBytesConsumer::FormDataBytesConsumer(const void* data, size_t size)
+FormDataBytesConsumer::FormDataBytesConsumer(const void* data, wtf_size_t size)
     : impl_(new SimpleFormDataBytesConsumer(
           EncodedFormData::Create(data, size))) {}
 

third_party/blink/renderer/core/fetch/form_data_bytes_consumer.h

@@ -23,7 +23,7 @@ class FormDataBytesConsumer final : public BytesConsumer {
   explicit CORE_EXPORT FormDataBytesConsumer(const String&);
   explicit CORE_EXPORT FormDataBytesConsumer(DOMArrayBuffer*);
   explicit CORE_EXPORT FormDataBytesConsumer(DOMArrayBufferView*);
-  CORE_EXPORT FormDataBytesConsumer(const void* data, size_t);
+  CORE_EXPORT FormDataBytesConsumer(const void* data, wtf_size_t);
   CORE_EXPORT FormDataBytesConsumer(ExecutionContext*,
                                     scoped_refptr<EncodedFormData>);
   CORE_EXPORT static FormDataBytesConsumer* CreateForTesting(

third_party/blink/renderer/core/fetch/headers.cc

@@ -40,7 +40,7 @@ class HeadersIterationSource final
 
  private:
   Vector<std::pair<String, String>> headers_;
-  size_t current_;
+  wtf_size_t current_;
 };
 
 }  // namespace
@@ -246,7 +246,7 @@ void Headers::FillWith(const Vector<Vector<String>>& object,
   //        TypeError.
   //     2. Append |header|’s first item/|header|’s second item to |headers|.
   //        Rethrow any exception."
-  for (size_t i = 0; i < object.size(); ++i) {
+  for (wtf_size_t i = 0; i < object.size(); ++i) {
     if (object[i].size() != 2) {
       exception_state.ThrowTypeError("Invalid value");
       return;

third_party/blink/renderer/core/fetch/multipart_parser.cc

@@ -7,6 +7,7 @@
 #include "third_party/blink/public/platform/platform.h"
 #include "third_party/blink/renderer/platform/network/http_names.h"
 #include "third_party/blink/renderer/platform/network/http_parsers.h"
+#include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
 
 #include <algorithm>
 #include <utility>
@@ -298,7 +299,10 @@ bool MultipartParser::ParseHeaderFields(const char** bytes_pointer,
                                         HTTPHeaderMap* header_fields) {
   // Combine the current bytes with buffered header bytes if needed.
   const char* header_bytes = *bytes_pointer;
-  size_t header_size = static_cast<size_t>(bytes_end - *bytes_pointer);
+  if ((bytes_end - *bytes_pointer) > std::numeric_limits<wtf_size_t>::max())
+    return false;
+
+  wtf_size_t header_size = static_cast<wtf_size_t>(bytes_end - *bytes_pointer);
   if (!buffered_header_bytes_.IsEmpty()) {
     buffered_header_bytes_.Append(header_bytes, header_size);
     header_bytes = buffered_header_bytes_.data();

third_party/blink/renderer/core/fetch/multipart_parser_test.cc

@@ -6,6 +6,7 @@
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/renderer/platform/network/http_names.h"
+#include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
 
 #include <string.h>
 #include <algorithm>
@@ -39,16 +40,16 @@ class MockMultipartParserClient final
     parts_.push_back(header_fields);
   }
   void PartDataInMultipartReceived(const char* bytes, size_t size) override {
-    parts_.back().data.Append(bytes, size);
+    parts_.back().data.Append(bytes, SafeCast<wtf_size_t>(size));
   }
   void PartDataInMultipartFullyReceived() override {
     parts_.back().data_fully_received = true;
   }
-  const Part& GetPart(size_t part_index) const {
+  const Part& GetPart(wtf_size_t part_index) const {
     EXPECT_LT(part_index, NumberOfParts());
     return part_index < NumberOfParts() ? parts_[part_index] : empty_part_;
   }
-  size_t NumberOfParts() const { return parts_.size(); }
+  wtf_size_t NumberOfParts() const { return parts_.size(); }
 
  private:
   Part empty_part_;