Update from https://crrev.com/306655

net/disk_cache/simple/simple_synchronous_entry.cc

 // Copyright (c) 2013 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 "net/disk_cache/simple/simple_synchronous_entry.h"
 
 #include <algorithm>
 #include <cstring>
 #include <functional>
 #include <limits>
@@ skipping 116 matching lines @@
                                  const int32 sparse_data_size)
     : last_used_(last_used),
       last_modified_(last_modified),
       sparse_data_size_(sparse_data_size) {
   memcpy(data_size_, data_size, sizeof(data_size_));
 }
 
 int SimpleEntryStat::GetOffsetInFile(const std::string& key,
                                      int offset,
                                      int stream_index) const {
-  const int64 headers_size = sizeof(SimpleFileHeader) + key.size();
-  const int64 additional_offset =
+  const size_t headers_size = sizeof(SimpleFileHeader) + key.size();
+  const size_t additional_offset =
       stream_index == 0 ? data_size_[1] + sizeof(SimpleFileEOF) : 0;
   return headers_size + offset + additional_offset;
 }
 
 int SimpleEntryStat::GetEOFOffsetInFile(const std::string& key,
                                         int stream_index) const {
   return GetOffsetInFile(key, data_size_[stream_index], stream_index);
 }
 
 int SimpleEntryStat::GetLastEOFOffsetInFile(const std::string& key,
                                             int stream_index) const {
   const int file_index = GetFileIndexFromStreamIndex(stream_index);
   const int eof_data_offset =
       file_index == 0 ? data_size_[0] + data_size_[1] + sizeof(SimpleFileEOF)
                       : data_size_[2];
   return GetOffsetInFile(key, eof_data_offset, stream_index);
 }
 
-int SimpleEntryStat::GetFileSize(const std::string& key, int file_index) const {
-  const int total_data_size =
+int64 SimpleEntryStat::GetFileSize(const std::string& key,
+                                   int file_index) const {
+  const int32 total_data_size =
       file_index == 0 ? data_size_[0] + data_size_[1] + sizeof(SimpleFileEOF)
                       : data_size_[2];
   return GetFileSizeFromKeyAndDataSize(key, total_data_size);
 }
 
 SimpleEntryCreationResults::SimpleEntryCreationResults(
     SimpleEntryStat entry_stat)
     : sync_entry(NULL),
       entry_stat(entry_stat),
       stream_0_crc32(crc32(0, Z_NULL, 0)),
@@ skipping 275 matching lines @@
     read_so_far += len_to_read;
     ++it;
   }
 
   *out_result = read_so_far;
 }
 
 void SimpleSynchronousEntry::WriteSparseData(
     const EntryOperationData& in_entry_op,
     net::IOBuffer* in_buf,
-    int64 max_sparse_data_size,
+    uint64 max_sparse_data_size,
     SimpleEntryStat* out_entry_stat,
     int* out_result) {
   DCHECK(initialized_);
   int64 offset = in_entry_op.sparse_offset;
   int buf_len = in_entry_op.buf_len;
 
   const char* buf = in_buf->data();
   int written_so_far = 0;
   int appended_so_far = 0;
 
   if (!sparse_file_open() && !CreateSparseFile()) {
     *out_result = net::ERR_CACHE_WRITE_FAILURE;
     return;
   }
 
-  int64 sparse_data_size = out_entry_stat->sparse_data_size();
+  uint64 sparse_data_size = out_entry_stat->sparse_data_size();
   // This is a pessimistic estimate; it assumes the entire buffer is going to
   // be appended as a new range, not written over existing ranges.
   if (sparse_data_size + buf_len > max_sparse_data_size) {
     DVLOG(1) << "Truncating sparse data file (" << sparse_data_size << " + "
              << buf_len << " > " << max_sparse_data_size << ")";
     TruncateSparseFile();
   }
 
   SparseRangeIterator it = sparse_ranges_.lower_bound(offset);
 
@@ skipping 945 matching lines @@
   range.offset = offset;
   range.length = len;
   range.data_crc32 = data_crc32;
   range.file_offset = data_file_offset;
   sparse_ranges_.insert(std::make_pair(offset, range));
 
   return true;
 }
 
 }  // namespace disk_cache