cc: Make images that can't possibly fit in cache not checker.

cc/tiles/software_image_decode_cache.h

 // Copyright 2016 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 CC_TILES_SOFTWARE_IMAGE_DECODE_CACHE_H_
 #define CC_TILES_SOFTWARE_IMAGE_DECODE_CACHE_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 122 matching lines @@
       scoped_refptr<TileTask>* task) override;
   void UnrefImage(const DrawImage& image) override;
   DecodedDrawImage GetDecodedImageForDraw(const DrawImage& image) override;
   void DrawWithImageFinished(const DrawImage& image,
                              const DecodedDrawImage& decoded_image) override;
   void ReduceCacheUsage() override;
   // Software doesn't keep outstanding images pinned, so this is a no-op.
   void SetShouldAggressivelyFreeResources(
       bool aggressively_free_resources) override {}
   void ClearCache() override;
+  size_t GetMaximumMemoryLimit() const override;
 
   // Decode the given image and store it in the cache. This is only called by an
   // image decode task from a worker thread.
   void DecodeImage(const ImageKey& key,
                    const DrawImage& image,
                    DecodeTaskType task_type);
 
   void RemovePendingTask(const ImageKey& key, DecodeTaskType task_type);
 
   // MemoryDumpProvider overrides.
@@ skipping 60 matching lines @@
     explicit MemoryBudget(size_t limit_bytes);
 
     size_t AvailableMemoryBytes() const;
     void AddUsage(size_t usage);
     void SubtractUsage(size_t usage);
     void ResetUsage();
     size_t total_limit_bytes() const { return limit_bytes_; }
     size_t GetCurrentUsageSafe() const;
 
    private:
-    size_t limit_bytes_;
+    const size_t limit_bytes_;
     base::CheckedNumeric<size_t> current_usage_bytes_;
   };
 
   using ImageMRUCache = base::
       HashingMRUCache<ImageKey, std::unique_ptr<DecodedImage>, ImageKeyHash>;
 
   // Looks for the key in the cache and returns true if it was found and was
   // successfully locked (or if it was already locked). Note that if this
   // function returns true, then a ref count is increased for the image.
   bool LockDecodedImageIfPossibleAndRef(const ImageKey& key);
@@ skipping 65 matching lines @@
                                      DecodeTaskType type,
                                      scoped_refptr<TileTask>* task);
 
   std::unordered_map<ImageKey, scoped_refptr<TileTask>, ImageKeyHash>
       pending_in_raster_image_tasks_;
   std::unordered_map<ImageKey, scoped_refptr<TileTask>, ImageKeyHash>
       pending_out_of_raster_image_tasks_;
 
   // The members below this comment can only be accessed if the lock is held to
   // ensure that they are safe to access on multiple threads.
+  // The exception is accessing |locked_images_budget_.total_limit_bytes()|,
+  // which is const and thread safe.

[Khushal, 2017/04/28 00:12:53]

nit: Can you make |limit_bytes_| in MemoryBudget const too?

[Khushal, 2017/04/28 00:18:46]

Note to self: Look for colors other than green.

[vmpstr, 2017/04/28 17:18:30]

Acknowledged.

   base::Lock lock_;
 
   // Decoded images and ref counts (predecode path).
   ImageMRUCache decoded_images_;
   std::unordered_map<ImageKey, int, ImageKeyHash> decoded_images_ref_counts_;
 
   // Decoded image and ref counts (at-raster decode path).
   ImageMRUCache at_raster_decoded_images_;
   std::unordered_map<ImageKey, int, ImageKeyHash>
       at_raster_decoded_images_ref_counts_;
 
   MemoryBudget locked_images_budget_;
 
   ResourceFormat format_;
   size_t max_items_in_cache_;
 
   // Used to uniquely identify DecodedImages for memory traces.
   base::AtomicSequenceNumber next_tracing_id_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_SOFTWARE_IMAGE_DECODE_CACHE_H_