Fix 64 bit truncation errors in platform/loader

Use appropriate types in loader code.

BUG=879657

Change-Id: I43da64c50b4dcdb2cd47a4b6ed45ecd7d87d15fb
Reviewed-on: https://chromium-review.googlesource.com/c/1330352Reviewed-by: Nate Chapin <japhet@chromium.org>
Commit-Queue: Dave Tapuska <dtapuska@chromium.org>
Cr-Commit-Position: refs/heads/master@{#610454}

third_party/blink/renderer/core/loader/frame_fetch_context.cc

@@ -670,7 +670,7 @@ void FrameFetchContext::DispatchDidReceiveResponse(
 
 void FrameFetchContext::DispatchDidReceiveData(unsigned long identifier,
                                                const char* data,
-                                               int data_length) {
+                                               size_t data_length) {
   if (IsDetached())
     return;
 
@@ -679,8 +679,9 @@ void FrameFetchContext::DispatchDidReceiveData(unsigned long identifier,
                         MasterDocumentLoader(), data, data_length);
 }
 
-void FrameFetchContext::DispatchDidReceiveEncodedData(unsigned long identifier,
-                                                      int encoded_data_length) {
+void FrameFetchContext::DispatchDidReceiveEncodedData(
+    unsigned long identifier,
+    size_t encoded_data_length) {
   if (IsDetached())
     return;
   probe::didReceiveEncodedDataLength(GetFrame()->GetDocument(),

third_party/blink/renderer/core/loader/frame_fetch_context.h

@@ -114,9 +114,9 @@ class CORE_EXPORT FrameFetchContext final : public BaseFetchContext {
                                   ResourceResponseType) override;
   void DispatchDidReceiveData(unsigned long identifier,
                               const char* data,
-                              int data_length) override;
+                              size_t data_length) override;
   void DispatchDidReceiveEncodedData(unsigned long identifier,
-                                     int encoded_data_length) override;
+                                     size_t encoded_data_length) override;
   void DispatchDidDownloadToBlob(unsigned long identifier,
                                  BlobDataHandle*) override;
   void DispatchDidFinishLoading(unsigned long identifier,

third_party/blink/renderer/core/loader/worker_fetch_context.cc

@@ -308,13 +308,13 @@ void WorkerFetchContext::DispatchDidReceiveResponse(
 
 void WorkerFetchContext::DispatchDidReceiveData(unsigned long identifier,
                                                 const char* data,
-                                                int data_length) {
+                                                size_t data_length) {
   probe::didReceiveData(global_scope_, identifier, nullptr, data, data_length);
 }
 
 void WorkerFetchContext::DispatchDidReceiveEncodedData(
     unsigned long identifier,
-    int encoded_data_length) {
+    size_t encoded_data_length) {
   probe::didReceiveEncodedDataLength(global_scope_, nullptr, identifier,
                                      encoded_data_length);
 }

third_party/blink/renderer/core/loader/worker_fetch_context.h

@@ -94,9 +94,9 @@ class WorkerFetchContext final : public BaseFetchContext {
                                   ResourceResponseType) override;
   void DispatchDidReceiveData(unsigned long identifier,
                               const char* data,
-                              int dataLength) override;
+                              size_t data_length) override;
   void DispatchDidReceiveEncodedData(unsigned long identifier,
-                                     int encoded_data_length) override;
+                                     size_t encoded_data_length) override;
   void DispatchDidFinishLoading(unsigned long identifier,
                                 TimeTicks finish_time,
                                 int64_t encoded_data_length,

third_party/blink/renderer/platform/loader/cors/cors_error_string.cc

@@ -63,7 +63,7 @@ String GetErrorString(const network::CorsErrorStatus& status,
 
   using CorsError = network::mojom::CorsError;
   const StringView hint(status.failed_parameter.data(),
-                        status.failed_parameter.size());
+                        SafeCast<wtf_size_t>(status.failed_parameter.size()));
 
   const char* resource_kind_raw =
       Resource::ResourceTypeToString(resource_type, initiator_name);

third_party/blink/renderer/platform/loader/fetch/buffering_data_pipe_writer.h

@@ -36,7 +36,7 @@ class PLATFORM_EXPORT BufferingDataPipeWriter {
   mojo::ScopedDataPipeProducerHandle handle_;
   mojo::SimpleWatcher watcher_;
   Deque<Vector<char>> buffer_;
-  size_t front_written_size_ = 0;
+  wtf_size_t front_written_size_ = 0;
   bool waiting_ = false;
   bool finished_ = false;
 };

third_party/blink/renderer/platform/loader/fetch/buffering_data_pipe_writer_test.cc

@@ -31,21 +31,21 @@ TEST(BufferingDataPipeWriterTest, WriteMany) {
   MojoResult result = mojo::CreateDataPipe(&options, &producer, &consumer);
   ASSERT_EQ(MOJO_RESULT_OK, result);
 
-  constexpr size_t total = kCapacity * 3;
-  constexpr size_t writing_chunk_size = 5;
-  constexpr size_t reading_chunk_size = 7;
+  constexpr wtf_size_t total = kCapacity * 3;
+  constexpr wtf_size_t writing_chunk_size = 5;
+  constexpr wtf_size_t reading_chunk_size = 7;
   Vector<char> input, output;
 
-  for (size_t i = 0; i < total; ++i)
+  for (wtf_size_t i = 0; i < total; ++i)
     input.push_back(static_cast<char>(engine() % 26 + 'A'));
 
   auto writer = std::make_unique<BufferingDataPipeWriter>(
       std::move(producer), platform->test_task_runner().get());
 
-  for (size_t i = 0; i < total;) {
+  for (wtf_size_t i = 0; i < total;) {
     // We use a temporary buffer to check that the buffer is copied immediately.
     char temp[writing_chunk_size] = {};
-    size_t size = std::min(total - i, writing_chunk_size);
+    wtf_size_t size = std::min(total - i, writing_chunk_size);
 
     std::copy(input.data() + i, input.data() + i + size, temp);
     ASSERT_TRUE(writer->Write(temp, size));

third_party/blink/renderer/platform/loader/fetch/cached_metadata.cc

@@ -12,7 +12,8 @@ scoped_refptr<CachedMetadata> CachedMetadata::CreateFromSerializedData(
     const char* data,
     size_t size) {
   // Ensure the data is big enough, otherwise discard the data.
-  if (size < kCachedMetaDataStart) {
+  if (size < kCachedMetaDataStart ||
+      size > std::numeric_limits<wtf_size_t>::max()) {
     return nullptr;
   }
   // Ensure the marker matches, otherwise discard the data.
@@ -20,10 +21,10 @@ scoped_refptr<CachedMetadata> CachedMetadata::CreateFromSerializedData(
       CachedMetadataHandler::kSingleEntry) {
     return nullptr;
   }
-  return base::AdoptRef(new CachedMetadata(data, size));
+  return base::AdoptRef(
+      new CachedMetadata(data, static_cast<wtf_size_t>(size)));
 }
-
-CachedMetadata::CachedMetadata(const char* data, size_t size) {
+CachedMetadata::CachedMetadata(const char* data, wtf_size_t size) {
   // Serialized metadata should have non-empty data.
   DCHECK_GT(size, kCachedMetaDataStart);
   DCHECK(data);
@@ -37,7 +38,7 @@ CachedMetadata::CachedMetadata(const char* data, size_t size) {
 
 CachedMetadata::CachedMetadata(uint32_t data_type_id,
                                const char* data,
-                               size_t size) {
+                               wtf_size_t size) {
   // Don't allow an ID of 0, it is used internally to indicate errors.
   DCHECK(data_type_id);
   DCHECK(data);

third_party/blink/renderer/platform/loader/fetch/cached_metadata.h

@@ -36,6 +36,7 @@
 #include "third_party/blink/renderer/platform/platform_export.h"
 #include "third_party/blink/renderer/platform/wtf/assertions.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/vector.h"
 
 namespace blink {
@@ -54,7 +55,8 @@ class PLATFORM_EXPORT CachedMetadata : public RefCounted<CachedMetadata> {
   static scoped_refptr<CachedMetadata> Create(uint32_t data_type_id,
                                               const char* data,
                                               size_t size) {
-    return base::AdoptRef(new CachedMetadata(data_type_id, data, size));
+    return base::AdoptRef(
+        new CachedMetadata(data_type_id, data, SafeCast<wtf_size_t>(size)));
   }
 
   static scoped_refptr<CachedMetadata> CreateFromSerializedData(
@@ -76,14 +78,14 @@ class PLATFORM_EXPORT CachedMetadata : public RefCounted<CachedMetadata> {
     return serialized_data_.data() + kCachedMetaDataStart;
   }
 
-  size_t size() const {
+  uint32_t size() const {
     DCHECK_GE(serialized_data_.size(), kCachedMetaDataStart);
     return serialized_data_.size() - kCachedMetaDataStart;
   }
 
  private:
-  CachedMetadata(const char* data, size_t);
-  CachedMetadata(uint32_t data_type_id, const char* data, size_t);
+  CachedMetadata(const char* data, wtf_size_t);
+  CachedMetadata(uint32_t data_type_id, const char* data, wtf_size_t);
 
   // Since the serialization format supports random access, storing it in
   // serialized form avoids need for a copy during serialization.

third_party/blink/renderer/platform/loader/fetch/fetch_context.cc

@@ -118,9 +118,9 @@ void FetchContext::DispatchDidReceiveResponse(
     Resource*,
     ResourceResponseType) {}
 
-void FetchContext::DispatchDidReceiveData(unsigned long, const char*, int) {}
+void FetchContext::DispatchDidReceiveData(unsigned long, const char*, size_t) {}
 
-void FetchContext::DispatchDidReceiveEncodedData(unsigned long, int) {}
+void FetchContext::DispatchDidReceiveEncodedData(unsigned long, size_t) {}
 
 void FetchContext::DispatchDidDownloadToBlob(unsigned long identifier,
                                              BlobDataHandle*) {}

third_party/blink/renderer/platform/loader/fetch/fetch_context.h

@@ -157,9 +157,9 @@ class PLATFORM_EXPORT FetchContext
       ResourceResponseType);
   virtual void DispatchDidReceiveData(unsigned long identifier,
                                       const char* data,
-                                      int data_length);
+                                      size_t data_length);
   virtual void DispatchDidReceiveEncodedData(unsigned long identifier,
-                                             int encoded_data_length);
+                                             size_t encoded_data_length);
   virtual void DispatchDidDownloadToBlob(unsigned long identifier,
                                          BlobDataHandle*);
   virtual void DispatchDidFinishLoading(unsigned long identifier,

third_party/blink/renderer/platform/loader/fetch/raw_resource.cc

@@ -38,6 +38,7 @@
 #include "third_party/blink/renderer/platform/network/http_names.h"
 #include "third_party/blink/renderer/platform/scheduler/public/thread.h"
 #include "third_party/blink/renderer/platform/scheduler/public/thread_scheduler.h"
+#include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
 
 namespace blink {
 
@@ -139,7 +140,7 @@ RawResource::RawResource(const ResourceRequest& resource_request,
 void RawResource::AppendData(const char* data, size_t length) {
   if (data_pipe_writer_) {
     DCHECK_EQ(kDoNotBufferData, GetDataBufferingPolicy());
-    data_pipe_writer_->Write(data, length);
+    data_pipe_writer_->Write(data, SafeCast<uint32_t>(length));
   } else {
     Resource::AppendData(data, length);
   }
@@ -340,7 +341,7 @@ bool RawResource::MatchPreload(const FetchParameters& params,
 
   if (Data()) {
     for (const auto& span : *Data())
-      data_pipe_writer_->Write(span.data(), span.size());
+      data_pipe_writer_->Write(span.data(), SafeCast<uint32_t>(span.size()));
   }
   SetDataBufferingPolicy(kDoNotBufferData);
 

third_party/blink/renderer/platform/loader/fetch/raw_resource_test.cc

@@ -45,6 +45,7 @@
 #include "third_party/blink/renderer/platform/testing/testing_platform_support_with_mock_scheduler.h"
 #include "third_party/blink/renderer/platform/testing/unit_test_helpers.h"
 #include "third_party/blink/renderer/platform/weborigin/security_origin.h"
+#include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
 
 namespace blink {
 
@@ -92,7 +93,7 @@ class DummyClient final : public GarbageCollectedFinalized<DummyClient>,
   String DebugName() const override { return "DummyClient"; }
 
   void DataReceived(Resource*, const char* data, size_t length) override {
-    data_.Append(data, length);
+    data_.Append(data, SafeCast<wtf_size_t>(length));
   }
 
   bool RedirectReceived(Resource*,

third_party/blink/renderer/platform/loader/fetch/resource.cc

@@ -975,7 +975,7 @@ void Resource::OnMemoryDump(WebMemoryDumpLevelOfDetail level_of_detail,
               WTF::CodePointCompareLessThan);
 
     StringBuilder builder;
-    for (size_t i = 0;
+    for (wtf_size_t i = 0;
          i < client_names.size() && i < kMaxResourceClientToShowInMemoryInfra;
          ++i) {
       if (i > 0)

third_party/blink/renderer/platform/loader/fetch/resource.h

@@ -358,10 +358,10 @@ class PLATFORM_EXPORT Resource : public GarbageCollectedFinalized<Resource>,
   void SetEncodedDataLength(int64_t value) {
     response_.SetEncodedDataLength(value);
   }
-  void SetEncodedBodyLength(int value) {
+  void SetEncodedBodyLength(int64_t value) {
     response_.SetEncodedBodyLength(value);
   }
-  void SetDecodedBodyLength(int value) {
+  void SetDecodedBodyLength(int64_t value) {
     response_.SetDecodedBodyLength(value);
   }
 

third_party/blink/renderer/platform/loader/fetch/resource_client_walker.h

@@ -46,7 +46,7 @@ class ResourceClientWalker {
   }
 
   T* Next() {
-    size_t size = client_vector_.size();
+    wtf_size_t size = client_vector_.size();
     while (index_ < size) {
       ResourceClient* next = client_vector_[index_++];
       DCHECK(next);
@@ -60,7 +60,7 @@ class ResourceClientWalker {
  private:
   const HeapHashCountedSet<WeakMember<ResourceClient>>& client_set_;
   HeapVector<Member<ResourceClient>> client_vector_;
-  size_t index_ = 0;
+  wtf_size_t index_ = 0;
 };
 
 }  // namespace blink

third_party/blink/renderer/platform/loader/fetch/resource_fetcher.cc

@@ -114,7 +114,7 @@ constexpr base::TimeDelta kKeepaliveLoadersTimeout =
 void AddRedirectsToTimingInfo(Resource* resource, ResourceTimingInfo* info) {
   // Store redirect responses that were packed inside the final response.
   const auto& responses = resource->GetResponse().RedirectResponses();
-  for (size_t i = 0; i < responses.size(); ++i) {
+  for (wtf_size_t i = 0; i < responses.size(); ++i) {
     const KURL& new_url = i + 1 < responses.size()
                               ? KURL(responses[i + 1].Url())
                               : resource->GetResourceRequest().Url();

third_party/blink/renderer/platform/loader/fetch/resource_load_scheduler.cc

@@ -6,6 +6,7 @@
 
 #include "base/metrics/field_trial_params.h"
 #include "base/metrics/histogram.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/strings/string_number_conversions.h"
 #include "third_party/blink/public/platform/platform.h"
 #include "third_party/blink/renderer/platform/histogram.h"
@@ -106,7 +107,7 @@ size_t GetOutstandingThrottledLimit(FetchContext* context) {
 }
 
 int TakeWholeKilobytes(int64_t& bytes) {
-  int kilobytes = bytes / 1024;
+  int kilobytes = base::saturated_cast<int>(bytes / 1024);
   bytes %= 1024;
   return kilobytes;
 }
@@ -140,13 +141,13 @@ class ResourceLoadScheduler::TrafficMonitor {
   scheduler::SchedulingLifecycleState current_state_ =
       scheduler::SchedulingLifecycleState::kStopped;
 
-  size_t total_throttled_request_count_ = 0;
+  uint32_t total_throttled_request_count_ = 0;
   size_t total_throttled_traffic_bytes_ = 0;
   size_t total_throttled_decoded_bytes_ = 0;
-  size_t total_not_throttled_request_count_ = 0;
+  uint32_t total_not_throttled_request_count_ = 0;
   size_t total_not_throttled_traffic_bytes_ = 0;
   size_t total_not_throttled_decoded_bytes_ = 0;
-  size_t throttling_state_change_count_ = 0;
+  uint32_t throttling_state_change_count_ = 0;
   bool report_all_is_called_ = false;
 
   scheduler::AggregatedMetricReporter<scheduler::FrameStatus, int64_t>
@@ -311,26 +312,34 @@ void ResourceLoadScheduler::TrafficMonitor::ReportAll() {
     main_frame_total_not_throttled_request_count.Count(
         total_not_throttled_request_count_);
     main_frame_total_throttled_traffic_bytes.Count(
-        total_throttled_traffic_bytes_);
+        base::saturated_cast<base::Histogram::Sample>(
+            total_throttled_traffic_bytes_));
     main_frame_total_not_throttled_traffic_bytes.Count(
-        total_not_throttled_traffic_bytes_);
+        base::saturated_cast<base::Histogram::Sample>(
+            total_not_throttled_traffic_bytes_));
     main_frame_total_throttled_decoded_bytes.Count(
-        total_throttled_decoded_bytes_);
+        base::saturated_cast<base::Histogram::Sample>(
+            total_throttled_decoded_bytes_));
     main_frame_total_not_throttled_decoded_bytes.Count(
-        total_not_throttled_decoded_bytes_);
+        base::saturated_cast<base::Histogram::Sample>(
+            total_not_throttled_decoded_bytes_));
   } else {
     sub_frame_total_throttled_request_count.Count(
         total_throttled_request_count_);
     sub_frame_total_not_throttled_request_count.Count(
         total_not_throttled_request_count_);
     sub_frame_total_throttled_traffic_bytes.Count(
-        total_throttled_traffic_bytes_);
+        base::saturated_cast<base::Histogram::Sample>(
+            total_throttled_traffic_bytes_));
     sub_frame_total_not_throttled_traffic_bytes.Count(
-        total_not_throttled_traffic_bytes_);
+        base::saturated_cast<base::Histogram::Sample>(
+            total_not_throttled_traffic_bytes_));
     sub_frame_total_throttled_decoded_bytes.Count(
-        total_throttled_decoded_bytes_);
+        base::saturated_cast<base::Histogram::Sample>(
+            total_throttled_decoded_bytes_));
     sub_frame_total_not_throttled_decoded_bytes.Count(
-        total_not_throttled_decoded_bytes_);
+        base::saturated_cast<base::Histogram::Sample>(
+            total_not_throttled_decoded_bytes_));
   }
 
   throttling_state_change_count.Count(throttling_state_change_count_);

third_party/blink/renderer/platform/loader/fetch/resource_loader.cc

@@ -61,6 +61,7 @@
 #include "third_party/blink/renderer/platform/weborigin/scheme_registry.h"
 #include "third_party/blink/renderer/platform/weborigin/security_violation_reporting_policy.h"
 #include "third_party/blink/renderer/platform/wtf/assertions.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/time.h"
 
@@ -941,8 +942,8 @@ void ResourceLoader::DidStartLoadingResponseBody(
   mojom::blink::BlobRegistry* blob_registry = BlobDataHandle::GetBlobRegistry();
   blob_registry->RegisterFromStream(
       mime_type.IsNull() ? g_empty_string : mime_type.LowerASCII(), "",
-      std::max(0ll, response.ExpectedContentLength()), std::move(body),
-      std::move(progress_client_ptr),
+      std::max(static_cast<int64_t>(0), response.ExpectedContentLength()),
+      std::move(body), std::move(progress_client_ptr),
       WTF::Bind(&ResourceLoader::FinishedCreatingBlob,
                 WrapWeakPersistent(this)));
 }
@@ -1094,7 +1095,7 @@ void ResourceLoader::RequestSynchronously(const ResourceRequest& request) {
   if (data_out.size()) {
     data_out.ForEachSegment([this](const char* segment, size_t segment_size,
                                    size_t segment_offset) {
-      DidReceiveData(segment, segment_size);
+      DidReceiveData(segment, SafeCast<int>(segment_size));
       return true;
     });
   }
@@ -1171,7 +1172,7 @@ void ResourceLoader::OnProgress(uint64_t delta) {
     return;
 
   Context().DispatchDidReceiveData(resource_->Identifier(), nullptr, delta);
-  resource_->DidDownloadData(delta);
+  resource_->DidDownloadData(SafeCast<int>(delta));
 }
 
 void ResourceLoader::FinishedCreatingBlob(

third_party/blink/renderer/platform/loader/fetch/resource_response.cc

@@ -112,12 +112,12 @@ void ResourceResponse::SetMimeType(const AtomicString& mime_type) {
   mime_type_ = mime_type;
 }
 
-long long ResourceResponse::ExpectedContentLength() const {
+int64_t ResourceResponse::ExpectedContentLength() const {
   return expected_content_length_;
 }
 
 void ResourceResponse::SetExpectedContentLength(
-    long long expected_content_length) {
+    int64_t expected_content_length) {
   is_null_ = false;
 
   // FIXME: Content length is determined by HTTP Content-Length header. We
@@ -343,7 +343,7 @@ double ResourceResponse::LastModified() const {
 bool ResourceResponse::IsAttachment() const {
   static const char kAttachmentString[] = "attachment";
   String value = http_header_fields_.Get(http_names::kContentDisposition);
-  size_t loc = value.find(';');
+  wtf_size_t loc = value.find(';');
   if (loc != kNotFound)
     value = value.Left(loc);
   value = value.StripWhiteSpace();
@@ -419,15 +419,15 @@ AtomicString ResourceResponse::ConnectionInfoString() const {
       connection_info_string.length());
 }
 
-void ResourceResponse::SetEncodedDataLength(long long value) {
+void ResourceResponse::SetEncodedDataLength(int64_t value) {
   encoded_data_length_ = value;
 }
 
-void ResourceResponse::SetEncodedBodyLength(long long value) {
+void ResourceResponse::SetEncodedBodyLength(int64_t value) {
   encoded_body_length_ = value;
 }
 
-void ResourceResponse::SetDecodedBodyLength(long long value) {
+void ResourceResponse::SetDecodedBodyLength(int64_t value) {
   decoded_body_length_ = value;
 }
 

third_party/blink/renderer/platform/loader/fetch/resource_response.h

@@ -172,8 +172,8 @@ class PLATFORM_EXPORT ResourceResponse final {
   const AtomicString& MimeType() const;
   void SetMimeType(const AtomicString&);
 
-  long long ExpectedContentLength() const;
-  void SetExpectedContentLength(long long);
+  int64_t ExpectedContentLength() const;
+  void SetExpectedContentLength(int64_t);
 
   const AtomicString& TextEncodingName() const;
   void SetTextEncodingName(const AtomicString&);
@@ -272,8 +272,8 @@ class PLATFORM_EXPORT ResourceResponse final {
                           const Vector<AtomicString>& certificate,
                           const SignedCertificateTimestampList& sct_list);
 
-  long long AppCacheID() const { return app_cache_id_; }
-  void SetAppCacheID(long long id) { app_cache_id_ = id; }
+  int64_t AppCacheID() const { return app_cache_id_; }
+  void SetAppCacheID(int64_t id) { app_cache_id_ = id; }
 
   const KURL& AppCacheManifestURL() const { return app_cache_manifest_url_; }
   void SetAppCacheManifestURL(const KURL& url) {
@@ -326,7 +326,7 @@ class PLATFORM_EXPORT ResourceResponse final {
   KURL OriginalURLViaServiceWorker() const;
 
   const Vector<char>& MultipartBoundary() const { return multipart_boundary_; }
-  void SetMultipartBoundary(const char* bytes, size_t size) {
+  void SetMultipartBoundary(const char* bytes, uint32_t size) {
     multipart_boundary_.clear();
     multipart_boundary_.Append(bytes, size);
   }
@@ -379,14 +379,14 @@ class PLATFORM_EXPORT ResourceResponse final {
 
   AtomicString ConnectionInfoString() const;
 
-  long long EncodedDataLength() const { return encoded_data_length_; }
-  void SetEncodedDataLength(long long value);
+  int64_t EncodedDataLength() const { return encoded_data_length_; }
+  void SetEncodedDataLength(int64_t value);
 
-  long long EncodedBodyLength() const { return encoded_body_length_; }
-  void SetEncodedBodyLength(long long value);
+  int64_t EncodedBodyLength() const { return encoded_body_length_; }
+  void SetEncodedBodyLength(int64_t value);
 
-  long long DecodedBodyLength() const { return decoded_body_length_; }
-  void SetDecodedBodyLength(long long value);
+  int64_t DecodedBodyLength() const { return decoded_body_length_; }
+  void SetDecodedBodyLength(int64_t value);
 
   // Extra data associated with this response.
   ExtraData* GetExtraData() const { return extra_data_.get(); }
@@ -536,7 +536,7 @@ class PLATFORM_EXPORT ResourceResponse final {
 
   // The id of the appcache this response was retrieved from, or zero if
   // the response was not retrieved from an appcache.
-  long long app_cache_id_ = 0;
+  int64_t app_cache_id_ = 0;
 
   // The manifest url of the appcache this response was retrieved from, if any.
   // Note: only valid for main resource responses.
@@ -569,14 +569,14 @@ class PLATFORM_EXPORT ResourceResponse final {
       net::HttpResponseInfo::ConnectionInfo::CONNECTION_INFO_UNKNOWN;
 
   // Size of the response in bytes prior to decompression.
-  long long encoded_data_length_ = 0;
+  int64_t encoded_data_length_ = 0;
 
   // Size of the response body in bytes prior to decompression.
-  long long encoded_body_length_ = 0;
+  int64_t encoded_body_length_ = 0;
 
   // Sizes of the response body in bytes after any content-encoding is
   // removed.
-  long long decoded_body_length_ = 0;
+  int64_t decoded_body_length_ = 0;
 
   // ExtraData associated with the response.
   scoped_refptr<ExtraData> extra_data_;

third_party/blink/renderer/platform/loader/fetch/source_keyed_cached_metadata_handler.cc

@@ -66,7 +66,8 @@ class SourceKeyedCachedMetadataHandler::SingleKeyHandler final
 class SourceKeyedCachedMetadataHandler::KeyHash {
  public:
   static unsigned GetHash(const Key& key) {
-    return StringHasher::ComputeHash(key.data(), key.size());
+    return StringHasher::ComputeHash(key.data(),
+                                     static_cast<uint32_t>(key.size()));
   }
 
   static bool Equal(const Key& a, const Key& b) { return a == b; }

third_party/blink/renderer/platform/loader/fetch/source_keyed_cached_metadata_handler_test.cc

@@ -9,6 +9,7 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/renderer/platform/crypto.h"
 #include "third_party/blink/renderer/platform/testing/testing_platform_support_with_mock_scheduler.h"
+#include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
 
 namespace blink {
 
@@ -69,7 +70,7 @@ struct CacheMetadataEntry {
   CacheMetadataEntry(const WebURL& url,
                      base::Time response_time,
                      const char* data,
-                     size_t data_size)
+                     wtf_size_t data_size)
       : url(url), response_time(response_time) {
     this->data.Append(data, data_size);
   }
@@ -93,7 +94,8 @@ class SourceKeyedCachedMetadataHandlerMockPlatform final
                      base::Time response_time,
                      const char* data,
                      size_t data_size) override {
-    cache_entries_.emplace_back(url, response_time, data, data_size);
+    cache_entries_.emplace_back(url, response_time, data,
+                                SafeCast<wtf_size_t>(data_size));
   }
 
   bool HasCacheMetadataFor(const WebURL& url) {

third_party/blink/renderer/platform/loader/link_header.h

@@ -75,8 +75,8 @@ class PLATFORM_EXPORT LinkHeaderSet {
     return header_set_.begin();
   }
   Vector<LinkHeader>::const_iterator end() const { return header_set_.end(); }
-  LinkHeader& operator[](size_t i) { return header_set_[i]; }
-  size_t size() { return header_set_.size(); }
+  LinkHeader& operator[](wtf_size_t i) { return header_set_[i]; }
+  wtf_size_t size() { return header_set_.size(); }
 
  private:
   Vector<LinkHeader> header_set_;

third_party/blink/renderer/platform/loader/subresource_integrity.cc

@@ -39,7 +39,7 @@ static bool DigestsEqual(const DigestValue& digest1,
   if (digest1.size() != digest2.size())
     return false;
 
-  for (size_t i = 0; i < digest1.size(); i++) {
+  for (wtf_size_t i = 0; i < digest1.size(); i++) {
     if (digest1[i] != digest2[i])
       return false;
   }
@@ -384,7 +384,8 @@ bool SubresourceIntegrity::ParseDigest(const UChar*& position,
   }
 
   // We accept base64url encoding, but normalize to "normal" base64 internally:
-  digest = NormalizeToBase64(String(begin, position - begin));
+  digest = NormalizeToBase64(
+      String(begin, static_cast<wtf_size_t>(position - begin)));
   return true;
 }
 
@@ -490,7 +491,7 @@ SubresourceIntegrity::ParseIntegrityAttribute(
       if (begin != position && report_info) {
         report_info->AddConsoleErrorMessage(
             "Ignoring unrecogized 'integrity' attribute option '" +
-            String(begin, position - begin) + "'.");
+            String(begin, static_cast<wtf_size_t>(position - begin)) + "'.");
       }
     }
 

third_party/blink/renderer/platform/loader/testing/mock_resource.cc

@@ -7,6 +7,7 @@
 #include "third_party/blink/renderer/platform/loader/fetch/fetch_parameters.h"
 #include "third_party/blink/renderer/platform/loader/fetch/resource_fetcher.h"
 #include "third_party/blink/renderer/platform/loader/fetch/resource_loader_options.h"
+#include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
 
 namespace blink {
 
@@ -81,7 +82,7 @@ MockCacheHandler::MockCacheHandler(
 
 void MockCacheHandler::Set(const char* data, size_t size) {
   data_.emplace();
-  data_->Append(data, size);
+  data_->Append(data, SafeCast<wtf_size_t>(size));
 }
 
 void MockCacheHandler::ClearCachedMetadata(