Added an experiment for an LRU snapshot cache.

ios/chrome/browser/snapshots/snapshot_cache.mm

 // Copyright 2012 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.
 
 #import "ios/chrome/browser/snapshots/snapshot_cache.h"
 
 #import <UIKit/UIKit.h>
 
 #include "base/critical_closure.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/mac/bind_objc_block.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_restrictions.h"
+#include "ios/chrome/browser/experimental_flags.h"
 #include "ios/chrome/browser/ui/ui_util.h"
 #import "ios/chrome/browser/ui/uikit_ui_util.h"
 #include "ios/web/public/web_thread.h"
 
 @interface SnapshotCache ()
 + (base::FilePath)imagePathForSessionID:(NSString*)sessionID;
 + (base::FilePath)greyImagePathForSessionID:(NSString*)sessionID;
 // Returns the directory where the thumbnails are saved.
 + (base::FilePath)cacheDirectory;
 // Returns the directory where the thumbnails were stored in M28 and earlier.
@@ skipping 14 matching lines @@
 @end
 
 namespace {
 static NSArray* const kSnapshotCacheDirectory = @[ @"Chromium", @"Snapshots" ];
 
 const NSUInteger kCacheInitialCapacity = 100;
 const NSUInteger kGreyInitialCapacity = 8;
 const CGFloat kJPEGImageQuality = 1.0;  // Highest quality. No compression.
 // Sequence token to make sure creation/deletion of snapshots don't overlap.
 const char kSequenceToken[] = "SnapshotCacheSequenceToken";
+// Maximum size in number of elements that the LRU cache can hold before
+// starting to evict elements.
+const NSUInteger kLRUCacheMaxCapacity = 6;
 
 // The paths of the images saved to disk, given a cache directory.
 base::FilePath FilePathForSessionID(NSString* sessionID,
                                     const base::FilePath& directory) {
   base::FilePath path = directory.Append(base::SysNSStringToUTF8(sessionID))
                             .ReplaceExtension(".jpg");
   if ([SnapshotCache snapshotScaleForDevice] == 2.0) {
     path = path.InsertBeforeExtension("@2x");
   } else if ([SnapshotCache snapshotScaleForDevice] == 3.0) {
     path = path.InsertBeforeExtension("@3x");
@@ skipping 70 matching lines @@
   static SnapshotCache* instance = [[SnapshotCache alloc] init];
   return instance;
 }
 
 - (id)init {
   if ((self = [super init])) {
     DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::UI);
     propertyReleaser_SnapshotCache_.Init(self, [SnapshotCache class]);
 
     if (!IsIPadIdiom()) {
-      // TODO(jbbegue): In the case where the cache grows, it is expensive.
-      // Make sure this doesn't suck when there are more than ten tabs.
-      imageDictionary_.reset(
-          [[NSMutableDictionary alloc] initWithCapacity:kCacheInitialCapacity]);
+      if (experimental_flags::IsLRUSnapshotCacheEnabled()) {
+        lruCache_.reset(
+            [[LRUCache alloc] initWithCacheSize:kLRUCacheMaxCapacity]);
+      } else {
+        imageDictionary_.reset([[NSMutableDictionary alloc]
+            initWithCapacity:kCacheInitialCapacity]);
+      }
+
       [[NSNotificationCenter defaultCenter]
           addObserver:self
              selector:@selector(handleLowMemory)
                  name:UIApplicationDidReceiveMemoryWarningNotification
                object:nil];
       [[NSNotificationCenter defaultCenter]
           addObserver:self
              selector:@selector(handleEnterBackground)
                  name:UIApplicationDidEnterBackgroundNotification
                object:nil];
@@ skipping 39 matching lines @@
 
 - (void)retrieveImageForSessionID:(NSString*)sessionID
                          callback:(void (^)(UIImage*))callback {
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::UI);
   DCHECK(sessionID);
   // iPad does not cache images, so if there is no callback we can avoid an
   // expensive read from storage.
   if (IsIPadIdiom() && !callback)
     return;
 
-  UIImage* img = [imageDictionary_ objectForKey:sessionID];
+  UIImage* img = nil;
+  if (lruCache_)
+    img = [lruCache_ objectForKey:sessionID];
+  else
+    img = [imageDictionary_ objectForKey:sessionID];
+
   if (img) {
     if (callback)
       callback(img);
     return;
   }
 
   base::PostTaskAndReplyWithResult(
       web::WebThread::GetTaskRunnerForThread(web::WebThread::FILE_USER_BLOCKING)
           .get(),
       FROM_HERE, base::BindBlock(^base::scoped_nsobject<UIImage>() {
         // Retrieve the image on a high priority thread.
         return base::scoped_nsobject<UIImage>([ReadImageFromDisk(
             [SnapshotCache imagePathForSessionID:sessionID]) retain]);
       }),
       base::BindBlock(^(base::scoped_nsobject<UIImage> image) {
         // The iPad tab switcher is currently using its own memory cache so the
         // image is not stored in memory here if running on iPad.
         // The same logic is used on image writes (code below).
-        if (!IsIPadIdiom() && image)
-          [imageDictionary_ setObject:image forKey:sessionID];
+        if (!IsIPadIdiom() && image) {
+          if (lruCache_)
+            [lruCache_ setObject:image forKey:sessionID];
+          else
+            [imageDictionary_ setObject:image forKey:sessionID];
+        }
         if (callback)
           callback(image);
       }));
 }
 
 - (void)setImage:(UIImage*)img withSessionID:(NSString*)sessionID {
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::UI);
   if (!img || !sessionID)
     return;
 
   // The iPad tab switcher is currently using its own memory cache so the image
   // is not stored in memory here if running on iPad.
   // The same logic is used on image reads (code above).
   if (!IsIPadIdiom()) {
-    [imageDictionary_ setObject:img forKey:sessionID];
+    if (lruCache_)
+      [lruCache_ setObject:img forKey:sessionID];
+    else
+      [imageDictionary_ setObject:img forKey:sessionID];
   }
   // Save the image to disk.
   web::WebThread::PostBlockingPoolSequencedTask(
       kSequenceToken, FROM_HERE,
       base::BindBlock(^{
         base::scoped_nsobject<UIImage> image([img retain]);
         WriteImageToDisk(image,
                          [SnapshotCache imagePathForSessionID:sessionID]);
       }));
 }
 
 - (void)removeImageWithSessionID:(NSString*)sessionID {
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::UI);
-  [imageDictionary_ removeObjectForKey:sessionID];
+  if (lruCache_)
+    [lruCache_ removeObjectForKey:sessionID];
+  else
+    [imageDictionary_ removeObjectForKey:sessionID];
+
   web::WebThread::PostBlockingPoolSequencedTask(
       kSequenceToken, FROM_HERE,
       base::BindBlock(^{
         base::FilePath imagePath =
             [SnapshotCache imagePathForSessionID:sessionID];
         base::DeleteFile(imagePath, false);
         base::DeleteFile([SnapshotCache greyImagePathForSessionID:sessionID],
                          false);
       }));
 }
@@ skipping 80 matching lines @@
           base::DeleteFile(cur_file, false);
         }
       }));
 }
 
 - (void)willBeSavedGreyWhenBackgrounding:(NSString*)sessionID {
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::UI);
   if (!sessionID)
     return;
   backgroundingImageSessionId_.reset([sessionID copy]);
