Make sync's change processors sequence-affine.

components/sync/driver/shared_change_processor.h

 // Copyright 2014 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 COMPONENTS_SYNC_DRIVER_SHARED_CHANGE_PROCESSOR_H_
 #define COMPONENTS_SYNC_DRIVER_SHARED_CHANGE_PROCESSOR_H_
 
 #include <memory>
 #include <string>
 
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
+#include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"

[gab, 2016/12/20 20:11:29]

rm?

[fdoray, 2016/12/20 20:34:39]

Still needed for |frontend_task_runner_|.

 #include "base/synchronization/lock.h"
 #include "components/sync/driver/data_type_controller.h"
 #include "components/sync/engine/model_safe_worker.h"
 #include "components/sync/model/data_type_error_handler.h"
 #include "components/sync/model/sync_change_processor.h"
 #include "components/sync/model/sync_data.h"
 #include "components/sync/model/sync_error.h"
 #include "components/sync/model/sync_error_factory.h"
 #include "components/sync/model/sync_merge_result.h"
 
@@ skipping 46 matching lines @@
   // Note: If this SharedChangeProcessor has been disconnected, or the
   // SyncableService was not alive, will return a null weak pointer.
   virtual base::WeakPtr<SyncableService> Connect(
       SyncClient* sync_client,
       GenericChangeProcessorFactory* processor_factory,
       UserShare* user_share,
       std::unique_ptr<DataTypeErrorHandler> error_handler,
       const base::WeakPtr<SyncMergeResult>& merge_result);
 
   // Disconnects from the generic change processor. May be called from any
-  // thread. After this, all attempts to interact with the change processor by
+  // sequence. After this, all attempts to interact with the change processor by

[gab, 2016/12/20 20:11:29]

s/May be called from any thread./This method is thread-safe./

[fdoray, 2016/12/20 20:34:39]

Done.

   // |local_service_| are dropped and return errors. The syncer will be safe to
   // shut down from the point of view of this datatype.
   // Note: Once disconnected, you cannot reconnect without creating a new
   // SharedChangeProcessor.
   // Returns: true if we were previously succesfully connected, false if we were
   // already disconnected.
   virtual bool Disconnect();
 
   // GenericChangeProcessor stubs (with disconnect support).
-  // Should only be called on the same thread the datatype resides.
+  // Should only be called on the same sequence the datatype resides.
   virtual int GetSyncCount();
   virtual SyncError ProcessSyncChanges(
       const tracked_objects::Location& from_here,
       const SyncChangeList& change_list);
   virtual SyncDataList GetAllSyncData(ModelType type) const;
   virtual SyncError GetAllSyncDataReturnError(ModelType type,
                                               SyncDataList* data) const;
   virtual SyncError UpdateDataTypeContext(
       ModelType type,
       SyncChangeProcessor::ContextRefreshStatus refresh_status,
@@ skipping 33 matching lines @@
   mutable base::Lock monitor_lock_;
   bool disconnected_;
 
   // The sync datatype we process changes for.
   const ModelType type_;
 
   // The frontend / UI MessageLoop this object is constructed on. May also be
   // destructed and/or disconnected on this loop, see ~SharedChangeProcessor.
   const scoped_refptr<const base::SingleThreadTaskRunner> frontend_task_runner_;
 
-  // The loop that all methods except the constructor, destructor, and
-  // Disconnect() should be called on.  Set in Connect().
-  scoped_refptr<base::SingleThreadTaskRunner> backend_task_runner_;
+  // The sequence that all methods except the constructor, destructor, and
+  // Disconnect() should be called on. Set in Connect().
+  scoped_refptr<base::SequencedTaskRunner> backend_task_runner_;
 
-  // Used only on |backend_loop_|.
+  // Used only on |backend_task_runner_|.
   GenericChangeProcessor* generic_change_processor_;
 
   std::unique_ptr<DataTypeErrorHandler> error_handler_;
 
   // The local service for this type. Only set if the DTC for the type uses
   // SharedChangeProcessor::StartAssociation().
   base::WeakPtr<SyncableService> local_service_;
 
   DISALLOW_COPY_AND_ASSIGN(SharedChangeProcessor);
 };
 
 }  // namespace syncer
 
 #endif  // COMPONENTS_SYNC_DRIVER_SHARED_CHANGE_PROCESSOR_H_