Avoid useless SYNC_CYCLE_CONTINUATION sync cycle

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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace browser_sync {
 
 namespace {
 
 void CallDoWorkAndSignalCallback(const WorkCallback& work,
                                  base::WaitableEvent* work_done,
                                  UIModelWorker* const scheduler,
-                                 UnrecoverableErrorInfo* error_info) {
+                                 SyncerError* error_info) {
   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;
   }
   *error_info = work.Run();
 
   // Notify the UIModelWorker that scheduled us that we have run
   // successfully.
   scheduler->OnTaskCompleted();
   work_done->Signal();  // Unblock the syncer thread that scheduled us.
 }
 
 }  // namespace
 
-UnrecoverableErrorInfo UIModelWorker::DoWorkAndWaitUntilDone(
+SyncerError 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;
+  SyncerError error_info;
   if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     DLOG(WARNING) << "DoWorkAndWaitUntilDone called from "
       << "ui_loop_. Probably a nested invocation?";
     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_.is_null());
-    UnrecoverableErrorInfo error_info;
     pending_work_ = base::Bind(&CallDoWorkAndSignalCallback, work, &work_done,
                                base::Unretained(this), &error_info);
     if (!BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, pending_work_)) {
       LOG(WARNING) << "Could not post work to UI loop.";
       pending_work_.Reset();
       syncapi_event_.Signal();
       return error_info;
     }
   }
   syncapi_event_.Signal();  // Notify that the syncapi produced work for us.
@@ skipping 46 matching lines @@
 
   state_ = STOPPED;
 }
 
 ModelSafeGroup UIModelWorker::GetModelSafeGroup() {
   return GROUP_UI;
 }
 
 
 }  // namespace browser_sync