Fix the snapshot_cache unittests.

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"
+#import "ios/chrome/browser/snapshots/snapshot_cache_internal.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
-
 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();
     snapshotCache_.reset([[SnapshotCache alloc] init]);
     testImages_.reset([[NSMutableArray alloc] initWithCapacity:kSessionCount]);
@@ skipping 150 matching lines @@
       *green = lastChannel - *green;
       *blue = lastChannel - *blue;
     }
   }
 
   const char* GetPixelData(CGImageRef cgImage) {
     CFDataRef data = CGDataProviderCopyData(CGImageGetDataProvider(cgImage));
     return reinterpret_cast<const char*>(CFDataGetBytePtr(data));
   }
 
+  void TriggerMemoryWarning() {
+    // _performMemoryWarning is a private API and musn't be compiled into

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

nit: musn't -> must not

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

Done.

+    // official builds.
+    [[UIApplication sharedApplication]
+        performSelector:@selector(_performMemoryWarning)];
+  }
+
   web::TestWebThreadBundle thread_bundle_;
   base::scoped_nsobject<SnapshotCache> snapshotCache_;
   base::scoped_nsobject<NSMutableArray> testSessions_;
   base::scoped_nsobject<NSMutableArray> testImages_;
 };
 
 // This test simply put all the snapshots in the cache and then gets them back
 // As the snapshots are kept in memory, the same pointer can be retrieved.
 // 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() && !experimental_flags::IsTabSwitcherEnabled()) {
-    return;
-  }
-
   SnapshotCache* cache = GetSnapshotCache();
 
+  if (![cache inMemoryCacheIsEnabled])
+    return;
+
   NSUInteger expectedCacheSize = kSessionCount;
-  if (experimental_flags::IsLRUSnapshotCacheEnabled())
+  if ([cache usesLRUCache])

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

This test changed too, is this expected?

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

Yes: same reason as in the other test.

     expectedCacheSize = MIN(kSessionCount, [cache lruCacheMaxSize]);
 
   // Put all images in the cache.
   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.
@@ skipping 103 matching lines @@
 
     base::FilePath path([SnapshotCache imagePathForSessionID:sessionID]);
     if (i == 0)
       EXPECT_TRUE(base::PathExists(path));
     else
       EXPECT_FALSE(base::PathExists(path));
   }
 }
 
 // Loads the color images into the cache, and pins two of them.  Ensures that
