Update from https://crrev.com/306655

net/disk_cache/simple/simple_index.h

 // 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.
 
 #ifndef NET_DISK_CACHE_SIMPLE_SIMPLE_INDEX_H_
 #define NET_DISK_CACHE_SIMPLE_SIMPLE_INDEX_H_
 
 #include <list>
 #include <vector>
 
@@ skipping 22 matching lines @@
 
 namespace disk_cache {
 
 class SimpleIndexDelegate;
 class SimpleIndexFile;
 struct SimpleIndexLoadResult;
 
 class NET_EXPORT_PRIVATE EntryMetadata {
  public:
   EntryMetadata();
-  EntryMetadata(base::Time last_used_time, int entry_size);
+  EntryMetadata(base::Time last_used_time, uint64 entry_size);
 
   base::Time GetLastUsedTime() const;
   void SetLastUsedTime(const base::Time& last_used_time);
 
-  int GetEntrySize() const { return entry_size_; }
-  void SetEntrySize(int entry_size) { entry_size_ = entry_size; }
+  uint64 GetEntrySize() const;
+  void SetEntrySize(uint64 entry_size);
 
   // Serialize the data into the provided pickle.
   void Serialize(Pickle* pickle) const;
   bool Deserialize(PickleIterator* it);
 
   static base::TimeDelta GetLowerEpsilonForTimeComparisons() {
     return base::TimeDelta::FromSeconds(1);
   }
   static base::TimeDelta GetUpperEpsilonForTimeComparisons() {
     return base::TimeDelta();
@@ skipping 19 matching lines @@
 
   SimpleIndex(const scoped_refptr<base::SingleThreadTaskRunner>& io_thread,
               SimpleIndexDelegate* delegate,
               net::CacheType cache_type,
               scoped_ptr<SimpleIndexFile> simple_index_file);
 
   virtual ~SimpleIndex();
 
   void Initialize(base::Time cache_mtime);
 
-  bool SetMaxSize(int max_bytes);
-  int max_size() const { return max_size_; }
+  void SetMaxSize(uint64 max_bytes);
+  uint64 max_size() const { return max_size_; }
 
   void Insert(uint64 entry_hash);
   void Remove(uint64 entry_hash);
 
   // Check whether the index has the entry given the hash of its key.
   bool Has(uint64 entry_hash) const;
 
   // Update the last used time of the entry with the given key and return true
   // iff the entry exist in the index.
   bool UseIfExists(uint64 entry_hash);
 
   void WriteToDisk();
 
   // Update the size (in bytes) of an entry, in the metadata stored in the
   // index. This should be the total disk-file size including all streams of the
   // entry.
-  bool UpdateEntrySize(uint64 entry_hash, int entry_size);
+  bool UpdateEntrySize(uint64 entry_hash, int64 entry_size);
 
   typedef base::hash_map<uint64, EntryMetadata> EntrySet;
 
   static void InsertInEntrySet(uint64 entry_hash,
                                const EntryMetadata& entry_metadata,
                                EntrySet* entry_set);
 
   // Executes the |callback| when the index is ready. Allows multiple callbacks.
   int ExecuteWhenReady(const net::CompletionCallback& callback);
 
@@ skipping 18 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(SimpleIndexTest, IndexSizeCorrectOnMerge);
   FRIEND_TEST_ALL_PREFIXES(SimpleIndexTest, DiskWriteQueued);
   FRIEND_TEST_ALL_PREFIXES(SimpleIndexTest, DiskWriteExecuted);
   FRIEND_TEST_ALL_PREFIXES(SimpleIndexTest, DiskWritePostponed);
 
   void StartEvictionIfNeeded();
   void EvictionDone(int result);
 
   void PostponeWritingToDisk();
 
-  void UpdateEntryIteratorSize(EntrySet::iterator* it, int entry_size);
+  void UpdateEntryIteratorSize(EntrySet::iterator* it, int64 entry_size);
 
   // Must run on IO Thread.
   void MergeInitializingSet(scoped_ptr<SimpleIndexLoadResult> load_result);
 
 #if defined(OS_ANDROID)
   void OnApplicationStateChange(base::android::ApplicationState state);
 
   scoped_ptr<base::android::ApplicationStatusListener> app_status_listener_;
 #endif
 
@@ skipping 36 matching lines @@
 
   // Set to true when the app is on the background. When the app is in the
   // background we can write the index much more frequently, to insure fresh
   // index on next startup.
   bool app_on_background_;
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_INDEX_H_