[Sync] Move //sync to //components/sync.

sync/internal_api/public/engine/model_safe_worker.h

Index: sync/internal_api/public/engine/model_safe_worker.h
diff --git a/sync/internal_api/public/engine/model_safe_worker.h b/sync/internal_api/public/engine/model_safe_worker.h
deleted file mode 100644
index 87662db834d7dcd909e9bf23e1bcf987e47c3ffd..0000000000000000000000000000000000000000
--- a/sync/internal_api/public/engine/model_safe_worker.h
+++ /dev/null
@@ -1,171 +0,0 @@
-// Copyright 2012 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 SYNC_INTERNAL_API_PUBLIC_ENGINE_MODEL_SAFE_WORKER_H_
-#define SYNC_INTERNAL_API_PUBLIC_ENGINE_MODEL_SAFE_WORKER_H_
-
-#include <map>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "base/callback.h"
-#include "base/memory/ref_counted.h"
-#include "base/message_loop/message_loop.h"
-#include "base/single_thread_task_runner.h"
-#include "base/synchronization/lock.h"
-#include "base/synchronization/waitable_event.h"
-#include "sync/base/sync_export.h"
-#include "sync/internal_api/public/base/model_type.h"
-#include "sync/internal_api/public/util/syncer_error.h"
-
-namespace base {
-class DictionaryValue;
-}  // namespace base
-
-namespace syncer {
-
-// TODO(akalin): Move the non-exported functions in this file to a
-// private header.
-
-typedef base::Callback<enum SyncerError(void)> WorkCallback;
-
-enum ModelSafeGroup {
-  GROUP_PASSIVE = 0,   // Models that are just "passively" being synced; e.g.
-                       // changes to these models don't need to be pushed to a
-                       // native model.
-  GROUP_UI,            // Models that live on UI thread and are being synced.
-  GROUP_DB,            // Models that live on DB thread and are being synced.
-  GROUP_FILE,          // Models that live on FILE thread and are being synced.
-  GROUP_HISTORY,       // Models that live on history thread and are being
-                       // synced.
-  GROUP_PASSWORD,      // Models that live on the password thread and are
-                       // being synced.  On windows and linux, this runs on the
-                       // DB thread.
-  GROUP_NON_BLOCKING,  // Models that correspond to non-blocking types. These
-                       // models always stay in GROUP_NON_BLOCKING; changes are
-                       // forwarded to these models without ModelSafeWorker/
-                       // SyncBackendRegistrar involvement.
-};
-
-SYNC_EXPORT std::string ModelSafeGroupToString(ModelSafeGroup group);
-
-// WorkerLoopDestructionObserver is notified when the thread where it works
-// is going to be destroyed.
-class WorkerLoopDestructionObserver {
- public:
-  virtual void OnWorkerLoopDestroyed(ModelSafeGroup group) = 0;
-};
-
-// The Syncer uses a ModelSafeWorker for all tasks that could potentially
-// modify syncable entries (e.g under a WriteTransaction). The ModelSafeWorker
-// only knows how to do one thing, and that is take some work (in a fully
-// pre-bound callback) and have it performed (as in Run()) from a thread which
-// is guaranteed to be "model-safe", where "safe" refers to not allowing us to
-// cause an embedding application model to fall out of sync with the
-// syncable::Directory due to a race. Each ModelSafeWorker is affiliated with
-// a thread and does actual work on that thread. On the destruction of that
-// thread, the affiliated worker is effectively disabled to do more
-// work and will notify its observer.
-class SYNC_EXPORT ModelSafeWorker
-    : public base::RefCountedThreadSafe<ModelSafeWorker>,
-      public base::MessageLoop::DestructionObserver {
- public:
-  // Subclass should implement to observe destruction of the loop where
-  // it actually does work. Called on UI thread immediately after worker is
-  // created.
-  virtual void RegisterForLoopDestruction() = 0;
-
-  // Called on sync loop from SyncBackendRegistrar::ShutDown(). Post task to
-  // working loop to stop observing loop destruction and invoke
-  // |unregister_done_callback|.
-  virtual void UnregisterForLoopDestruction(
-      base::Callback<void(ModelSafeGroup)> unregister_done_callback);
-
-  // If not stopped, call DoWorkAndWaitUntilDoneImpl() to do work. Otherwise
-  // return CANNOT_DO_WORK.
-  SyncerError DoWorkAndWaitUntilDone(const WorkCallback& work);
-
-  // Soft stop worker by setting stopped_ flag. Called when sync is disabled
-  // or browser is shutting down. Called on UI loop.
-  virtual void RequestStop();
-
-  virtual ModelSafeGroup GetModelSafeGroup() = 0;
-
-  // MessageLoop::DestructionObserver implementation.
-  void WillDestroyCurrentMessageLoop() override;
-
- protected:
-  explicit ModelSafeWorker(WorkerLoopDestructionObserver* observer);
-  ~ModelSafeWorker() override;
-
-  // Any time the Syncer performs model modifications (e.g employing a
-  // WriteTransaction), it should be done by this method to ensure it is done
-  // from a model-safe thread.
-  virtual SyncerError DoWorkAndWaitUntilDoneImpl(const WorkCallback& work) = 0;
-
-  base::WaitableEvent* work_done_or_stopped() {
-    return &work_done_or_stopped_;
-  }
-
-  // Return true if the worker was stopped. Thread safe.
-  bool IsStopped();
-
-  // Subclass should call this in RegisterForLoopDestruction() from the loop
-  // where work is done.
-  void SetWorkingLoopToCurrent();
-
- private:
-  friend class base::RefCountedThreadSafe<ModelSafeWorker>;
-
-  void UnregisterForLoopDestructionAsync(
-      base::Callback<void(ModelSafeGroup)> unregister_done_callback);
-
-  // Whether the worker should/can do more work. Set when sync is disabled or
-  // when the worker's working thread is to be destroyed.
-  base::Lock stopped_lock_;
-  bool stopped_;
-
-  // Signal set when work on native thread is finished or when native thread
-  // is to be destroyed so no more work can be done.
-  base::WaitableEvent work_done_or_stopped_;
-
-  // Notified when working thread of the worker is to be destroyed.
-  WorkerLoopDestructionObserver* observer_;
-
-  // Remember working loop for posting task to unregister destruction
-  // observation from sync thread when shutting down sync.
-  base::Lock working_task_runner_lock_;
-  scoped_refptr<base::SingleThreadTaskRunner> working_task_runner_;
-
-  // Callback passed with UnregisterForLoopDestruction. Normally this
-  // remains unset/unused and is stored only if |working_task_runner_| isn't
-  // initialized by the time UnregisterForLoopDestruction is called.
-  // It is safe to copy and thread safe.
-  // See comments in model_safe_worker.cc for more details.
-  base::Callback<void(ModelSafeGroup)> unregister_done_callback_;
-};
-
-// A map that details which ModelSafeGroup each ModelType
-// belongs to.  Routing info can change in response to the user enabling /
-// disabling sync for certain types, as well as model association completions.
-typedef std::map<ModelType, ModelSafeGroup> ModelSafeRoutingInfo;
-
-// Caller takes ownership of return value.
-SYNC_EXPORT std::unique_ptr<base::DictionaryValue> ModelSafeRoutingInfoToValue(
-    const ModelSafeRoutingInfo& routing_info);
-
-SYNC_EXPORT std::string ModelSafeRoutingInfoToString(
-    const ModelSafeRoutingInfo& routing_info);
-
-SYNC_EXPORT ModelTypeSet GetRoutingInfoTypes(
-    const ModelSafeRoutingInfo& routing_info);
-
-SYNC_EXPORT ModelSafeGroup GetGroupForModelType(
-    const ModelType type,
-    const ModelSafeRoutingInfo& routes);
-
-}  // namespace syncer
-
-#endif  // SYNC_INTERNAL_API_PUBLIC_ENGINE_MODEL_SAFE_WORKER_H_