Use TaskScheduler instead of blocking pool in enumerate_modules_model.cc.

chrome/browser/win/enumerate_modules_model.h

 // Copyright (c) 2011 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.
 
 #ifndef CHROME_BROWSER_WIN_ENUMERATE_MODULES_MODEL_H_
 #define CHROME_BROWSER_WIN_ENUMERATE_MODULES_MODEL_H_
 
 #include <memory>
 #include <utility>
 #include <vector>
@@ skipping 123 matching lines @@
   // will notify when done by calling the DoneScanning method of |observer_|.
   void ScanNow(ModulesVector* list);
 
   // Sets |per_module_delay_| to zero, causing the modules to be inspected
   // in realtime.
   void SetPerModuleDelayToZero();
 
  private:
   FRIEND_TEST_ALL_PREFIXES(EnumerateModulesTest, CollapsePath);
 
-  // This function enumerates all modules in the blocking pool. Once the list of
-  // module filenames is populated it posts a delayed task to call
-  // ScanImplDelay for the first module.
+  // This function posts a task to enumerate all modules asynchronously. Once
+  // the list of module filenames is populated, a delayed task is posted to scan
+  // the first module.
   void ScanImplStart();
 
-  // Immediately posts a CONTINUE_ON_SHUTDOWN task to ScanImplModule for the
-  // given module. This ping-ponging is because the blocking pool does not
-  // offer a delayed CONTINUE_ON_SHUTDOWN task.
-  // TODO(chrisha): When the new scheduler enables delayed CONTINUE_ON_SHUTDOWN
-  // tasks, simplify this logic.
-  void ScanImplDelay(size_t index);
-
   // Inspects the module in |enumerated_modules_| at the given |index|. Gets
   // module information, normalizes it, and collapses the path. This is an
   // expensive operation and non-critical. Posts a delayed task to ScanImplDelay
   // for the next module. When all modules are finished forwards directly to
   // ScanImplFinish.
   void ScanImplModule(size_t index);
 
   // Collects metrics and notifies the observer that the enumeration is complete
   // by invoking DoneScanning on the UI thread.
   void ScanImplFinish();
@@ skipping 37 matching lines @@
   // based on the |path_mapping_| vector.
   void CollapsePath(Module* module);
 
   // Reports (via UMA) a handful of high-level metrics regarding third party
   // modules in this process. Called by ScanImplFinish.
   void ReportThirdPartyMetrics();
 
   // The typedef for the vector that maps a regular file path to %env_var%.
   typedef std::vector<std::pair<base::string16, base::string16>> PathMapping;
 
+  // The TaskRunner to perform work in the background.
+  const scoped_refptr<base::TaskRunner> background_task_runner_;
+
   // The vector of paths to %env_var%, used to account for differences in
   // where people keep there files, c:\windows vs. d:\windows, etc.
   PathMapping path_mapping_;
 
   // The vector containing all the enumerated modules (loaded and modules of
   // interest).
   ModulesVector* enumerated_modules_;
 
   // The observer, which needs to be notified when the scan is complete.
   EnumerateModulesModel* observer_;
@@ skipping 18 matching lines @@
 // both currently loaded modules (called DLLs on Windows) and modules 'of
 // interest', such as WinSock LSP modules. This class also marks each module
 // as benign or suspected bad or outright bad, using a supplied blacklist that
 // is currently hard-coded.
 //
 // To use this class, grab the singleton pointer and call ScanNow().
 // Then wait to get notified through MODULE_LIST_ENUMERATED when the list is
 // ready.
 //
 // The member functions of this class may only be used from the UI thread. The
-// bulk of the work is actually performed in the blocking pool with
+// bulk of the work is actually performed asynchronously in TaskScheduler with
 // CONTINUE_ON_SHUTDOWN semantics, as the WinCrypt functions can effectively
 // block arbitrarily during shutdown.
 //
 // TODO(chrisha): If this logic is ever extended to other platforms, then make
 // this file generic for all platforms, and remove the precompiler logic in
 // app_menu_icon_controller.*.
 class EnumerateModulesModel {
  public:
   // UMA histogram constants.
   enum UmaModuleConflictHistogramOptions {
@@ skipping 72 matching lines @@
   EnumerateModulesModel();
   ~EnumerateModulesModel();
 
   // Called on the UI thread when the helper class is done scanning. The
   // ModuleEnumerator that calls this must not do any work after causing this
   // function to be called, as the EnumerateModulesModel may delete the
   // ModuleEnumerator.
   void DoneScanning();
 
   // The vector containing all the modules enumerated. Will be normalized and
-  // any bad modules will be marked. Written to from the blocking pool by the
-  // |module_enumerator_|, read from on the UI thread by this class.
+  // any bad modules will be marked. Written to from the background TaskRunner
+  // by
+  // the |module_enumerator_|, read from on the UI thread by this class.

[Finnur, 2017/02/21 10:45:55]

nit: These two lines can be consolidated.

[fdoray, 2017/02/22 18:53:06]

Done.

   ModuleEnumerator::ModulesVector enumerated_modules_;
 
-  // The object responsible for enumerating the modules in the blocking pool.
-  // Only used from the UI thread. This ends up internally doing its work in the
-  // blocking pool.
+  // The object responsible for enumerating the modules on a background
+  // TaskRunner. Only accessed from the UI thread.
   std::unique_ptr<ModuleEnumerator> module_enumerator_;
 
   // Whether the conflict notification has been acknowledged by the user. Only
   // modified on the UI thread.
   bool conflict_notification_acknowledged_;
 
   // The number of confirmed bad modules (not including suspected bad ones)
   // found during last scan. Only modified on the UI thread.
   int confirmed_bad_modules_detected_;
 
   // The number of bad modules the user needs to be aggressively notified about.
   // Only modified on the UI thread.
   int modules_to_notify_about_;
 
   // The number of suspected bad modules (not including confirmed bad ones)
   // found during last scan. Only modified on the UI thread.
   int suspected_bad_modules_detected_;
 
   base::ObserverList<Observer> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(EnumerateModulesModel);
 };
 
 #endif  // CHROME_BROWSER_WIN_ENUMERATE_MODULES_MODEL_H_