Enable the snapshot cache on iPad when the tab switcher is enabled.

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"
@@ skipping 126 matching lines @@
 + (SnapshotCache*)sharedInstance {
   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()) {
-      if (experimental_flags::IsLRUSnapshotCacheEnabled()) {
-        lruCache_.reset(
-            [[LRUCache alloc] initWithCacheSize:kLRUCacheMaxCapacity]);
-      } else {
-        imageDictionary_.reset([[NSMutableDictionary alloc]
-            initWithCapacity:kCacheInitialCapacity]);
-      }
+    // Always use the LRUCache when the tab switcher is enabled.
+    if (experimental_flags::IsTabSwitcherEnabled() ||
+        experimental_flags::IsLRUSnapshotCacheEnabled()) {
+      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];
     }
   }
   return self;
 }
 
 - (void)dealloc {
-  if (!IsIPadIdiom()) {
+  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
@@ skipping 12 matching lines @@
     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_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)
+
+  // Cache on iPad is enabled only when the tab switcher is enabled.
+  if ((IsIPadIdiom() && !experimental_flags::IsTabSwitcherEnabled()) &&
+      !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) {
-        // 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) {
+        // Cache on iPad is enabled only when the tab switcher is enabled.
+        if ((!IsIPadIdiom() || experimental_flags::IsTabSwitcherEnabled()) &&
+            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()) {
+  // Cache on iPad is enabled only when the tab switcher is enabled.
+  if (!IsIPadIdiom() || experimental_flags::IsTabSwitcherEnabled()) {
     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 111 matching lines @@
   backgroundingImageSessionId_.reset([sessionID copy]);
   if (lruCache_) {
     backgroundingColorImage_.reset([[lruCache_ objectForKey:sessionID] retain]);
   } else {
     backgroundingColorImage_.reset(
         [[imageDictionary_ objectForKey:sessionID] retain]);
   }
 }
 
 - (void)handleLowMemory {
-  DCHECK(!IsIPadIdiom());
+  DCHECK(!IsIPadIdiom() || experimental_flags::IsTabSwitcherEnabled());
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::UI);
   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[sessionID] forKey:sessionID];
   } else {
     imageDictionary_.reset(dictionary);
   }
 }
 
 - (void)handleEnterBackground {
-  DCHECK(!IsIPadIdiom());
+  DCHECK(!IsIPadIdiom() || experimental_flags::IsTabSwitcherEnabled());
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::UI);
   [imageDictionary_ removeAllObjects];
   [lruCache_ removeAllObjects];
 }
 
 - (void)handleBecomeActive {
-  DCHECK(!IsIPadIdiom());
+  DCHECK(!IsIPadIdiom() || experimental_flags::IsTabSwitcherEnabled());
   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_]) {
@@ skipping 144 matching lines @@
 }
 - (BOOL)hasGreyImageInMemory:(NSString*)sessionID {
   return [greyImageDictionary_ objectForKey:sessionID] != nil;
 }
 
 - (NSUInteger)lruCacheMaxSize {
   return [lruCache_ maxCacheSize];
 }
 
 @end