Integrate about:conflicts with --diagnostics...

chrome/browser/diagnostics/recon_diagnostics.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/diagnostics/recon_diagnostics.h"
 
 #include <string>
 
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/string_util.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "base/path_service.h"
 #include "chrome/browser/diagnostics/diagnostics_test.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/json_value_serializer.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
+#include "chrome/browser/enumerate_modules_model_win.h"
 #include "chrome/installer/util/install_util.h"
 #endif
 
 // Reconnaissance diagnostics. These are the first and most critical
 // diagnostic tests. Here we check for the existence of critical files.
 // TODO(cpu): Define if it makes sense to localize strings.
 
-// TODO(cpu): There are a few maxium file sizes hardcoded in this file
+// TODO(cpu): There are a few maximum file sizes hardcoded in this file
 // that have little or no theoretical or experimental ground. Find a way
 // to justify them.
 
 namespace {
 
 class InstallTypeTest;
 InstallTypeTest* g_install_type = 0;
 
 // Check that the flavor of the operating system is supported.
 class OperatingSystemTest : public DiagnosticTest {
@@ skipping 11 matching lines @@
     if (version < base::win::VERSION_XP) {
       RecordFailure(ASCIIToUTF16("Windows 2000 or earlier"));
       return false;
     }
     base::win::GetServicePackLevel(&major, &minor);
     if ((version == base::win::VERSION_XP) && (major < 2)) {
       RecordFailure(ASCIIToUTF16("XP Service Pack 1 or earlier"));
       return false;
     }
 #else
-    // TODO(port): define the OS criteria for linux and mac.
+    // TODO(port): define the OS criteria for Linux and Mac.
 #endif  // defined(OS_WIN)
     RecordSuccess(ASCIIToUTF16(StringPrintf("%s %s (%d [%d:%d])",
         base::SysInfo::OperatingSystemName().c_str(),
         base::SysInfo::OperatingSystemVersion().c_str(),
         version, major, minor)));
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(OperatingSystemTest);
 };
 
+// Check if any conflicting DLLs are loaded.
+class ConflictingDllsTest : public DiagnosticTest {
+ public:
+  ConflictingDllsTest() : DiagnosticTest(ASCIIToUTF16("Conflicting modules")) {}
+
+  virtual int GetId() { return 0; }
+
+  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) {
+#if defined(OS_WIN)
+    EnumerateModulesModel* model = EnumerateModulesModel::GetInstance();
+    model->set_limited_mode(true);
+    model->ScanNow();
+    ListValue* list = model->GetModuleList();
+    if (!model->confirmed_bad_modules_detected() &&
+        !model->suspected_bad_modules_detected()) {
+      RecordSuccess(ASCIIToUTF16("No conflicting modules found"));
+      return true;
+    }
+
+    string16 failures = ASCIIToUTF16("Possibly conflicting modules:");
+    DictionaryValue* dictionary;
+    for (size_t i = 0; i < list->GetSize(); ++i) {
+      list->GetDictionary(i, &dictionary);
+      int status;
+      string16 location;
+      string16 name;
+      if (!dictionary->GetInteger("status", &status))
+        RecordFailure(ASCIIToUTF16("No 'status' field found"));
+      if (status < ModuleEnumerator::SUSPECTED_BAD)
+        continue;
+
+      if (!dictionary->GetString("location", &location)) {
+        RecordFailure(ASCIIToUTF16("No 'location' field found"));
+        return true;
+      }
+      if (!dictionary->GetString("name", &name)) {
+        RecordFailure(ASCIIToUTF16("No 'name' field found"));
+        return true;
+      }
+
+      failures += ASCIIToUTF16("\n") + location + name;
+    }
+    RecordFailure(failures);
+    return true;
+#else
+    RecordFailure(ASCIIToUTF16("Not implemented"));
+    return true;
+#endif  // defined(OS_WIN)
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ConflictingDllsTest);
+};
+
 // Check if it is system install or per-user install.
 class InstallTypeTest : public DiagnosticTest {
  public:
   InstallTypeTest() : DiagnosticTest(ASCIIToUTF16("Install Type")),
                       user_level_(false) {}
 
   virtual int GetId() { return 0; }
 
   virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) {
 #if defined(OS_WIN)
@@ skipping 69 matching lines @@
   {"User data Directory", chrome::DIR_USER_DATA,
       true, false, true, 850 * kOneMeg},
   {"Local state file", chrome::FILE_LOCAL_STATE,
       false, false, true, 500 * kOneKilo},
   {"Dictionaries Directory", chrome::DIR_APP_DICTIONARIES,
       true, true, false, 0},
   {"Inspector Directory", chrome::DIR_INSPECTOR,
       true, false, false, 0}
 };
 
-// Check that the user's data directory exists and the paths are writeable.
-// If it is a systemwide install some paths are not expected to be writeable.
-// This test depends on |InstallTypeTest| having run succesfuly.
+// Check that the user's data directory exists and the paths are writable.
+// If it is a systemwide install some paths are not expected to be writable.
+// This test depends on |InstallTypeTest| having run successfully.
 class PathTest : public DiagnosticTest {
  public:
   explicit PathTest(const TestPathInfo& path_info)
       : DiagnosticTest(ASCIIToUTF16(path_info.test_name)),
         path_info_(path_info) {}
 
   virtual int GetId() { return 0; }
 
   virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) {
     if (!g_install_type) {
@@ skipping 41 matching lines @@
                   + printable_size);
     return true;
   }
 
  private:
   TestPathInfo path_info_;
   DISALLOW_COPY_AND_ASSIGN(PathTest);
 };
 
 // Check that the disk space in the volume where the user data dir normally
-// lives is not dangerosly low.
+// lives is not dangerously low.
 class DiskSpaceTest : public DiagnosticTest {
  public:
   DiskSpaceTest() : DiagnosticTest(ASCIIToUTF16("Disk Space")) {}
 
   virtual int GetId() { return 0; }
 
   virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) {
     FilePath data_dir;
     if (!PathService::Get(chrome::DIR_USER_DATA, &data_dir))
       return false;
@@ skipping 89 matching lines @@
 }
 
 DiagnosticTest* MakeDiskSpaceTest() {
   return new DiskSpaceTest();
 }
 
 DiagnosticTest* MakeOperatingSystemTest() {
   return new OperatingSystemTest();
 }
 
+DiagnosticTest* MakeConflictingDllsTest() {
+  return new ConflictingDllsTest();
+}
+
 DiagnosticTest* MakeInstallTypeTest() {
   return new InstallTypeTest();
 }
 
 DiagnosticTest* MakePreferencesTest() {
   FilePath path = DiagnosticTest::GetUserDefaultProfileDir();
   path = path.Append(chrome::kPreferencesFilename);
   return new JSONTest(path, ASCIIToUTF16("Profile JSON"), 100 * kOneKilo);
 }
 
 DiagnosticTest* MakeBookMarksTest() {
   FilePath path = DiagnosticTest::GetUserDefaultProfileDir();
   path = path.Append(chrome::kBookmarksFileName);
   return new JSONTest(path, ASCIIToUTF16("BookMarks JSON"), 2 * kOneMeg);
 }
 
 DiagnosticTest* MakeLocalStateTest() {
   FilePath path;
   PathService::Get(chrome::DIR_USER_DATA, &path);
   path = path.Append(chrome::kLocalStateFilename);
   return new JSONTest(path, ASCIIToUTF16("Local State JSON"), 50 * kOneKilo);
 }