-  backgroundingColorImage_.reset(
-      [[imageDictionary_ objectForKey:sessionID] retain]);
+  if (lruCache_) {
+    backgroundingColorImage_.reset([[lruCache_ objectForKey:sessionID] retain]);
+  } else {
+    backgroundingColorImage_.reset(
+        [[imageDictionary_ objectForKey:sessionID] retain]);
+  }
 }
 
 - (void)handleLowMemory {
   DCHECK(!IsIPadIdiom());
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::UI);
   NSMutableDictionary* dictionary =
       [[NSMutableDictionary alloc] initWithCapacity:2];
   for (NSString* sessionID in pinnedIDs_) {
-    UIImage* image = [imageDictionary_ objectForKey:sessionID];
+    UIImage* image = nil;
+    if (lruCache_)
+      image = [lruCache_ objectForKey:sessionID];
+    else
+      image = [imageDictionary_ objectForKey:sessionID];
     if (image)
       [dictionary setObject:image forKey:sessionID];
   }
-  imageDictionary_.reset(dictionary);
+  if (lruCache_) {
+    [lruCache_ removeAllObjects];
+    for (NSString* sessionID in pinnedIDs_)
+      [lruCache_ setObject:dictionary[sessionID] forKey:sessionID];
+  } else {
+    imageDictionary_.reset(dictionary);
+  }
 }
 
 - (void)handleEnterBackground {
   DCHECK(!IsIPadIdiom());
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::UI);
   [imageDictionary_ removeAllObjects];
