[reland] Use TaskScheduler instead of SequencedWorkerPool in snapshot_cache.mm.

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/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/mac/bind_objc_block.h"
 #include "base/mac/objc_property_releaser.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/task_runner_util.h"
+#include "base/task_scheduler/post_task.h"
 #include "base/threading/thread_restrictions.h"
 #include "ios/chrome/browser/experimental_flags.h"
 #import "ios/chrome/browser/snapshots/lru_cache.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 ()
 // Returns the directory where the thumbnails are saved.
@@ skipping 14 matching lines @@
 // |mostRecentGreyBlock_| if |mostRecentGreySessionId_| matches |sessionID|.
 - (void)saveGreyImage:(UIImage*)greyImage forKey:(NSString*)sessionID;
 @end
 
 namespace {
 static NSArray* const kSnapshotCacheDirectory = @[ @"Chromium", @"Snapshots" ];
 
 const NSUInteger kCacheInitialCapacity = 100;
 const NSUInteger kGreyInitialCapacity = 8;
 const CGFloat kJPEGImageQuality = 1.0;  // Highest quality. No compression.
-// Sequence token to make sure creation/deletion of snapshots don't overlap.
-const char kSequenceToken[] = "SnapshotCacheSequenceToken";
 // Maximum size in number of elements that the LRU cache can hold before
 // starting to evict elements.
 const NSUInteger kLRUCacheMaxCapacity = 6;
 
+struct SnapshotTaskRunner {
+  const scoped_refptr<base::SequencedTaskRunner> task_runner =
+      base::CreateSequencedTaskRunnerWithTraits(
+          {base::MayBlock(), base::TaskPriority::USER_VISIBLE});
+};
+
+// Sequence token to make sure creation/deletion of snapshots don't overlap.
+base::LazyInstance<SnapshotTaskRunner>::Leaky g_snapshot_task_runner =
+    LAZY_INSTANCE_INITIALIZER;
+
 // The paths of the images saved to disk, given a cache directory.
 base::FilePath FilePathForSessionID(NSString* sessionID,
                                     const base::FilePath& directory) {
   base::FilePath path = directory.Append(base::SysNSStringToUTF8(sessionID))
                             .ReplaceExtension(".jpg");
   if ([SnapshotCache snapshotScaleForDevice] == 2.0) {
     path = path.InsertBeforeExtension("@2x");
   } else if ([SnapshotCache snapshotScaleForDevice] == 3.0) {
     path = path.InsertBeforeExtension("@3x");
   }
@@ skipping 197 matching lines @@
   DCHECK_CURRENTLY_ON(web::WebThread::UI);
   if (!img || !sessionID)
     return;
 
   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(^{
+  g_snapshot_task_runner.Get().task_runner->PostTask(
+      FROM_HERE, base::BindBlock(^{
         base::scoped_nsobject<UIImage> image([img retain]);
         WriteImageToDisk(image,
                          [SnapshotCache imagePathForSessionID:sessionID]);
       }));
 }
 
 - (void)removeImageWithSessionID:(NSString*)sessionID {
   DCHECK_CURRENTLY_ON(web::WebThread::UI);
   if (lruCache_)
     [lruCache_ removeObjectForKey:sessionID];
   else
     [imageDictionary_ removeObjectForKey:sessionID];
 
-  web::WebThread::PostBlockingPoolSequencedTask(
-      kSequenceToken, FROM_HERE,
-      base::BindBlock(^{
+  g_snapshot_task_runner.Get().task_runner->PostTask(
+      FROM_HERE, base::BindBlock(^{
         base::FilePath imagePath =
             [SnapshotCache imagePathForSessionID:sessionID];
         base::DeleteFile(imagePath, false);
         base::DeleteFile([SnapshotCache greyImagePathForSessionID:sessionID],
                          false);
       }));
 }
 
 - (base::FilePath)oldCacheDirectory {
   DCHECK_CURRENTLY_ON(web::WebThread::UI);
@@ skipping 43 matching lines @@
     DCHECK(result);
   }
   return GreyFilePathForSessionID(sessionID, path);
 }
 
 - (void)purgeCacheOlderThan:(const base::Time&)date
                     keeping:(NSSet*)liveSessionIds {
   DCHECK_CURRENTLY_ON(web::WebThread::UI);
   // Copying the date, as the block must copy the value, not the reference.
   const base::Time dateCopy = date;
-  web::WebThread::PostBlockingPoolSequencedTask(
-      kSequenceToken, FROM_HERE,
-      base::BindBlock(^{
+  g_snapshot_task_runner.Get().task_runner->PostTask(
+      FROM_HERE, base::BindBlock(^{
         std::set<base::FilePath> filesToKeep;
         for (NSString* sessionID : liveSessionIds) {
           base::FilePath curImagePath =
               [SnapshotCache imagePathForSessionID:sessionID];
           filesToKeep.insert(curImagePath);
           filesToKeep.insert(
               [SnapshotCache greyImagePathForSessionID:sessionID]);
         }
         base::FileEnumerator enumerator([SnapshotCache cacheDirectory], false,
                                         base::FileEnumerator::FILES);
@@ skipping 194 matching lines @@
       FilePathForSessionID(sessionID, [SnapshotCache cacheDirectory]);
 
   // The color image may still be in memory.  Verify the sessionID matches.
   if (backgroundingColorImage_) {
     if (![backgroundingImageSessionId_ isEqualToString:sessionID]) {
       backgroundingColorImage_.reset();
       backgroundingImageSessionId_.reset();
     }
   }
 
-  web::WebThread::PostBlockingPoolTask(
-      FROM_HERE, base::Bind(&ConvertAndSaveGreyImage, colorImagePath,
-                            greyImagePath, backgroundingColorImage_));
+  base::PostTaskWithTraits(
+      FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_VISIBLE},
+      base::BindOnce(&ConvertAndSaveGreyImage, colorImagePath, greyImagePath,
+                     backgroundingColorImage_));
 }
 
 @end
 
 @implementation SnapshotCache (TestingAdditions)
 
 - (BOOL)hasImageInMemory:(NSString*)sessionID {
   if ([self usesLRUCache])
     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