Use TaskScheduler instead of WorkerPool in keystone_glue.mm.

chrome/browser/mac/keystone_glue.mm

 // Copyright (c) 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 "chrome/browser/mac/keystone_glue.h"
 
 #include <sys/mount.h>
 #include <sys/param.h>
 #include <sys/stat.h>
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/mac/authorization_util.h"
 #include "base/mac/bundle_locations.h"
 #include "base/mac/foundation_util.h"
 #include "base/mac/mac_logging.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/sys_string_conversions.h"
-#include "base/threading/worker_pool.h"
+#include "base/task_scheduler/post_task.h"
 #include "build/build_config.h"
 #import "chrome/browser/mac/keystone_registration.h"
 #include "chrome/common/channel_info.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/version_info/version_info.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/l10n_util_mac.h"
 
@@ skipping 18 matching lines @@
 NSString* kBrandUserFile = @"~/Library/Google/" kBrandFileName;
 NSString* kBrandSystemFile = @"/Library/Google/" kBrandFileName;
 
 NSString* UserBrandFilePath() {
   return [kBrandUserFile stringByStandardizingPath];
 }
 NSString* SystemBrandFilePath() {
   return [kBrandSystemFile stringByStandardizingPath];
 }
 
-// Adaptor for scheduling an Objective-C method call on a |WorkerPool|
-// thread.
+// Adaptor for scheduling an Objective-C method call in TaskScheduler.
 class PerformBridge : public base::RefCountedThreadSafe<PerformBridge> {
  public:
 
   // Call |sel| on |target| with |arg| in a WorkerPool thread.
   // |target| and |arg| are retained, |arg| may be |nil|.
   static void PostPerform(id target, SEL sel, id arg) {
     DCHECK(target);
     DCHECK(sel);
 
     scoped_refptr<PerformBridge> op = new PerformBridge(target, sel, arg);
-    base::WorkerPool::PostTask(
-        FROM_HERE, base::Bind(&PerformBridge::Run, op.get()), true);
+    base::PostTaskWithTraits(
+        FROM_HERE, base::TaskTraits()
+                       .WithFileIO()
+                       .WithPriority(base::TaskPriority::BACKGROUND)
+                       .WithShutdownBehavior(
+                           base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),

[Mark Mentovai, 2016/11/29 21:56:06]

Revise change description to match this.

[fdoray, 2016/11/30 19:25:21]

Done.

+        base::Bind(&PerformBridge::Run, op.get()));
   }
 
   // Convenience for the no-argument case.
   static void PostPerform(id target, SEL sel) {
     PostPerform(target, sel, nil);
   }
 
  private:
   // Allow RefCountedThreadSafe<> to delete.
   friend class base::RefCountedThreadSafe<PerformBridge>;
@@ skipping 614 matching lines @@
   NSDictionary* infoPlist =
       [NSDictionary dictionaryWithContentsOfFile:appInfoPlistPath];
   return base::mac::ObjCCast<NSString>(
       [infoPlist objectForKey:@"CFBundleShortVersionString"]);
 }
 
 // Runs on the main thread.
 - (void)determineUpdateStatusAsync {
   DCHECK([NSThread isMainThread]);
 
   PerformBridge::PostPerform(self, @selector(determineUpdateStatus));

[Mark Mentovai, 2016/11/29 21:56:06]

I think that this one could be SKIP_ON_SHUTDOWN…

[fdoray, 2016/11/30 19:25:21]

Are you sure?

CONTINUE_ON_SHUTDOWN tasks are not scheduled during shutdown. Shutdown may
complete and the process may be terminated while they are still running.

SKIP_ON_SHUTDOWN tasks are not scheduled during shutdown. If a SKIP_ON_SHUTDOWN
task was already running when shutdown started, shutdown won't complete and the
process won't be terminated before it completes.

BLOCK_SHUTDOWN tasks are guaranteed to run to completion if they are posted
before shutdown completes.

[Mark Mentovai, 2016/11/30 19:53:00]

OK, that’s confusing terminology to me, but it sounds like CONTINUE_ON_SHUTDOWN
is right for this one.

 }
 
 // Runs on a thread managed by WorkerPool.
 - (void)determineUpdateStatus {
   DCHECK(![NSThread isMainThread]);
 
   NSString* version = [self currentlyInstalledVersion];
 
   [self performSelectorOnMainThread:@selector(determineUpdateStatusForVersion:)
                          withObject:version
@@ skipping 339 matching lines @@
   // on the main thread before jumping over to a WorkerPool-managed
   // thread to run the tool.
   DCHECK([NSThread isMainThread]);
 
   SEL selector = @selector(changePermissionsForPromotionWithTool:);
   NSString* toolPath =
       [base::mac::FrameworkBundle()
           pathForResource:@"keystone_promote_postflight"
                    ofType:@"sh"];
 
   PerformBridge::PostPerform(self, selector, toolPath);

[Mark Mentovai, 2016/11/29 21:56:06]

…but this one should be CONTINUE_ON_SHUTDOWN, because it’s concerned with
continuing and completing a task that’s in progress.

[fdoray, 2016/11/30 19:25:21]

You want to make sure that this task runs to completion? Then it should be
BLOCK_SHUTDOWN.

Problem: The main thread stops running tasks before TaskScheduler shutdown
starts. This line
https://cs.chromium.org/chromium/src/chrome/browser/mac/keystone_glue.mm?l=1096
is a no-op if it runs during or after TaskScheduler shutdown. Therefore,
TaskScheduler shutdown should not be blocked on this task.

[Mark Mentovai, 2016/11/30 19:53:00]

Yes, that’s what I was saying.
Oh well, then. OK.

 }
 
 - (void)changePermissionsForPromotionWithTool:(NSString*)toolPath {
   const char* toolPathC = [toolPath fileSystemRepresentation];
 
   const char* appPathC = [appPath_ fileSystemRepresentation];
   const char* arguments[] = {appPathC, NULL};
 
   int exit_status;
   OSStatus status = base::mac::ExecuteWithPrivilegesAndWait(
@@ skipping 109 matching lines @@
   return [KeystoneGlue defaultKeystoneGlue] != nil;
 }
 
 base::string16 CurrentlyInstalledVersion() {
   KeystoneGlue* keystoneGlue = [KeystoneGlue defaultKeystoneGlue];
   NSString* version = [keystoneGlue currentlyInstalledVersion];
   return base::SysNSStringToUTF16(version);
 }
 
 }  // namespace keystone_glue