This adds a recovery mode to the diagnostics

chrome/browser/diagnostics/diagnostics_model.cc

 // 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/diagnostics_model.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/diagnostics/diagnostics_test.h"
 #include "chrome/browser/diagnostics/recon_diagnostics.h"
 #include "chrome/browser/diagnostics/sqlite_diagnostics.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 
 namespace diagnostics {
 
+// This is the count of diagnostic tests on each platform.  This should
+// only be used by testing code.
+#if defined(OS_WIN)
+const int DiagnosticsModel::kDiagnosticsTestCount = 19;
+#elif defined(OS_MACOSX)
+const int DiagnosticsModel::kDiagnosticsTestCount = 16;
+#elif defined(OS_POSIX)
+#if defined(OS_CHROMEOS)
+const int DiagnosticsModel::kDiagnosticsTestCount = 19;
+#else
+const int DiagnosticsModel::kDiagnosticsTestCount = 17;
+#endif
+#endif
+
 namespace {
 
 // Embodies the commonalities of the model across platforms. It manages the
 // list of tests and can loop over them. The main job of the platform specific
 // code becomes:
 // 1- Inserting the appropriate tests into |tests_|
 // 2- Overriding RunTest() to wrap it with the appropriate fatal exception
 //    handler for the OS.
 // This class owns the all the tests and will only delete them upon
 // destruction.
@@ skipping 15 matching lines @@
 
   virtual void RunAll(DiagnosticsModel::Observer* observer) OVERRIDE {
     size_t test_count = tests_.size();
     for (size_t ix = 0; ix != test_count; ++ix) {
       bool do_next = RunTest(tests_[ix], observer, ix);
       ++tests_run_;
       if (!do_next)
         break;
     }
     if (observer)
-      observer->OnDoneAll(this);
+      observer->OnAllTestsDone(this);
   }
 
-  virtual const TestInfo& GetTest(size_t index) OVERRIDE {
+  virtual void RecoverAll(DiagnosticsModel::Observer* observer) OVERRIDE {
+    size_t test_count = tests_.size();
+    for (size_t i = 0; i != test_count; ++i) {
+      bool do_next = RunRecovery(tests_[i], observer, i);
+      if (!do_next)
+        break;
+    }
+    if (observer)
+      observer->OnAllRecoveryDone(this);
+  }
+
+  virtual const TestInfo& GetTest(size_t index) const OVERRIDE {
     return *tests_[index];
   }
 
+  virtual bool GetTestInfo(const std::string& id,
+                           const TestInfo** result) const OVERRIDE {
+    for (size_t i = 0; i < tests_.size(); i++) {
+      if (tests_[i]->GetId() == id) {
+        *result = tests_[i];
+        return true;
+      }
+    }
+    return false;
+  }
+
  protected:
-  // Run a particular test. Return false if no other tests should be run.
+  // Run a particular diagnostic test. Return false if no other tests should be
+  // run.
   virtual bool RunTest(DiagnosticsTest* test,
                        Observer* observer,
                        size_t index) {
     return test->Execute(observer, this, index);
   }
 
+  // Recover from a particular diagnostic test. Return false if no further
+  // recovery should be run.
+  virtual bool RunRecovery(DiagnosticsTest* test,
+                           Observer* observer,
+                           size_t index) {
+    return test->Recover(observer, this, index);
+  }
+
   typedef std::vector<DiagnosticsTest*> TestArray;
   TestArray tests_;
   int tests_run_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DiagnosticsModelImpl);
 };
 
 // Each platform can have their own tests. For the time being there is only
 // one test that works on all platforms.
@@ skipping 95 matching lines @@
 #if defined(OS_WIN)
   return new DiagnosticsModelWin();
 #elif defined(OS_MACOSX)
   return new DiagnosticsModelMac();
 #elif defined(OS_POSIX)
   return new DiagnosticsModelPosix();
 #endif
 }
 
 }  // namespace diagnostics