Introduce the plumbing necessary to report Unrecoverable error from model safe workers.

chrome/browser/sync/glue/ui_model_worker.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_SYNC_GLUE_UI_MODEL_WORKER_H_
 #define CHROME_BROWSER_SYNC_GLUE_UI_MODEL_WORKER_H_
 #pragma once
 
 #include "base/callback.h"
+#include "base/compiler_specific.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/task.h"
 #include "chrome/browser/sync/engine/model_safe_worker.h"
+#include "chrome/browser/sync/util/unrecoverable_error_info.h"
 
 namespace base {
 class WaitableEvent;
 }
 
 class MessageLoop;
 
 namespace browser_sync {
 
 // A ModelSafeWorker for UI models (e.g. bookmarks) that accepts work requests
 // from the syncapi that need to be fulfilled from the MessageLoop home to the
 // native model.
 //
 // Lifetime note: Instances of this class will generally be owned by the
 // SyncerThread. When the SyncerThread _object_ is destroyed, the
 // UIModelWorker will be destroyed. The SyncerThread object is destroyed
 // after the actual syncer pthread has exited.
 class UIModelWorker : public browser_sync::ModelSafeWorker {
  public:
   UIModelWorker();
   virtual ~UIModelWorker();
 
   // A simple task to signal a waitable event after Run()ning a Closure.
   class CallDoWorkAndSignalTask : public Task {
    public:
-    CallDoWorkAndSignalTask(Callback0::Type* work,
-                            base::WaitableEvent* work_done,
-                            UIModelWorker* scheduler)
-        : work_(work), work_done_(work_done), scheduler_(scheduler) {
+    CallDoWorkAndSignalTask(
+        const WorkCallback& work,
+        base::WaitableEvent* work_done,
+        UIModelWorker* scheduler,
+        UnrecoverableErrorInfo* error_info)
+        : work_(work), work_done_(work_done), scheduler_(scheduler),
+          error_info_(error_info) {
     }
     virtual ~CallDoWorkAndSignalTask() { }
 
     // Task implementation.
     virtual void Run();
 
    private:
     // Task data - a closure and a waitable event to signal after the work has
     // been done.
-    Callback0::Type* work_;
+    WorkCallback work_;
     base::WaitableEvent* work_done_;
 
     // The UIModelWorker responsible for scheduling us.
     UIModelWorker* const scheduler_;
 
+    UnrecoverableErrorInfo* error_info_;
+
     DISALLOW_COPY_AND_ASSIGN(CallDoWorkAndSignalTask);
   };
 
   // Called by the UI thread on shutdown of the sync service. Blocks until
   // the UIModelWorker has safely met termination conditions, namely that
   // no task scheduled by CallDoWorkFromModelSafeThreadAndWait remains un-
   // processed and that syncapi will not schedule any further work for us to do.
   void Stop();
 
   // ModelSafeWorker implementation. Called on syncapi SyncerThread.
-  virtual void DoWorkAndWaitUntilDone(Callback0::Type* work);
-  virtual ModelSafeGroup GetModelSafeGroup();
+  virtual UnrecoverableErrorInfo DoWorkAndWaitUntilDone(
+      const WorkCallback& work) OVERRIDE;
+  virtual ModelSafeGroup GetModelSafeGroup() OVERRIDE;
 
   // Upon receiving this idempotent call, the ModelSafeWorker can
   // assume no work will ever be scheduled again from now on. If it has any work
   // that it has not yet completed, it must make sure to run it as soon as
   // possible as the Syncer is trying to shut down. Called from the CoreThread.
   void OnSyncerShutdownComplete();
 
   // Callback from |pending_work_| to notify us that it has been run.
   // Called on ui loop.
   void OnTaskCompleted() { pending_work_ = NULL; }
@@ skipping 42 matching lines @@
   // SyncerThread has terminated. We only care about (1) when we are in Stop(),
   // because we have to manually Run() the task.
   base::ConditionVariable syncapi_event_;
 
   DISALLOW_COPY_AND_ASSIGN(UIModelWorker);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_UI_MODEL_WORKER_H_