Integrate about:conflicts with --diagnostics...

chrome/browser/enumerate_modules_model_win.cc

-// 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.
 
 #include "chrome/browser/enumerate_modules_model_win.h"
 
 #include <Tlhelp32.h>
 #include <wintrust.h>
 
 #include "app/l10n_util.h"
 #include "app/win/win_util.h"
@@ skipping 107 matching lines @@
 
   // idmmbc.dll (IDM), "%systemroot%\\system32\\". See: http://crbug.com/26892/.
   { "b8dce5c3", "23d01d5b", "", "", "6.03",
       static_cast<RecommendedAction>(UPDATE | DISABLE) },
 
   // imon.dll (NOD32), "%systemroot%\\system32\\". See: http://crbug.com/21715.
   { "8f42f22e", "23d01d5b", "", "", "4.0",
       static_cast<RecommendedAction>(UPDATE | DISABLE) },
 
   // is3lsp.dll, "%commonprogramfiles%\\is3\\anti-spyware\\".
-  { "7ffbdce9", "bc5673f2", "", "", "", INVESTIGATING },
+  { "7ffbdce9", "bc5673f2", "", "", "",
+      static_cast<RecommendedAction>(UPDATE | DISABLE | SEE_LINK) },
 
   // jsi.dll, "%programfiles%\\profilecraze\\".
   { "f9555eea", "e3548061", "", "", "", kUninstallLink },
 
   // kernel.dll, "%programfiles%\\contentwatch\\internet protection\\modules\\".
   { "ead2768e", "4e61ce60", "", "", "", INVESTIGATING },
 
   // mgking0.dll, "%systemroot%\\system32\\".
   { "d0893e38", "23d01d5b", "", "", "", kUninstallLink },
 
@@ skipping 144 matching lines @@
 
     if (version_ok) {
       // At this point, the names match and there is no version specified
       // or the versions also match.
 
       std::string desc_or_signer(blacklisted.desc_or_signer);
       std::string signer_hash, description_hash;
       GenerateHash(WideToUTF8(module.digital_signer), &signer_hash);
       GenerateHash(WideToUTF8(module.description), &description_hash);
 
-      // If signatures match, we have a winner.
-      if (!desc_or_signer.empty() && signer_hash == desc_or_signer)
+      // If signatures match (or both are empty), then we have a winner.
+      if (signer_hash == desc_or_signer)
         return CONFIRMED_BAD;
 
-      // If description matches and location, then we also have a match.
-      if (!desc_or_signer.empty() && description_hash == desc_or_signer &&
+      // If descriptions match (or both are empty) and the locations match, then
+      // we also have a confirmed match.
+      if (description_hash == desc_or_signer &&
           !location_hash.empty() && location_hash == blacklisted.location) {
         return CONFIRMED_BAD;
       }
 
       // We are not sure, but it is likely bad.
       return SUSPECTED_BAD;
     }
   }
 
   return NOT_MATCHED;
 }
 
 ModuleEnumerator::ModuleEnumerator(EnumerateModulesModel* observer)
     : observer_(observer),
+      limited_mode_(false),
       callback_thread_id_(BrowserThread::ID_COUNT) {
 }
 
 ModuleEnumerator::~ModuleEnumerator() {
 }
 
-void ModuleEnumerator::ScanNow(ModulesVector* list) {
-  CHECK(BrowserThread::GetCurrentThreadIdentifier(&callback_thread_id_));
-  DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::FILE));
+void ModuleEnumerator::ScanNow(ModulesVector* list, bool limited_mode) {
   enumerated_modules_ = list;
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-          NewRunnableMethod(this, &ModuleEnumerator::ScanOnFileThread));
+
+  limited_mode_ = limited_mode;
+
+  if (!limited_mode_) {
+    CHECK(BrowserThread::GetCurrentThreadIdentifier(&callback_thread_id_));
+    DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::FILE));
+    BrowserThread::PostTask(
+        BrowserThread::FILE, FROM_HERE,
+            NewRunnableMethod(this, &ModuleEnumerator::ScanImpl));
+  } else {
+    // Run it synchronously.
+    ScanImpl();
+  }
 }
 
