Make module enumeration a low priority background task.

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 137 matching lines @@
   // enumeration is complete. |observer| must outlive the ModuleEnumerator.
   explicit ModuleEnumerator(EnumerateModulesModel* observer);
 
   ~ModuleEnumerator();
 
   // Start scanning the loaded module list (if a scan is not already in
   // progress). This function does not block while reading the module list and
   // 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 does the actual file scanning work in the blocking pool. It
-  // enumerates all loaded modules in the process and other modules of interest,
-  // such as the registered Winsock LSP modules and stores them in
-  // |enumerated_modules_|. It then normalizes the module info and matches them
-  // against a blacklist of known bad modules. Finally, notifies the observer
-  // that the enumeration is complete by invoking DoneScanning.
-  void ScanImpl();
+  // 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.
+  void ScanImplStart();
 
-  // Enumerate all modules loaded into the Chrome process.
+  // 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();
+
+  // Enumerate all modules loaded into the Chrome process. Creates empty
+  // entries in |enumerated_modules_| with a populated |location| field.
   void EnumerateLoadedModules();
 
-  // Enumerate all registered Windows shell extensions.
+  // Enumerate all registered Windows shell extensions. Creates empty
+  // entries in |enumerated_modules_| with a populated |location| field.
   void EnumerateShellExtensions();
 
-  // Enumerate all registered Winsock LSP modules.
+  // Enumerate all registered Winsock LSP modules. Creates empty
+  // entries in |enumerated_modules_| with a populated |location| field.
   void EnumerateWinsockModules();
 
   // Reads the registered shell extensions found under |parent| key in the
-  // registry.
+  // registry. Creates empty entries in |enumerated_modules_| with a populated
+  // |location| field.
   void ReadShellExtensions(HKEY parent);
 
   // Given a |module|, initializes the structure and loads additional
   // information using the location field of the module.
   void PopulateModuleInformation(Module* module);
 
   // Checks the module list to see if a |module| of the same type, location
   // and name has been added before and if so, increments its duplication
   // counter. If it doesn't appear in the list, it is added.
   void AddToListWithoutDuplicating(const Module&);
 
   // Builds up a vector of path values mapping to environment variable,
   // with pairs like [c:\windows\, %systemroot%]. This is later used to
   // collapse paths like c:\windows\system32 into %systemroot%\system32, which
   // we can use for comparison against our blacklist (which uses only env vars).
   // NOTE: The vector will not contain an exhaustive list of environment
   // variables, only the ones currently found on the blacklist or ones that are
   // likely to appear there.
   void PreparePathMappings();
 
   // For a given |module|, collapse the path from c:\windows to %systemroot%,
   // 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 ScanImpl after modules have been
-  // enumerated and processed.
+  // 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 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_;
 
+  // The delay that is observed between module inspection tasks. This is
+  // currently 1 second, which means it takes several minutes to iterate over
+  // all modules on average.
+  base::TimeDelta per_module_delay_;
+
+  // The amount of time taken for on-disk module inspection. Reported in
+  // ScanImplFinish.
+  base::TimeDelta enumeration_inspection_time_;
+
+  // The total amount of time taken for module enumeration. Reported in
+  // ScanImplFinish.
+  base::TimeDelta enumeration_total_time_;
+
   DISALLOW_COPY_AND_ASSIGN(ModuleEnumerator);
 };
 
 // This is a singleton class that enumerates all modules loaded into Chrome,
 // 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().
@@ skipping 55 matching lines @@
   int suspected_bad_modules_detected() const;
 
   // Returns the number of confirmed bad modules found in the last scan.
   // Returns 0 if no scan has taken place yet.
   int confirmed_bad_modules_detected() const;
 
   // Returns how many modules to notify the user about.
   int modules_to_notify_about() const;
 
   // Checks to see if a scanning task should be started and sets one off, if so.
+  // This will cause ScanNow to be invoked in background mode.
   void MaybePostScanningTask();
 
-  // Asynchronously start the scan for the loaded module list.
-  void ScanNow();
+  // Asynchronously start the scan for the loaded module list. If
+  // |background_mode| is true the scan will happen slowly over a process of
+  // minutes, spread across dozens or even hundreds of delayed tasks. Otherwise
+  // the processing will occur in a single task.
+  void ScanNow(bool background_mode);
 
   // Gets the whole module list as a ListValue.
   base::ListValue* GetModuleList();
 
   // Returns the site to which the user should be taken when the conflict bubble
   // or app menu item is clicked. For now this is simply chrome://conflicts,
   // which contains detailed information about conflicts. Returns an empty URL
   // if there are no conficts. May only be called on UI thread.
   GURL GetConflictUrl();
 
@@ skipping 35 matching lines @@
   // 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_