Added an experiment for an LRU snapshot cache.

ios/chrome/browser/snapshots/snapshot_cache_unittest.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 <Foundation/Foundation.h>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/ios/ios_util.h"
 #include "base/location.h"
 #include "base/mac/bind_objc_block.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/run_loop.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/time/time.h"
+#include "ios/chrome/browser/experimental_flags.h"
 #include "ios/chrome/browser/ui/ui_util.h"
 #include "ios/web/public/test/test_web_thread_bundle.h"
 #include "ios/web/public/web_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gtest_mac.h"
 #include "testing/platform_test.h"
 
 static const NSUInteger kSessionCount = 10;
 static const NSUInteger kSnapshotPixelSize = 8;
 
 // Promote some implementation methods to public.
 @interface SnapshotCache (Testing)
 + (base::FilePath)imagePathForSessionID:(NSString*)sessionID;
 + (base::FilePath)greyImagePathForSessionID:(NSString*)sessionID;
 - (void)handleLowMemory;
 @end
 
 @interface SnapshotCache (TestingAdditions)
 - (BOOL)hasImageInMemory:(NSString*)sessionID;
 - (BOOL)hasGreyImageInMemory:(NSString*)sessionID;
 @end
 
 @implementation SnapshotCache (TestingAdditions)

[sdefresne, 2015/11/03 11:25:19]

Please avoid adding methods to the class in the test file. Can you move this to
a private part of the SnapshotCache class?

[jbbegue, 2015/11/03 13:37:19]

Done.

 - (BOOL)hasImageInMemory:(NSString*)sessionID {
-  return [imageDictionary_ objectForKey:sessionID] != nil;
+  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
 
 namespace {
 
 class SnapshotCacheTest : public PlatformTest {
  protected:
   // Build an array of session names and an array of UIImages filled with
   // random colors.
   void SetUp() override {
     PlatformTest::SetUp();
@@ skipping 170 matching lines @@
 // This test also checks that images are correctly removed from the disk.
 TEST_F(SnapshotCacheTest, Cache) {
   // Don't run on tablets because color snapshots are not cached so this test
   // can't compare the UIImage pointers directly.
   if (IsIPadIdiom()) {
     return;
   }
 
   SnapshotCache* cache = GetSnapshotCache();
 
+  NSUInteger expectedCacheSize = kSessionCount;
+  if (experimental_flags::IsLRUSnapshotCacheEnabled())
+    expectedCacheSize = MIN(kSessionCount, [cache lruCacheMaxSize]);
+
   // Put all images in the cache.
-  for (NSUInteger i = 0; i < kSessionCount; ++i) {
+  for (NSUInteger i = 0; i < expectedCacheSize; ++i) {
     UIImage* image = [testImages_ objectAtIndex:i];
     NSString* sessionID = [testSessions_ objectAtIndex:i];
     [cache setImage:image withSessionID:sessionID];
   }
 
   // Get images back.
   __block NSUInteger numberOfCallbacks = 0;
-  for (NSUInteger i = 0; i < kSessionCount; ++i) {
+  for (NSUInteger i = 0; i < expectedCacheSize; ++i) {
     NSString* sessionID = [testSessions_ objectAtIndex:i];
     UIImage* expectedImage = [testImages_ objectAtIndex:i];
     EXPECT_TRUE(expectedImage != nil);
     [cache retrieveImageForSessionID:sessionID
                             callback:^(UIImage* image) {
                               // Images have not been removed from the
                               // dictionnary. We expect the same pointer.
                               EXPECT_EQ(expectedImage, image);
                               ++numberOfCallbacks;
                             }];
   }
-  EXPECT_EQ(kSessionCount, numberOfCallbacks);
+  EXPECT_EQ(MIN(expectedCacheSize, [cache lruCacheMaxSize]), numberOfCallbacks);
 }
 
 // This test puts all the snapshots in the cache and flushes them to disk.
 // The snapshots are then reloaded from the disk, and the colors are compared.
 TEST_F(SnapshotCacheTest, SaveToDisk) {
   SnapshotCache* cache = GetSnapshotCache();
 
   // Put all images in the cache.
   for (NSUInteger i = 0; i < kSessionCount; ++i) {
     UIImage* image = [testImages_ objectAtIndex:i];
@@ skipping 321 matching lines @@
   EXPECT_TRUE(base::PathExists(retinaFile));
 
   // Delete the image.
   [cache removeImageWithSessionID:kSession];
   FlushRunLoops();  // ensure the file is removed.
 
   EXPECT_FALSE(base::PathExists(retinaFile));
 }
 
 }  // namespace