This adds a recovery mode to the diagnostics

chrome/browser/diagnostics/recon_diagnostics.cc

 // Copyright (c) 2012 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"
@@ skipping 307 matching lines @@
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DiskSpaceTest);
 };
 
 // Checks that a given json file can be correctly parsed.
 class JSONTest : public DiagnosticsTest {
  public:
+  enum FileImportance {
+    NON_CRITICAL,
+    CRITICAL
+  };
+
   JSONTest(const base::FilePath& path,
            const std::string& id,
            const std::string& name,
-           int64 max_file_size)
-      : DiagnosticsTest(id, name), path_(path), max_file_size_(max_file_size) {}
+           int64 max_file_size,
+           FileImportance importance)
+      : DiagnosticsTest(id, name),
+        path_(path),
+        max_file_size_(max_file_size),
+        importance_(importance) {}
 
   virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) OVERRIDE {
     if (!base::PathExists(path_)) {
-      RecordFailure(DIAG_RECON_FILE_NOT_FOUND, "File not found");
+      if (importance_ == CRITICAL) {
+        RecordOutcome(DIAG_RECON_FILE_NOT_FOUND,
+                      "File not found",
+                      DiagnosticsModel::TEST_FAIL_CONTINUE);
+      } else {
+        RecordOutcome(DIAG_RECON_FILE_NOT_FOUND_OK,
+                      "File not found (but that is OK)",
+                      DiagnosticsModel::TEST_OK);
+      }
       return true;
     }
     int64 file_size;
     if (!file_util::GetFileSize(path_, &file_size)) {
       RecordFailure(DIAG_RECON_CANNOT_OBTAIN_FILE_SIZE,
                     "Cannot obtain file size");
       return true;
     }
 
     if (file_size > max_file_size_) {
@@ skipping 20 matching lines @@
       return true;
     }
 
     RecordSuccess("File parsed OK");
     return true;
   }
 
  private:
   base::FilePath path_;
   int64 max_file_size_;
+  FileImportance importance_;
   DISALLOW_COPY_AND_ASSIGN(JSONTest);
 };
 
 }  // namespace
 
 DiagnosticsTest* MakeUserDirTest() { return new PathTest(kPathsToTest[0]); }
 
 DiagnosticsTest* MakeLocalStateFileTest() {
   return new PathTest(kPathsToTest[1]);
 }
@@ skipping 12 matching lines @@
 
 DiagnosticsTest* MakeOperatingSystemTest() { return new OperatingSystemTest(); }
 
 DiagnosticsTest* MakeConflictingDllsTest() { return new ConflictingDllsTest(); }
 
 DiagnosticsTest* MakeInstallTypeTest() { return new InstallTypeTest(); }
 
 DiagnosticsTest* MakePreferencesTest() {
   base::FilePath path = DiagnosticsTest::GetUserDefaultProfileDir();
   path = path.Append(chrome::kPreferencesFilename);
-  return new JSONTest(
-      path, kJSONProfileTest, "Profile JSON", 100 * kOneKilobyte);
+  return new JSONTest(path,
+                      kJSONProfileTest,
+                      "Profile JSON",
+                      100 * kOneKilobyte,
+                      JSONTest::CRITICAL);
 }
 
 DiagnosticsTest* MakeBookMarksTest() {
   base::FilePath path = DiagnosticsTest::GetUserDefaultProfileDir();
   path = path.Append(chrome::kBookmarksFileName);
-  return new JSONTest(
-      path, kJSONBookmarksTest, "Bookmarks JSON", 2 * kOneMegabyte);
+  return new JSONTest(path,
+                      kJSONBookmarksTest,
+                      "Bookmarks JSON",
+                      2 * kOneMegabyte,
+                      JSONTest::NON_CRITICAL);
 }
 
 DiagnosticsTest* MakeLocalStateTest() {
   base::FilePath path;
   PathService::Get(chrome::DIR_USER_DATA, &path);
   path = path.Append(chrome::kLocalStateFilename);
-  return new JSONTest(
-      path, kJSONLocalStateTest, "Local State JSON", 50 * kOneKilobyte);
+  return new JSONTest(path,
+                      kJSONLocalStateTest,
+                      "Local State JSON",
+                      50 * kOneKilobyte,
+                      JSONTest::CRITICAL);
 }
 
 }  // namespace diagnostics