Fix the snapshot_cache unittests.

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"
+#import "ios/chrome/browser/snapshots/snapshot_cache_internal.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.
 - (base::FilePath)oldCacheDirectory;
 // Remove all UIImages from |imageDictionary_|.
 - (void)handleEnterBackground;
 // Remove all but adjacent UIImages from |imageDictionary_|.
 - (void)handleLowMemory;
 // Restore adjacent UIImages to |imageDictionary_|.
 - (void)handleBecomeActive;
@@ skipping 99 matching lines @@
 + (SnapshotCache*)sharedInstance {
   static SnapshotCache* instance = [[SnapshotCache alloc] init];
   return instance;
 }
 
 - (id)init {
   if ((self = [super init])) {
     DCHECK_CURRENTLY_ON(web::WebThread::UI);
     propertyReleaser_SnapshotCache_.Init(self, [SnapshotCache class]);
 
-    // Always use the LRUCache when the tab switcher is enabled.
-    if (experimental_flags::IsTabSwitcherEnabled() ||
-        experimental_flags::IsLRUSnapshotCacheEnabled()) {
+    if ([self usesLRUCache]) {
       lruCache_.reset(
           [[LRUCache alloc] initWithCacheSize:kLRUCacheMaxCapacity]);
     } else {
       imageDictionary_.reset(
           [[NSMutableDictionary alloc] initWithCapacity:kCacheInitialCapacity]);
     }
-
-    if (!IsIPadIdiom() || experimental_flags::IsTabSwitcherEnabled()) {
-      [[NSNotificationCenter defaultCenter]
-          addObserver:self
-             selector:@selector(handleLowMemory)
-                 name:UIApplicationDidReceiveMemoryWarningNotification
-               object:nil];
-      [[NSNotificationCenter defaultCenter]
-          addObserver:self
-             selector:@selector(handleEnterBackground)
-                 name:UIApplicationDidEnterBackgroundNotification
-               object:nil];
-      [[NSNotificationCenter defaultCenter]
-          addObserver:self
-             selector:@selector(handleBecomeActive)
-                 name:UIApplicationDidBecomeActiveNotification
-               object:nil];
-    }
+    [[NSNotificationCenter defaultCenter]
+        addObserver:self
+           selector:@selector(handleLowMemory)
+               name:UIApplicationDidReceiveMemoryWarningNotification
+             object:nil];
+    [[NSNotificationCenter defaultCenter]
+        addObserver:self
+           selector:@selector(handleEnterBackground)
+               name:UIApplicationDidEnterBackgroundNotification
+             object:nil];
+    [[NSNotificationCenter defaultCenter]
+        addObserver:self
+           selector:@selector(handleBecomeActive)
+               name:UIApplicationDidBecomeActiveNotification
+             object:nil];
   }
   return self;
 }
 
 - (void)dealloc {
-  if (!IsIPadIdiom() || experimental_flags::IsTabSwitcherEnabled()) {
-    [[NSNotificationCenter defaultCenter]
-        removeObserver:self
-                  name:UIApplicationDidReceiveMemoryWarningNotification
-                object:nil];
-    [[NSNotificationCenter defaultCenter]
-        removeObserver:self
-                  name:UIApplicationDidEnterBackgroundNotification
-                object:nil];
-    [[NSNotificationCenter defaultCenter]
-        removeObserver:self
-                  name:UIApplicationDidBecomeActiveNotification
-                object:nil];
-  }
+  [[NSNotificationCenter defaultCenter]
+      removeObserver:self
+                name:UIApplicationDidReceiveMemoryWarningNotification
+              object:nil];
+  [[NSNotificationCenter defaultCenter]
+      removeObserver:self
+                name:UIApplicationDidEnterBackgroundNotification
+              object:nil];
+  [[NSNotificationCenter defaultCenter]
+      removeObserver:self
+                name:UIApplicationDidBecomeActiveNotification
+              object:nil];
   [super dealloc];
 }
 
 + (CGFloat)snapshotScaleForDevice {
   // On handset, the color snapshot is used for the stack view, so the scale of
   // the snapshot images should match the scale of the device.
   // On tablet, the color snapshot is only used to generate the grey snapshot,
   // which does not have to be high quality, so use scale of 1.0 on all tablets.
   if (IsIPadIdiom()) {
     return 1.0;
   }
   // Cap snapshot resolution to 2x to reduce the amount of memory they use.
   return MIN([UIScreen mainScreen].scale, 2.0);
 }
 
 - (void)retrieveImageForSessionID:(NSString*)sessionID
                          callback:(void (^)(UIImage*))callback {
   DCHECK_CURRENTLY_ON(web::WebThread::UI);
   DCHECK(sessionID);
 
-  // Cache on iPad is enabled only when the tab switcher is enabled.
-  if ((IsIPadIdiom() && !experimental_flags::IsTabSwitcherEnabled()) &&
-      !callback)
+  if (![self inMemoryCacheIsEnabled] && !callback)
     return;
 
   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) {
-        // Cache on iPad is enabled only when the tab switcher is enabled.
-        if ((!IsIPadIdiom() || experimental_flags::IsTabSwitcherEnabled()) &&
-            image) {
+        if ([self inMemoryCacheIsEnabled] && 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::WebThread::UI);
   if (!img || !sessionID)
     return;
 
-  // Cache on iPad is enabled only when the tab switcher is enabled.
-  if (!IsIPadIdiom() || experimental_flags::IsTabSwitcherEnabled()) {
+  if ([self inMemoryCacheIsEnabled]) {
     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]);
@@ skipping 110 matching lines @@
     return;
   backgroundingImageSessionId_.reset([sessionID copy]);
   if (lruCache_) {
     backgroundingColorImage_.reset([[lruCache_ objectForKey:sessionID] retain]);
   } else {
     backgroundingColorImage_.reset(
         [[imageDictionary_ objectForKey:sessionID] retain]);
   }
 }
 
+- (BOOL)inMemoryCacheIsEnabled {
+  // In-memory cache on iPad is enabled only when the tab switcher is enabled.
+  return !IsIPadIdiom() || experimental_flags::IsTabSwitcherEnabled();
+}
+
+- (BOOL)usesLRUCache {
+  // Always use the LRUCache when the tab switcher is enabled.
+  return experimental_flags::IsTabSwitcherEnabled() ||
+         experimental_flags::IsLRUSnapshotCacheEnabled();
+}
+
 - (void)handleLowMemory {
-  DCHECK(!IsIPadIdiom() || experimental_flags::IsTabSwitcherEnabled());
   DCHECK_CURRENTLY_ON(web::WebThread::UI);
   base::scoped_nsobject<NSMutableDictionary> dictionary(
       [[NSMutableDictionary alloc] initWithCapacity:2]);
   for (NSString* sessionID in pinnedIDs_) {
     UIImage* image = nil;
     if (lruCache_)
       image = [lruCache_ objectForKey:sessionID];
     else
       image = [imageDictionary_ objectForKey:sessionID];
     if (image)
       [dictionary setObject:image forKey:sessionID];
   }
   if (lruCache_) {
     [lruCache_ removeAllObjects];
     for (NSString* sessionID in pinnedIDs_)
       [lruCache_ setObject:[dictionary objectForKey:sessionID]
                     forKey:sessionID];
   } else {
     imageDictionary_ = dictionary;
   }
 }
 
 - (void)handleEnterBackground {
-  DCHECK(!IsIPadIdiom() || experimental_flags::IsTabSwitcherEnabled());
   DCHECK_CURRENTLY_ON(web::WebThread::UI);
   [imageDictionary_ removeAllObjects];
   [lruCache_ removeAllObjects];
 }
 
 - (void)handleBecomeActive {
-  DCHECK(!IsIPadIdiom() || experimental_flags::IsTabSwitcherEnabled());
   DCHECK_CURRENTLY_ON(web::WebThread::UI);
   for (NSString* sessionID in pinnedIDs_)
     [self retrieveImageForSessionID:sessionID callback:nil];
 }
 
 - (void)saveGreyImage:(UIImage*)greyImage forKey:(NSString*)sessionID {
   DCHECK_CURRENTLY_ON(web::WebThread::UI);
   if (greyImage)
     [greyImageDictionary_ setObject:greyImage forKey:sessionID];
   if ([sessionID isEqualToString:mostRecentGreySessionId_]) {
@@ skipping 130 matching lines @@
   web::WebThread::PostBlockingPoolTask(
       FROM_HERE, base::Bind(&ConvertAndSaveGreyImage, colorImagePath,
                             greyImagePath, backgroundingColorImage_));
 }
 
 @end
 
 @implementation SnapshotCache (TestingAdditions)
 
 - (BOOL)hasImageInMemory:(NSString*)sessionID {
-  if (experimental_flags::IsLRUSnapshotCacheEnabled())
+  if ([self usesLRUCache])

[sdefresne, 2016/10/07 14:56:19]

The test changed, is this expected?

[jif, 2016/10/24 15:10:03]

Yes. It is now correct:
The LRU cache is used when IsLRUSnapshotCacheEnabled OR when the tab switcher is
enabled.

     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