-// only the two pinned IDs remain in memory after a call to -handleLowMemory.
-TEST_F(SnapshotCacheTest, HandleLowMemory) {
-// TODO(droger): This test fails on iPad iOS8 device: http://crbug.com/455209
-#if !TARGET_IPHONE_SIMULATOR
-  if (IsIPadIdiom() && base::ios::IsRunningOnIOS8OrLater()) {
-    LOG(WARNING) << "Test disabled on iPad iOS8 device.";
-    return;
-  }
-#endif
-
+// only the two pinned IDs remain in memory after a memory warning.
+TEST_F(SnapshotCacheTest, HandleMemoryWarning) {
   LoadAllColorImagesIntoCache(true);
 
   SnapshotCache* cache = GetSnapshotCache();
 
   NSString* firstPinnedID = [testSessions_ objectAtIndex:4];
   NSString* secondPinnedID = [testSessions_ objectAtIndex:6];
   NSMutableSet* set = [NSMutableSet set];
   [set addObject:firstPinnedID];
   [set addObject:secondPinnedID];
   cache.pinnedIDs = set;
 
-  if (!IsIPadIdiom() || experimental_flags::IsTabSwitcherEnabled())
-    [cache handleLowMemory];
+  TriggerMemoryWarning();
 
-  BOOL expectedValue = YES;
-  if (IsIPadIdiom() && !experimental_flags::IsTabSwitcherEnabled())
-    expectedValue = NO;
-
-  EXPECT_EQ(expectedValue, [cache hasImageInMemory:firstPinnedID]);
-  EXPECT_EQ(expectedValue, [cache hasImageInMemory:secondPinnedID]);
+  EXPECT_EQ(YES, [cache hasImageInMemory:firstPinnedID]);
+  EXPECT_EQ(YES, [cache hasImageInMemory:secondPinnedID]);
 
   NSString* notPinnedID = [testSessions_ objectAtIndex:2];
   EXPECT_FALSE([cache hasImageInMemory:notPinnedID]);
 
   // Wait for the final image to be pulled off disk.
   FlushRunLoops();
 }
 
 // Tests that createGreyCache creates the grey snapshots in the background,
 // from color images in the in-memory cache.  When the grey images are all
@@ skipping 26 matching lines @@
 
 // Same as previous test, except that all the color images are on disk,
 // rather than in memory.
 // Disabled due to the greyImage crash.  b/8048597
 TEST_F(SnapshotCacheTest, CreateGreyCacheFromDisk) {
   LoadAllColorImagesIntoCache(true);
 
   // Remove color images from in-memory cache.
   SnapshotCache* cache = GetSnapshotCache();
 
-  if (!IsIPadIdiom() || experimental_flags::IsTabSwitcherEnabled())
-    [cache handleLowMemory];
+  TriggerMemoryWarning();
 
   // Request the creation of a grey image cache for all images.
   [cache createGreyCache:testSessions_];
 
   // Wait for them to be put into the grey image cache.
   WaitForGreyImagesInCache(kSessionCount);
 
   __block NSUInteger numberOfCallbacks = 0;
   for (NSUInteger i = 0; i < kSessionCount; ++i) {
     NSString* sessionID = [testSessions_ objectAtIndex:i];
@@ skipping 20 matching lines @@
   [sessionIDs addObject:[testSessions_ objectAtIndex:0]];
   [sessionIDs addObject:[testSessions_ objectAtIndex:1]];
   [sessionIDs addObject:[testSessions_ objectAtIndex:2]];
 
   SnapshotCache* cache = GetSnapshotCache();
 
   // Put 3 images in the cache.
   LoadColorImagesIntoCache(kNumImages, true);
   // Make sure the color images are only on disk, to ensure the background
   // thread is slow enough to queue up the requests.
-  if (!IsIPadIdiom() || experimental_flags::IsTabSwitcherEnabled())
-    [cache handleLowMemory];
+  TriggerMemoryWarning();
 
   // Enable the grey image cache.
   [cache createGreyCache:sessionIDs];
 
   // Request the grey versions
   __block BOOL firstCallbackCalled = NO;
   __block BOOL secondCallbackCalled = NO;
   __block BOOL thirdCallbackCalled = NO;
   [cache greyImageForSessionID:[testSessions_ objectAtIndex:0]
                       callback:^(UIImage*) {
@@ skipping 50 matching lines @@
   CGContextRef context = UIGraphicsGetCurrentContext();
   UIImage* image = GenerateRandomImage(context);
   UIGraphicsEndImageContext();
 
   // Add the image to the cache then call handle low memory to ensure the image
   // is read from disk instead of the in-memory cache.
   SnapshotCache* cache = GetSnapshotCache();
   NSString* const kSession = @"foo";
   [cache setImage:image withSessionID:kSession];
   FlushRunLoops();  // ensure the file is written to disk.
-  if (!IsIPadIdiom() || experimental_flags::IsTabSwitcherEnabled())
-    [cache handleLowMemory];
+  TriggerMemoryWarning();
 
   // Retrive the image and have the callback verify the size and scale.
   __block BOOL callbackComplete = NO;
   [cache retrieveImageForSessionID:kSession
                           callback:^(UIImage* imageFromDisk) {
                             EXPECT_EQ(image.size.width,
                                       imageFromDisk.size.width);
                             EXPECT_EQ(image.size.height,
                                       imageFromDisk.size.height);
                             EXPECT_EQ(image.scale, imageFromDisk.scale);
@@ skipping 15 matching lines @@
   CGContextRef context = UIGraphicsGetCurrentContext();
   UIImage* image = GenerateRandomImage(context);
   UIGraphicsEndImageContext();
 
   // Add the image to the cache then call handle low memory to ensure the image
   // is read from disk instead of the in-memory cache.
   SnapshotCache* cache = GetSnapshotCache();
   NSString* const kSession = @"foo";
   [cache setImage:image withSessionID:kSession];
   FlushRunLoops();  // ensure the file is written to disk.
-  if (!IsIPadIdiom() || experimental_flags::IsTabSwitcherEnabled())
-    [cache handleLowMemory];
+  TriggerMemoryWarning();
 
   // Verify the file was writted with @2x in the file name.
   base::FilePath retinaFile = [SnapshotCache imagePathForSessionID:kSession];
   EXPECT_TRUE(base::PathExists(retinaFile));
 
   // Delete the image.
   [cache removeImageWithSessionID:kSession];
   FlushRunLoops();  // ensure the file is removed.
 
   EXPECT_FALSE(base::PathExists(retinaFile));
 }
 
 }  // namespace