[Sync] Register USS types with ModelTypeRegistry before download

components/sync_driver/glue/sync_backend_registrar.h

 // 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 COMPONENTS_SYNC_DRIVER_GLUE_SYNC_BACKEND_REGISTRAR_H_
 #define COMPONENTS_SYNC_DRIVER_GLUE_SYNC_BACKEND_REGISTRAR_H_
 
 #include <stdint.h>
 
 #include <map>
+#include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/engine/model_safe_worker.h"
 #include "sync/internal_api/public/sync_manager.h"
@@ skipping 39 matching lines @@
   //   2) UI posts task to shut down syncer on sync thread.
   //   3) If sync is disabled, call ReleaseSyncThread() on the UI thread.
   //   3) UI posts SyncBackendRegistrar::ShutDown() on sync thread to
   //      unregister workers from observing destruction of their working loops.
   //   4) Workers notify registrar when unregistration finishes or working
   //      loops are destroyed. Registrar destroys itself on last worker
   //      notification. Sync thread will be stopped if ownership was not
   //      released.
   ~SyncBackendRegistrar() override;
 
+  // Adds |type| to set of non-blocking types. These types will have
+  // GROUP_NON_BLOCKING initial model safe group and would be treated
+  // differently in ModelTypeRegistry.
+  void RegisterNonBlockingType(syncer::ModelType type);
+
   // Informs the SyncBackendRegistrar of the currently enabled set of types.
   // These types will be placed in the passive group.  This function should be
   // called exactly once during startup.
   void SetInitialTypes(syncer::ModelTypeSet initial_types);
 
   // Returns whether or not we are currently syncing encryption keys.
   // Must be called on the UI thread.
   bool IsNigoriEnabled() const;
 
   // Removes all types in |types_to_remove| from the routing info and
@@ skipping 79 matching lines @@
 
   // Return true if |model_type| lives on the current thread.  Must be
   // called with |lock_| held.  May be called on any thread.
   bool IsCurrentThreadSafeForModel(syncer::ModelType model_type) const;
 
   // Returns true if the current thread is the native thread for the
   // given group (or if it is undeterminable).
   bool IsOnThreadForGroup(syncer::ModelType type,
                           syncer::ModelSafeGroup group) const;
 
+  // Returns model safe group that should be assigned to type when it is first
+  // configured (before activation). Returns GROUP_PASSIVE for directory types
+  // and GROUP_NON_BLOCKING for non-blocking types.
+  syncer::ModelSafeGroup GetInitialGroupForType(syncer::ModelType type) const;
+
   // Name used for debugging.
   const std::string name_;
 
   // A pointer to the sync client.
   sync_driver::SyncClient* const sync_client_;
 
   // Protects all variables below.
   mutable base::Lock lock_;
 
   // We maintain ownership of all workers.  In some cases, we need to
@@ skipping 23 matching lines @@
   const scoped_refptr<base::SingleThreadTaskRunner> ui_thread_;
   const scoped_refptr<base::SingleThreadTaskRunner> db_thread_;
   const scoped_refptr<base::SingleThreadTaskRunner> file_thread_;
 
   // Declare |sync_thread_| at the end so that it will be destroyed before
   // objects above because tasks on sync thread depend on those objects,
   // e.g. Shutdown() depends on |lock_|, SyncManager::Init() depends on
   // workers, etc.
   scoped_ptr<base::Thread> sync_thread_;
 
+  // Set of types with non-blocking implementation (as opposed to directory
+  // based).
+  syncer::ModelTypeSet non_blocking_types_;
+
   DISALLOW_COPY_AND_ASSIGN(SyncBackendRegistrar);
 };
 
 }  // namespace browser_sync
 
 #endif  // COMPONENTS_SYNC_DRIVER_GLUE_SYNC_BACKEND_REGISTRAR_H_