[ObjC ARC] Converts ios/chrome/browser/snapshots:unit_tests to ARC.

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/location.h"
 #include "base/mac/bind_objc_block.h"
 #include "base/mac/scoped_cftyperef.h"
-#include "base/mac/scoped_nsautorelease_pool.h"
-#include "base/mac/scoped_nsobject.h"
 #include "base/run_loop.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/task_scheduler/task_scheduler.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time/time.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"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 static const NSUInteger kSessionCount = 10;
 static const NSUInteger kSnapshotPixelSize = 8;
 
 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]);
-    testSessions_.reset(
-        [[NSMutableArray alloc] initWithCapacity:kSessionCount]);
+    snapshotCache_ = [[SnapshotCache alloc] init];
+    testImages_ = [[NSMutableArray alloc] initWithCapacity:kSessionCount];
+    testSessions_ = [[NSMutableArray alloc] initWithCapacity:kSessionCount];
 
     CGFloat scale = [snapshotCache_ snapshotScaleForDevice];
     UIGraphicsBeginImageContextWithOptions(
         CGSizeMake(kSnapshotPixelSize, kSnapshotPixelSize), NO, scale);
     CGContextRef context = UIGraphicsGetCurrentContext();
     srand(1);
 
     for (NSUInteger i = 0; i < kSessionCount; ++i) {
       UIImage* image = GenerateRandomImage(context);
       [testImages_ addObject:image];
       [testSessions_
           addObject:[NSString stringWithFormat:@"SessionId-%" PRIuNS, i]];
     }
 
     UIGraphicsEndImageContext();
 
     ClearDumpedImages();
   }
 
   void TearDown() override {
     ClearDumpedImages();
     [snapshotCache_ shutdown];
-    snapshotCache_.reset();
+    snapshotCache_ = nil;
     PlatformTest::TearDown();
   }
 
