[iOS] Fixed tab snapshot cache refresh issues on iPad.

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 122 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]);
 
-    // TODO(andybons): 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]);
-    [[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];
+    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]);
+      [[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 {
-  [[NSNotificationCenter defaultCenter]
-      removeObserver:self
-                name:UIApplicationDidReceiveMemoryWarningNotification
-              object:nil];
-  [[NSNotificationCenter defaultCenter]
-      removeObserver:self
-                name:UIApplicationDidEnterBackgroundNotification
-              object:nil];
-  [[NSNotificationCenter defaultCenter]
-      removeObserver:self
-                name:UIApplicationDidBecomeActiveNotification
-              object:nil];
+  if (!IsIPadIdiom()) {
+    [[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_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];
   if (img) {
     if (callback)
       callback(img);
     return;
   }
 
   base::PostTaskAndReplyWithResult(
       web::WebThread::GetMessageLoopProxyForThread(
           web::WebThread::FILE_USER_BLOCKING).get(),
-      FROM_HERE,
-      base::BindBlock(^base::scoped_nsobject<UIImage>() {
+      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) {
-        if (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 (callback)
           callback(image);
       }));
 }
 
 - (void)setImage:(UIImage*)img withSessionID:(NSString*)sessionID {
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::UI);
   if (!img || !sessionID)
     return;
 
-  // Color snapshots are not used on tablets, so don't keep them in memory.
+  // 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];
   }
   // 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]);
@@ skipping 101 matching lines @@
 - (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]);
 }
 
 - (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];
     if (image)
       [dictionary setObject:image forKey:sessionID];
   }
   imageDictionary_.reset(dictionary);
 }
 
 - (void)handleEnterBackground {
+  DCHECK(!IsIPadIdiom());
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::UI);
   [imageDictionary_ 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_]) {
@@ skipping 123 matching lines @@
       backgroundingImageSessionId_.reset();
     }
   }
 
   web::WebThread::PostBlockingPoolTask(
       FROM_HERE, base::Bind(&ConvertAndSaveGreyImage, colorImagePath,
                             greyImagePath, backgroundingColorImage_));
 }
 
 @end