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

chrome/browser/sync/glue/ui_model_worker.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/sync/glue/ui_model_worker.h"
 
 #include "base/message_loop.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/synchronization/waitable_event.h"
 #include "content/browser/browser_thread.h"
 
 namespace browser_sync {
+using sessions::UnrecoverableErrorInfo;
 
-void UIModelWorker::DoWorkAndWaitUntilDone(Callback0::Type* work) {
+UnrecoverableErrorInfo UIModelWorker::DoWorkAndWaitUntilDone(
+    const WorkCallback& work) {
   // In most cases, this method is called in WORKING state. It is possible this
   // gets called when we are in the RUNNING_MANUAL_SHUTDOWN_PUMP state, because
   // the UI loop has initiated shutdown but the syncer hasn't got the memo yet.
   // This is fine, the work will get scheduled and run normally or run by our
   // code handling this case in Stop(). Note there _no_ way we can be in here
   // with state_ = STOPPED, so it is safe to read / compare in this case.
   CHECK_NE(ANNOTATE_UNPROTECTED_READ(state_), STOPPED);
-
+  UnrecoverableErrorInfo error_info;
   if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     DLOG(WARNING) << "DoWorkAndWaitUntilDone called from "
       << "ui_loop_. Probably a nested invocation?";
-    work->Run();
-    return;
+    return work.Run();
   }
 
   // Create an unsignaled event to wait on.
   base::WaitableEvent work_done(false, false);
   {
     // We lock only to avoid PostTask'ing a NULL pending_work_ (because it
     // could get Run() in Stop() and call OnTaskCompleted before we post).
     // The task is owned by the message loop as per usual.
     base::AutoLock lock(lock_);
     DCHECK(!pending_work_);
-    pending_work_ = new CallDoWorkAndSignalTask(work, &work_done, this);
+    UnrecoverableErrorInfo error_info;
+    pending_work_ = new CallDoWorkAndSignalTask(work, &work_done, this,
+                                                &error_info);
     if (!BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, pending_work_)) {
       LOG(WARNING) << "Could not post work to UI loop.";
       pending_work_ = NULL;
       syncapi_event_.Signal();
-      return;
+      return error_info;
     }
   }
   syncapi_event_.Signal();  // Notify that the syncapi produced work for us.
   work_done.Wait();
+  return error_info;
 }
 
 UIModelWorker::UIModelWorker()
     : state_(WORKING),
       pending_work_(NULL),
       syncapi_has_shutdown_(false),
       syncapi_event_(&lock_) {
 }
 
 UIModelWorker::~UIModelWorker() {
@@ skipping 34 matching lines @@
   }
 
   state_ = STOPPED;
 }
 
 ModelSafeGroup UIModelWorker::GetModelSafeGroup() {
   return GROUP_UI;
 }
 
 void UIModelWorker::CallDoWorkAndSignalTask::Run() {
-  if (!work_) {
+  if (work_.is_null()) {
     // This can happen during tests or cases where there are more than just the
     // default UIModelWorker in existence and it gets destroyed before
     // the main UI loop has terminated.  There is no easy way to assert the
     // loop is running / not running at the moment, so we just provide cancel
     // semantics here and short-circuit.
     // TODO(timsteele): Maybe we should have the message loop destruction
     // observer fire when the loop has ended, just a bit before it
     // actually gets destroyed.
     return;
   }
-  work_->Run();
+  *error_info_ = work_.Run();
 
   // Sever ties with work_ to allow the sanity-checking above that we don't
   // get run twice.
-  work_ = NULL;
+  work_.Reset();
 
   // Notify the UIModelWorker that scheduled us that we have run
   // successfully.
   scheduler_->OnTaskCompleted();
   work_done_->Signal();  // Unblock the syncer thread that scheduled us.
 }
 
 }  // namespace browser_sync