Warn by default when certain DLL conflicts exist on XP.

chrome/browser/enumerate_modules_model_win.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_ENUMERATE_MODULES_MODEL_WIN_H_
 #define CHROME_BROWSER_ENUMERATE_MODULES_MODEL_WIN_H_
 
 #include <utility>
 #include <vector>
 
@@ skipping 44 matching lines @@
   };
 
   // A bitmask with the possible resolutions for bad modules.
   enum RecommendedAction {
     NONE          = 0,
     INVESTIGATING = 1 << 0,
     UNINSTALL     = 1 << 1,
     DISABLE       = 1 << 2,
     UPDATE        = 1 << 3,
     SEE_LINK      = 1 << 4,
+    NOTIFY_USER   = 1 << 5,
+  };
+
+  // Which Windows OS is affected.
+  enum OperatingSystem {
+    ALL          = -1,
+    XP           = 1 << 0,
   };
 
   // The structure we populate when enumerating modules.
   struct Module {
     // The type of module found
     ModuleType type;
     // The module status (benign/bad/etc).
     ModuleStatus status;
     // The module path, not including filename.
     string16 location;
@@ skipping 19 matching lines @@
   // A vector typedef of all modules enumerated.
   typedef std::vector<Module> ModulesVector;
 
   // A structure we populate with the blacklist entries.
   struct BlacklistEntry {
     const char* filename;
     const char* location;
     const char* desc_or_signer;
     const char* version_from;  // Version where conflict started.
     const char* version_to;    // First version that works.
+    OperatingSystem os;  // Bitmask, representing what OS this entry applies to.
     RecommendedAction help_tip;
   };
 
   // A static function that normalizes the module information in the |module|
   // struct. Module information needs to be normalized before comparing against
   // the blacklist. This is because the same module can be described in many
   // different ways, ie. file paths can be presented in long/short name form,
   // and are not case sensitive on Windows. Also, the version string returned
   // can include appended text, which we don't want to use during comparison
   // against the blacklist.
@@ skipping 110 matching lines @@
 //
 // 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.
 //
 // This class can be used on the UI thread as it asynchronously offloads the
 // file work over to the FILE thread and reports back to the caller with a
 // notification.
 class EnumerateModulesModel {
  public:
+  // UMA histogram constants.
+  enum UmaModuleConflictHistogramOptions {
+    ACTION_BUBBLE_SHOWN = 0,
+    ACTION_BUBBLE_LEARN_MORE,
+    ACTION_MENU_LEARN_MORE,
+    ACTION_BOUNDARY, // Must be the last value.
+  };
+
   static EnumerateModulesModel* GetInstance();
 
+  // Record via UMA what the user selected.
+  static void RecordLearnMoreStat(bool from_menu);
+
   // Returns true if we should show the conflict notification. The conflict
   // notification is only shown once during the lifetime of the process.
   bool ShouldShowConflictWarning() const;
 
   // Called when the user has acknowledged the conflict notification.
   void AcknowledgeConflictNotification();
 
   // Returns the number of suspected bad modules found in the last scan.
   // Returns 0 if no scan has taken place yet.
   int suspected_bad_modules_detected() const {
     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() const {
     return confirmed_bad_modules_detected_;
   }
 
+  // Returns how many modules to notify the user about.
+  int modules_to_notify_about() const {
+    return modules_to_notify_about_;
+  }
+
   // 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;
   }
 
+  // Checks to see if a scanning task should be started and sets one off, if so.
+  void MaybePostScanningTask();
+
   // 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.
   base::ListValue* GetModuleList() const;
 
+  // Gets the Help Center URL for the first *notable* conflict module that we've
+  // elected to notify the user about.
+  GURL GetFirstNotableConflict();
+
  private:
   friend struct DefaultSingletonTraits<EnumerateModulesModel>;
   friend class ModuleEnumerator;
 
   EnumerateModulesModel();
   virtual ~EnumerateModulesModel();
 
   // Called on the UI thread when the helper class is done scanning.
   void DoneScanning();
 
@@ skipping 23 matching lines @@
   // True if we are currently scanning for modules.
   bool scanning_;
 
   // Whether the conflict notification has been acknowledged by the user.
   bool conflict_notification_acknowledged_;
 
   // The number of confirmed bad modules (not including suspected bad ones)
   // found during last scan.
   int confirmed_bad_modules_detected_;
 
+  // The number of bad modules the user needs to be aggressively notified about.
+  int modules_to_notify_about_;
+
   // 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_