-  SnapshotCache* GetSnapshotCache() {
-    return snapshotCache_.get();
-  }
+  SnapshotCache* GetSnapshotCache() { return snapshotCache_; }
 
   // Generates an image filled with a random color.
   UIImage* GenerateRandomImage(CGContextRef context) {
     CGFloat r = rand() / CGFloat(RAND_MAX);
     CGFloat g = rand() / CGFloat(RAND_MAX);
     CGFloat b = rand() / CGFloat(RAND_MAX);
     CGContextSetRGBStrokeColor(context, r, g, b, 1.0);
     CGContextSetRGBFillColor(context, r, g, b, 1.0);
     CGContextFillRect(
         context, CGRectMake(0.0, 0.0, kSnapshotPixelSize, kSnapshotPixelSize));
     return UIGraphicsGetImageFromCurrentImageContext();
   }
 
   // Flushes all the runloops internally used by the snapshot cache.
   void FlushRunLoops() {
     base::TaskScheduler::GetInstance()->FlushForTesting();
     base::RunLoop().RunUntilIdle();
   }
 
   // This function removes the snapshots both from dictionary and from disk.
   void ClearDumpedImages() {
     SnapshotCache* cache = GetSnapshotCache();
 
     NSString* sessionID;
-    for (sessionID in testSessions_.get())
+    for (sessionID in testSessions_)
       [cache removeImageWithSessionID:sessionID];
 
     FlushRunLoops();
     // The above calls to -removeImageWithSessionID remove both the color
     // and grey snapshots for each sessionID, if they are on disk.  However,
     // ensure we also get rid of the grey snapshots in memory.
     [cache removeGreyCache];
 
     __block BOOL foundImage = NO;
     __block NSUInteger numCallbacks = 0;
-    for (sessionID in testSessions_.get()) {
+    for (sessionID in testSessions_) {
       base::FilePath path([cache imagePathForSessionID:sessionID]);
 
       // Checks that the snapshot is not on disk.
       EXPECT_FALSE(base::PathExists(path));
 
       // Check that the snapshot is not in the dictionary.
       [cache retrieveImageForSessionID:sessionID
                               callback:^(UIImage* image) {
                                 ++numCallbacks;
                                 if (image)
@@ skipping 12 matching lines @@
   void LoadAllColorImagesIntoCache(bool waitForFilesOnDisk) {
     LoadColorImagesIntoCache(kSessionCount, waitForFilesOnDisk);
   }
 
   // Loads |count| color images into the cache.  If |waitForFilesOnDisk|
   // is YES, will not return until the images have been written to disk.
   void LoadColorImagesIntoCache(NSUInteger count, bool waitForFilesOnDisk) {
     SnapshotCache* cache = GetSnapshotCache();
     // Put color images in the cache.
     for (NSUInteger i = 0; i < count; ++i) {
-      base::mac::ScopedNSAutoreleasePool pool;
-      UIImage* image = [testImages_ objectAtIndex:i];
-      NSString* sessionID = [testSessions_ objectAtIndex:i];
-      [cache setImage:image withSessionID:sessionID];
+      @autoreleasepool {
+        UIImage* image = [testImages_ objectAtIndex:i];
+        NSString* sessionID = [testSessions_ objectAtIndex:i];
+        [cache setImage:image withSessionID:sessionID];
+      }
     }
     if (waitForFilesOnDisk) {
       FlushRunLoops();
       for (NSUInteger i = 0; i < count; ++i) {
         // Check that images are on the disk.
         NSString* sessionID = [testSessions_ objectAtIndex:i];
         base::FilePath path([cache imagePathForSessionID:sessionID]);
         EXPECT_TRUE(base::PathExists(path));
       }
     }
@@ skipping 43 matching lines @@
     // _performMemoryWarning is a private API and must not be compiled into
     // official builds.
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wundeclared-selector"
     [[UIApplication sharedApplication]
         performSelector:@selector(_performMemoryWarning)];
 #pragma clang diagnostic pop
   }
 
   web::TestWebThreadBundle thread_bundle_;
-  base::scoped_nsobject<SnapshotCache> snapshotCache_;
-  base::scoped_nsobject<NSMutableArray> testSessions_;
-  base::scoped_nsobject<NSMutableArray> testImages_;
+  SnapshotCache* snapshotCache_;
+  NSMutableArray* testSessions_;
+  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) {
   SnapshotCache* cache = GetSnapshotCache();
 
   NSUInteger expectedCacheSize = MIN(kSessionCount, [cache lruCacheMaxSize]);
 
@@ skipping 211 matching lines @@
 }
 #endif  // !TARGET_IPHONE_SIMULATOR
 
 // Tests mostRecentGreyBlock, which is a block to be called when the most
 // recently requested grey image is finally loaded.
 // The test requests three images be cached as grey images.  Only the final
 // callback of the three requests should be called.
 // Disabled due to the greyImage crash.  b/8048597
 TEST_F(SnapshotCacheTest, MostRecentGreyBlock) {
   const NSUInteger kNumImages = 3;
-  base::scoped_nsobject<NSMutableArray> sessionIDs(
-      [[NSMutableArray alloc] initWithCapacity:kNumImages]);
+  NSMutableArray* sessionIDs =
+      [[NSMutableArray alloc] initWithCapacity:kNumImages];
   [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.
@@ skipping 36 matching lines @@
 
   // Now convert every image into a grey image, on disk, in the background.
   for (NSUInteger i = 0; i < kSessionCount; ++i) {
     [cache saveGreyInBackgroundForSessionID:[testSessions_ objectAtIndex:i]];
   }
 
   // Waits for the grey images for the sessions in |testSessions_| to be written
   // to disk, which happens in a background thread.
   FlushRunLoops();
 
-  for (NSString* sessionID in testSessions_.get()) {
+  for (NSString* sessionID in testSessions_) {
     base::FilePath path([cache greyImagePathForSessionID:sessionID]);
     EXPECT_TRUE(base::PathExists(path));
     base::DeleteFile(path, false);
   }
 }
 
 // Verifies that image size and scale are preserved when writing and reading
 // from disk.
 TEST_F(SnapshotCacheTest, SizeAndScalePreservation) {
   SnapshotCache* cache = GetSnapshotCache();
@@ skipping 54 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