Integrate about:conflicts with --diagnostics...

chrome/browser/enumerate_modules_model_win.h

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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_ENUMERATE_MODULES_MODEL_WIN_H_
 #define CHROME_BROWSER_ENUMERATE_MODULES_MODEL_WIN_H_
 #pragma once
 
 #include <utility>
 #include <vector>
 
@@ skipping 100 matching lines @@
   static void NormalizeModule(Module* module);
 
   // A static function that checks whether |module| has been |blacklisted|.
   static ModuleStatus Match(const Module& module,
                             const BlacklistEntry& blacklisted);
 
   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, but
-  // will notify when done through the MODULE_LIST_ENUMERATED notification.
+  // progress). This function does not block while reading the module list
+  // (unless we are in limited_mode, see below), and will notify when done
+  // through the MODULE_LIST_ENUMERATED notification.
   // The process will also send MODULE_INCOMPATIBILITY_DETECTED if an
   // incompatible module was detected.
-  void ScanNow(ModulesVector* list);
+  // When in |limited_mode|, this function will not leverage the File thread
+  // to run asynchronously and will therefore block until scanning is done
+  // (and will also not send out any notifications).
+  void ScanNow(ModulesVector* list, bool limited_mode);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(EnumerateModulesTest, CollapsePath);
 
   // The (currently) hard coded blacklist of known bad modules.
   static const BlacklistEntry kModuleBlacklist[];
 
-  // This function does the actual file scanning work on the FILE thread. 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, it calls
-  // ReportBack to let the observer know we are done.
-  void ScanOnFileThread();
+  // This function does the actual file scanning work on the FILE thread (or
+  // block the main thread when in limited_mode). 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, it calls ReportBack to let the observer
+  // know we are done.
+  void ScanImpl();
 
   // Enumerate all modules loaded into the Chrome process.
   void EnumerateLoadedModules();
 
   // Enumerate all registered Windows shell extensions.
   void EnumerateShellExtensions();
 
   // Enumerate all registered Winsock LSP modules.
   void EnumerateWinsockModules();
 
@@ skipping 42 matching lines @@
   // 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, who needs to be notified when we are done.
   EnumerateModulesModel* observer_;
 
+  // See limited_mode below.
+  bool limited_mode_;
+
   // The thread that we need to call back on to report that we are done.
   BrowserThread::ID callback_thread_id_;
 
   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
@@ skipping 15 matching lines @@
   int suspected_bad_modules_detected() {
     return suspected_bad_modules_detected_;
   }
 
   // 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() {
     return confirmed_bad_modules_detected_;
   }
 
-  // Asynchronously start the scan for the loaded module list.
-  // When the list is ready.
+  // Set to true when we the scanning process can not rely on certain Chrome
+  // services to exists.
+  void set_limited_mode(bool limited_mode) {
+    limited_mode_ = limited_mode;
+  }
+
+  // Asynchronously start the scan for the loaded module list, except when in
+  // limited_mode (in which case it blocks).
   void ScanNow();
 
   // Gets the whole module list as a ListValue.
   ListValue* GetModuleList();
 
  private:
   friend struct DefaultSingletonTraits<EnumerateModulesModel>;
   friend class ModuleEnumerator;
 
   EnumerateModulesModel();
@@ skipping 11 matching lines @@
   // any bad modules will be marked.
   ModuleEnumerator::ModulesVector enumerated_modules_;
 
   // The object responsible for enumerating the modules on the File thread.
   scoped_refptr<ModuleEnumerator> module_enumerator_;
 
   // When this singleton object is constructed we go and fire off this timer to
   // start scanning for modules after a certain amount of time has passed.
   base::OneShotTimer<EnumerateModulesModel> check_modules_timer_;
 
+  // While normally |false|, this mode can be set to indicate that the scanning
+  // process should not rely on certain services normally available to Chrome,
+  // such as the resource bundle and the notification system, not to mention
+  // having multiple threads. This mode is useful during diagnostics, which
+  // runs without firing up all necessary Chrome services first.
+  bool limited_mode_;
+
   // True if we are currently scanning for modules.
   bool scanning_;
 
   // The number of confirmed bad modules (not including suspected bad ones)
   // found during last scan.
   int confirmed_bad_modules_detected_;
 
   // The number of suspected bad modules (not including confirmed bad ones)
   // found during last scan.
   int suspected_bad_modules_detected_;
 
   DISALLOW_COPY_AND_ASSIGN(EnumerateModulesModel);
 };
 
 #endif  // CHROME_BROWSER_ENUMERATE_MODULES_MODEL_WIN_H_