Revert 105404 - [Sync] Refactor non-frontend DTC to handle new API properly.

chrome/browser/sync/glue/non_frontend_data_type_controller.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/non_frontend_data_type_controller.h"
 
-#include "base/bind.h"
-#include "base/callback.h"
 #include "base/logging.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/api/sync_error.h"
 #include "chrome/browser/sync/glue/change_processor.h"
 #include "chrome/browser/sync/glue/model_associator.h"
 #include "chrome/browser/sync/profile_sync_factory.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/syncable/model_type.h"
 #include "content/browser/browser_thread.h"
 
@@ skipping 36 matching lines @@
     delete start_callback;
     return;
   }
 
   start_callback_.reset(start_callback);
   abort_association_ = false;
 
   state_ = MODEL_STARTING;
   if (!StartModels()) {
     // If we are waiting for some external service to load before associating
-    // or we failed to start the models, we exit early.
+    // or we failed to start the models, we exit early. state_ will control
+    // what we perform next.
     DCHECK(state_ == NOT_RUNNING || state_ == MODEL_STARTING);
     return;
   }
 
   // Kick off association on the thread the datatype resides on.
   state_ = ASSOCIATING;
   if (!StartAssociationAsync()) {
     SyncError error(FROM_HERE, "Failed to post StartAssociation", type());
     StartDoneImpl(ASSOCIATION_FAILED, DISABLED, error);
   }
@@ skipping 34 matching lines @@
   base::TimeTicks start_time = base::TimeTicks::Now();
   SyncError error;
   bool merge_success = model_associator_->AssociateModels(&error);
   RecordAssociationTime(base::TimeTicks::Now() - start_time);
   if (!merge_success) {
     StartFailed(ASSOCIATION_FAILED, error);
     return;
   }
 
   profile_sync_service_->ActivateDataType(type(), model_safe_group(),
-                                          change_processor());
+                                          change_processor_.get());
   StartDone(!sync_has_nodes ? OK_FIRST_RUN : OK, RUNNING, SyncError());
 }
 
 void NonFrontendDataTypeController::StartFailed(StartResult result,
                                                 const SyncError& error) {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
   model_associator_.reset();
   change_processor_.reset();
   StartDone(result,
             result == ASSOCIATION_FAILED ? DISABLED : NOT_RUNNING,
             error);
 }
 
 void NonFrontendDataTypeController::StartDone(
     DataTypeController::StartResult result,
     DataTypeController::State new_state,
     const SyncError& error) {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
   abort_association_complete_.Signal();
   base::AutoLock lock(abort_association_lock_);
   if (!abort_association_) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-        base::Bind(&NonFrontendDataTypeController::StartDoneImpl,
-                   this,
-                   result,
-                   new_state,
-                   error));
+        NewRunnableMethod(
+            this,
+            &NonFrontendDataTypeController::StartDoneImpl,
+            result,
+            new_state,
+            error));
   }
 }
 
 void NonFrontendDataTypeController::StartDoneImpl(
     DataTypeController::StartResult result,
     DataTypeController::State new_state,
     const SyncError& error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  // It's possible to have StartDoneImpl called first from the UI thread
-  // (due to Stop being called) and then posted from the non-UI thread. In
-  // this case, we drop the second call because we've already been stopped.
+
   if (state_ == NOT_RUNNING) {
+    // During stop it is possible startdoneimpl can be called twice. Once from
+    // the |StartDone| method and once from the |Stop| method.
     DCHECK(!start_callback_.get());
     return;
   }
-
   state_ = new_state;
   if (state_ != RUNNING) {
     // Start failed.
     StopModels();
     RecordStartFailure(result);
   }
 
   // We have to release the callback before we call it, since it's possible
   // invoking the callback will trigger a call to STOP(), which will get
   // confused by the non-NULL start_callback_.
   scoped_ptr<StartCallback> callback(start_callback_.release());
   callback->Run(result, error);
 }
 
-// TODO(sync): Blocking the UI thread at shutdown is bad. The new API avoids
-// this. Once all non-frontend datatypes use the new API, we can get rid of this
-// locking (see implementation in AutofillProfileDataTypeController).
+// TODO(sync): Blocking the UI thread at shutdown is bad. If we had a way of
+// distinguishing chrome shutdown from sync shutdown, we should be able to avoid
+// this (http://crbug.com/55662).
 void NonFrontendDataTypeController::Stop() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // If Stop() is called while Start() is waiting for association to
   // complete, we need to abort the association and wait for the DB
   // thread to finish the StartImpl() task.
   if (state_ == ASSOCIATING) {
     state_ = STOPPING;
     {
       base::AutoLock lock(abort_association_lock_);
       abort_association_ = true;
@@ skipping 56 matching lines @@
 
 DataTypeController::State NonFrontendDataTypeController::state() const {
   return state_;
 }
 
 void NonFrontendDataTypeController::OnUnrecoverableError(
     const tracked_objects::Location& from_here,
     const std::string& message) {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
   RecordUnrecoverableError(from_here, message);
-  BrowserThread::PostTask(BrowserThread::UI, from_here,
-      base::Bind(&NonFrontendDataTypeController::OnUnrecoverableErrorImpl,
-                 this,
-                 from_here,
-                 message));
+  BrowserThread::PostTask(BrowserThread::UI, from_here, NewRunnableMethod(this,
+      &NonFrontendDataTypeController::OnUnrecoverableErrorImpl, from_here,
+      message));
 }
 
 void NonFrontendDataTypeController::OnUnrecoverableErrorImpl(
     const tracked_objects::Location& from_here,
     const std::string& message) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   profile_sync_service_->OnUnrecoverableError(from_here, message);
 }
 
 ProfileSyncFactory* NonFrontendDataTypeController::profile_sync_factory()
     const {
   return profile_sync_factory_;
 }
 
 Profile* NonFrontendDataTypeController::profile() const {
   return profile_;
 }
 
 ProfileSyncService* NonFrontendDataTypeController::profile_sync_service()
     const {
   return profile_sync_service_;
 }
 
-void NonFrontendDataTypeController::set_start_callback(
-    StartCallback* callback) {
-  start_callback_.reset(callback);
-}
 void NonFrontendDataTypeController::set_state(State state) {
   state_ = state;
 }
 
-AssociatorInterface* NonFrontendDataTypeController::associator() const {
-  return model_associator_.get();
-}
-
 void NonFrontendDataTypeController::set_model_associator(
     AssociatorInterface* associator) {
   model_associator_.reset(associator);
 }
 
-ChangeProcessor* NonFrontendDataTypeController::change_processor() const {
-  return change_processor_.get();
-}
-
 void NonFrontendDataTypeController::set_change_processor(
     ChangeProcessor* change_processor) {
   change_processor_.reset(change_processor);
 }
 
 }  // namespace browser_sync