+  [lruCache_ removeAllObjects];
 }
 
 - (void)handleBecomeActive {
   DCHECK(!IsIPadIdiom());
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::UI);
   for (NSString* sessionID in pinnedIDs_)
     [self retrieveImageForSessionID:sessionID callback:nil];
 }
 
 - (void)saveGreyImage:(UIImage*)greyImage forKey:(NSString*)sessionID {
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::UI);
   if (greyImage)
     [greyImageDictionary_ setObject:greyImage forKey:sessionID];
   if ([sessionID isEqualToString:mostRecentGreySessionId_]) {
     mostRecentGreyBlock_.get()(greyImage);
     [self clearGreySessionInfo];
   }
 }
 
 - (void)loadGreyImageAsync:(NSString*)sessionID {
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::UI);
   // Don't call -retrieveImageForSessionID here because it caches the colored
   // image, which we don't need for the grey image cache. But if the image is
   // already in the cache, use it.
-  UIImage* img = [imageDictionary_ objectForKey:sessionID];
+  UIImage* img = nil;
+  if (lruCache_)
+    img = [lruCache_ objectForKey:sessionID];
+  else
+    img = [imageDictionary_ objectForKey:sessionID];
+
   base::PostTaskAndReplyWithResult(
       web::WebThread::GetTaskRunnerForThread(web::WebThread::FILE_USER_BLOCKING)
           .get(),
       FROM_HERE, base::BindBlock(^base::scoped_nsobject<UIImage>() {
         base::scoped_nsobject<UIImage> result([img retain]);
         // If the image is not in the cache, load it from disk.
         if (!result)
           result.reset([ReadImageFromDisk(
               [SnapshotCache imagePathForSessionID:sessionID]) retain]);
         if (result)
@@ skipping 100 matching lines @@
       backgroundingImageSessionId_.reset();
     }
   }
 
   web::WebThread::PostBlockingPoolTask(
       FROM_HERE, base::Bind(&ConvertAndSaveGreyImage, colorImagePath,
                             greyImagePath, backgroundingColorImage_));
 }
 
 @end
+
+@implementation SnapshotCache (TestingAdditions)
+
+- (BOOL)hasImageInMemory:(NSString*)sessionID {
+  if (experimental_flags::IsLRUSnapshotCacheEnabled())
+    return [lruCache_ objectForKey:sessionID] != nil;
+  else
+    return [imageDictionary_ objectForKey:sessionID] != nil;
+}
+- (BOOL)hasGreyImageInMemory:(NSString*)sessionID {
+  return [greyImageDictionary_ objectForKey:sessionID] != nil;
+}
+
+- (NSUInteger)lruCacheMaxSize {
+  return [lruCache_ maxCacheSize];
+}
+
+@end