-void ModuleEnumerator::ScanOnFileThread() {
+void ModuleEnumerator::ScanImpl() {
   base::TimeTicks start_time = base::TimeTicks::Now();
 
   enumerated_modules_->clear();
 
   // Make sure the path mapping vector is setup so we can collapse paths.
   PreparePathMappings();
 
   base::TimeTicks checkpoint = base::TimeTicks::Now();
 
   // Enumerating loaded modules must happen first since the other types of
@@ skipping 10 matching lines @@
   checkpoint = base::TimeTicks::Now();
   EnumerateWinsockModules();
   HISTOGRAM_TIMES("Conflicts.EnumerateWinsockModules",
                   base::TimeTicks::Now() - checkpoint);
 
   MatchAgainstBlacklist();
 
   std::sort(enumerated_modules_->begin(),
             enumerated_modules_->end(), ModuleSort);
 
-  // Send a reply back on the UI thread.
-  BrowserThread::PostTask(
-      callback_thread_id_, FROM_HERE,
-      NewRunnableMethod(this, &ModuleEnumerator::ReportBack));
+  if (!limited_mode_) {
+    // Send a reply back on the UI thread.
+    BrowserThread::PostTask(
+        callback_thread_id_, FROM_HERE,
+        NewRunnableMethod(this, &ModuleEnumerator::ReportBack));
+  } else {
+    // We are on the main thread already.
+    ReportBack();
+  }
 
   HISTOGRAM_TIMES("Conflicts.EnumerationTotalTime",
                   base::TimeTicks::Now() - start_time);
 }
 
 void ModuleEnumerator::EnumerateLoadedModules() {
   // Get all modules in the current process.
   ScopedHandle snap(::CreateToolhelp32Snapshot(TH32CS_SNAPMODULE,
                     ::GetCurrentProcessId()));
   if (!snap.Get())
@@ skipping 203 matching lines @@
     if (module->status == NOT_MATCHED || module->status == GOOD) {
       if (StartsWith(module->location, L"%temp%", false) ||
           StartsWith(module->location, L"%tmp%", false)) {
         module->status = SUSPECTED_BAD;
       }
     }
   }
 }
 
 void ModuleEnumerator::ReportBack() {
-  DCHECK(BrowserThread::CurrentlyOn(callback_thread_id_));
+  if (!limited_mode_)
+    DCHECK(BrowserThread::CurrentlyOn(callback_thread_id_));
   observer_->DoneScanning();
 }
 
 string16 ModuleEnumerator::GetSubjectNameFromDigitalSignature(
     const FilePath& filename) {
   HCERTSTORE store = NULL;
   HCRYPTMSG message = NULL;
 
   // Find the crypto message for this filename.
   bool result = !!CryptQueryObject(CERT_QUERY_OBJECT_FILE,
@@ skipping 89 matching lines @@
     return;  // A scan is already in progress.
 
   lock->Acquire();  // Balanced in DoneScanning();
 
   scanning_ = true;
 
   // Instruct the ModuleEnumerator class to load this on the File thread.
   // ScanNow does not block.
   if (!module_enumerator_)
     module_enumerator_ = new ModuleEnumerator(this);
-  module_enumerator_->ScanNow(&enumerated_modules_);
+  module_enumerator_->ScanNow(&enumerated_modules_, limited_mode_);
 }
 
 ListValue* EnumerateModulesModel::GetModuleList() {
   if (scanning_)
     return NULL;
 
   lock->Acquire();
 
   if (enumerated_modules_.empty()) {
     lock->Release();
@@ skipping 12 matching lines @@
       // Module is not loaded, denote type of module.
       if (module->type & ModuleEnumerator::SHELL_EXTENSION)
         type_string = ASCIIToWide("Shell Extension");
       if (module->type & ModuleEnumerator::WINSOCK_MODULE_REGISTRATION) {
         if (!type_string.empty())
           type_string += ASCIIToWide(", ");
         type_string += ASCIIToWide("Winsock");
       }
       // Must be one of the above type.
       DCHECK(!type_string.empty());
-      type_string += ASCIIToWide(" -- ");
-      type_string += l10n_util::GetStringUTF16(IDS_CONFLICTS_NOT_LOADED_YET);
+      if (!limited_mode_) {
+        type_string += ASCIIToWide(" -- ");
+        type_string += l10n_util::GetStringUTF16(IDS_CONFLICTS_NOT_LOADED_YET);
+      }
     }
     data->SetString("type_description", type_string);
     data->SetInteger("status", module->status);
     data->SetString("location", module->location);
     data->SetString("name", module->name);
     data->SetString("product_name", module->product_name);
     data->SetString("description", module->description);
     data->SetString("version", module->version);
     data->SetString("digital_signer", module->digital_signer);
 
-    // Figure out the possible resolution help string.
-    string16 actions;
-    string16 separator = ASCIIToWide(" ") + l10n_util::GetStringUTF16(
-        IDS_CONFLICTS_CHECK_POSSIBLE_ACTION_SEPERATOR) +
-        ASCIIToWide(" ");
+    if (!limited_mode_) {
+      // Figure out the possible resolution help string.
+      string16 actions;
+      string16 separator = ASCIIToWide(" ") + l10n_util::GetStringUTF16(
+          IDS_CONFLICTS_CHECK_POSSIBLE_ACTION_SEPERATOR) +
+          ASCIIToWide(" ");
 
-    if (module->recommended_action & ModuleEnumerator::NONE) {
-      actions = l10n_util::GetStringUTF16(
-          IDS_CONFLICTS_CHECK_INVESTIGATING);
+      if (module->recommended_action & ModuleEnumerator::NONE) {
+        actions = l10n_util::GetStringUTF16(
+            IDS_CONFLICTS_CHECK_INVESTIGATING);
+      }
+      if (module->recommended_action & ModuleEnumerator::UNINSTALL) {
+        if (!actions.empty())
+          actions += separator;
+        actions = l10n_util::GetStringUTF16(
+            IDS_CONFLICTS_CHECK_POSSIBLE_ACTION_UNINSTALL);
+      }
+      if (module->recommended_action & ModuleEnumerator::UPDATE) {
+        if (!actions.empty())
+          actions += separator;
+        actions += l10n_util::GetStringUTF16(
+            IDS_CONFLICTS_CHECK_POSSIBLE_ACTION_UPDATE);
+      }
+      if (module->recommended_action & ModuleEnumerator::DISABLE) {
+        if (!actions.empty())
+          actions += separator;
+        actions += l10n_util::GetStringUTF16(
+            IDS_CONFLICTS_CHECK_POSSIBLE_ACTION_DISABLE);
+      }
+      string16 possible_resolution = actions.empty() ? ASCIIToWide("") :
+          l10n_util::GetStringUTF16(IDS_CONFLICTS_CHECK_POSSIBLE_ACTIONS) +
+          ASCIIToWide(" ") +
+          actions;
+      data->SetString("possibleResolution", possible_resolution);
+      data->SetString("help_url",
+                      ConstructHelpCenterUrl(*module).spec().c_str());
     }
-    if (module->recommended_action & ModuleEnumerator::UNINSTALL) {
-      if (!actions.empty())
-        actions += separator;
-      actions = l10n_util::GetStringUTF16(
-          IDS_CONFLICTS_CHECK_POSSIBLE_ACTION_UNINSTALL);
-    }
-    if (module->recommended_action & ModuleEnumerator::UPDATE) {
-      if (!actions.empty())
-        actions += separator;
-      actions += l10n_util::GetStringUTF16(
-          IDS_CONFLICTS_CHECK_POSSIBLE_ACTION_UPDATE);
-    }
-    if (module->recommended_action & ModuleEnumerator::DISABLE) {
-      if (!actions.empty())
-        actions += separator;
-      actions += l10n_util::GetStringUTF16(
-          IDS_CONFLICTS_CHECK_POSSIBLE_ACTION_DISABLE);
-    }
-    string16 possible_resolution = actions.empty() ? ASCIIToWide("") :
-        l10n_util::GetStringUTF16(IDS_CONFLICTS_CHECK_POSSIBLE_ACTIONS) +
-        ASCIIToWide(" ") +
-        actions;
-    data->SetString("possibleResolution", possible_resolution);
-    data->SetString("help_url", ConstructHelpCenterUrl(*module).spec().c_str());
 
     list->Append(data);
   }
 
   lock->Release();
   return list;
 }
 
 EnumerateModulesModel::EnumerateModulesModel()
     : scanning_(false),
+      limited_mode_(false),
       confirmed_bad_modules_detected_(0),
       suspected_bad_modules_detected_(0) {
   const CommandLine& cmd_line = *CommandLine::ForCurrentProcess();
   if (cmd_line.HasSwitch(switches::kConflictingModulesCheck)) {
     check_modules_timer_.Start(
         base::TimeDelta::FromMilliseconds(kModuleCheckDelayMs),
         this, &EnumerateModulesModel::ScanNow);
   }
 
   lock = new Lock();
@@ skipping 16 matching lines @@
   }
 
   scanning_ = false;
   lock->Release();
 
   HISTOGRAM_COUNTS_100("Conflicts.SuspectedBadModules",
                        suspected_bad_modules_detected_);
   HISTOGRAM_COUNTS_100("Conflicts.ConfirmedBadModules",
                        confirmed_bad_modules_detected_);
 
-  NotificationService::current()->Notify(
-      NotificationType::MODULE_LIST_ENUMERATED,
-      Source<EnumerateModulesModel>(this),
-      NotificationService::NoDetails());
+  if (!limited_mode_) {
+    NotificationService::current()->Notify(
+        NotificationType::MODULE_LIST_ENUMERATED,
+        Source<EnumerateModulesModel>(this),
+        NotificationService::NoDetails());
 
-  if (suspected_bad_modules_detected_ || confirmed_bad_modules_detected_) {
-    bool found_confirmed_bad_modules = confirmed_bad_modules_detected_  > 0;
-    NotificationService::current()->Notify(
-        NotificationType::MODULE_INCOMPATIBILITY_DETECTED,
-        Source<EnumerateModulesModel>(this),
-        Details<bool>(&found_confirmed_bad_modules));
+    if (suspected_bad_modules_detected_ || confirmed_bad_modules_detected_) {
+      bool found_confirmed_bad_modules = confirmed_bad_modules_detected_  > 0;
+      NotificationService::current()->Notify(
+          NotificationType::MODULE_INCOMPATIBILITY_DETECTED,
+          Source<EnumerateModulesModel>(this),
+          Details<bool>(&found_confirmed_bad_modules));
+    }
   }
 }
 
 GURL EnumerateModulesModel::ConstructHelpCenterUrl(
     const ModuleEnumerator::Module& module) {
   if (!(module.recommended_action & ModuleEnumerator::SEE_LINK))
     return GURL();
 
   // Construct the needed hashes.
   std::string filename, location, description, signer;
   GenerateHash(WideToUTF8(module.name), &filename);
   GenerateHash(WideToUTF8(module.location), &location);
   GenerateHash(WideToUTF8(module.description), &description);
   GenerateHash(WideToUTF8(module.digital_signer), &signer);
 
   string16 url = l10n_util::GetStringF(IDS_HELP_CENTER_VIEW_CONFLICTS,
       ASCIIToWide(filename), ASCIIToWide(location),
       ASCIIToWide(description), ASCIIToWide(signer));
   return GURL(WideToUTF8(url));
 }