sync: Support nudges from non-blocking sync types

Implements support for receiving nudges from the non-blocking sync
engine.  When a non-blocking sync type requests a commit, it will also
send a request to the sync scheduler asking it to schedule
a sync cycle for some time in the future.

Adds some of the code required to support refresh requests, but does not
include an interface to allow clients of the non-blocking sync API to
access it.

Adds basic support for the initial download nudge.  When a non-blocking
type starts syncing for the first time, it sends a request to the
scheduler asking it to download any data available on the server.  This
allows it to complete initial sync quickly and without putting the
scheduler into configure mode.  For now, this looks like
a refresh request in the sync protocol.  This will be changed in
a future CL.

BUG=351005

Review URL: https://codereview.chromium.org/375023002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@282439 0039d316-1c4b-4281-b951-d872f2087c98

17 files changed, 259 insertions, 35 deletions

diff --git a/sync/engine/model_type_sync_worker_impl.cc b/sync/engine/model_type_sync_worker_impl.cc
index 090db11..a5402c2 100644
--- a/sync/engine/model_type_sync_worker_impl.cc
+++ b/sync/engine/model_type_sync_worker_impl.cc
@@ -20,12 +20,18 @@ namespace syncer {
 ModelTypeSyncWorkerImpl::ModelTypeSyncWorkerImpl(
     ModelType type,
     const DataTypeState& initial_state,
+    NudgeHandler* nudge_handler,
     scoped_ptr<ModelTypeSyncProxy> type_sync_proxy)
     : type_(type),
       data_type_state_(initial_state),
       type_sync_proxy_(type_sync_proxy.Pass()),
+      nudge_handler_(nudge_handler),
       entities_deleter_(&entities_),
       weak_ptr_factory_(this) {
+  // Request an initial sync if it hasn't been completed yet.
+  if (!data_type_state_.initial_sync_done) {
+    nudge_handler_->NudgeForInitialDownload(type_);
+  }
 }
 
 ModelTypeSyncWorkerImpl::~ModelTypeSyncWorkerImpl() {
@@ -217,7 +223,8 @@ void ModelTypeSyncWorkerImpl::StorePendingCommit(
                           request.specifics);
   }
 
-  // TODO: Nudge SyncScheduler.
+  if (CanCommitItems())
+    nudge_handler_->NudgeForCommit(type_);
 }
 
 void ModelTypeSyncWorkerImpl::OnCommitResponse(
diff --git a/sync/engine/model_type_sync_worker_impl.h b/sync/engine/model_type_sync_worker_impl.h
index 5837222..69d4156 100644
--- a/sync/engine/model_type_sync_worker_impl.h
+++ b/sync/engine/model_type_sync_worker_impl.h
@@ -12,6 +12,7 @@
 #include "sync/engine/commit_contributor.h"
 #include "sync/engine/model_type_sync_worker.h"
 #include "sync/engine/non_blocking_sync_common.h"
+#include "sync/engine/nudge_handler.h"
 #include "sync/engine/update_handler.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/protocol/sync.pb.h"
@@ -52,6 +53,7 @@ class SYNC_EXPORT ModelTypeSyncWorkerImpl : public UpdateHandler,
  public:
   ModelTypeSyncWorkerImpl(ModelType type,
                           const DataTypeState& initial_state,
+                          NudgeHandler* nudge_handler,
                           scoped_ptr<ModelTypeSyncProxy> type_sync_proxy);
   virtual ~ModelTypeSyncWorkerImpl();
 
@@ -109,6 +111,9 @@ class SYNC_EXPORT ModelTypeSyncWorkerImpl : public UpdateHandler,
   // This is NULL when no proxy is connected..
   scoped_ptr<ModelTypeSyncProxy> type_sync_proxy_;
 
+  // Interface used to access and send nudges to the sync scheduler.  Not owned.
+  NudgeHandler* nudge_handler_;
+
   // A map of per-entity information known to this object.
   //
   // When commits are pending, their information is stored here.  This
diff --git a/sync/engine/model_type_sync_worker_impl_unittest.cc b/sync/engine/model_type_sync_worker_impl_unittest.cc
index 09b47ad..3aaaf3a 100644
--- a/sync/engine/model_type_sync_worker_impl_unittest.cc
+++ b/sync/engine/model_type_sync_worker_impl_unittest.cc
@@ -12,6 +12,7 @@
 #include "sync/sessions/status_controller.h"
 #include "sync/syncable/syncable_util.h"
 #include "sync/test/engine/mock_model_type_sync_proxy.h"
+#include "sync/test/engine/mock_nudge_handler.h"
 #include "sync/test/engine/single_type_mock_server.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
@@ -132,6 +133,12 @@ class ModelTypeSyncWorkerImplTest : public ::testing::Test {
   CommitResponseData GetCommitResponseOnModelThread(
       const std::string& tag) const;
 
+  // Returns the number of commit nudges sent to the mock nudge handler.
+  int GetNumCommitNudges() const;
+
+  // Returns the number of initial sync nudges sent to the mock nudge handler.
+  int GetNumInitialDownloadNudges() const;
+
   // Helpers for building various messages and structures.
   static std::string GenerateTagHash(const std::string& tag);
   static sync_pb::EntitySpecifics GenerateSpecifics(const std::string& tag,
@@ -149,6 +156,10 @@ class ModelTypeSyncWorkerImplTest : public ::testing::Test {
   // a single UpdateHandler and CommitContributor pair.  In this test
   // harness, the |worker_| is both of them.
   SingleTypeMockServer mock_server_;
+
+  // A mock to track the number of times the ModelTypeSyncWorker requests to
+  // sync.
+  MockNudgeHandler mock_nudge_handler_;
 };
 
 ModelTypeSyncWorkerImplTest::ModelTypeSyncWorkerImplTest()
@@ -178,6 +189,8 @@ void ModelTypeSyncWorkerImplTest::NormalInitialize() {
   initial_state.initial_sync_done = true;
 
   InitializeWithState(initial_state);
+
+  mock_nudge_handler_.ClearCounters();
 }
 
 void ModelTypeSyncWorkerImplTest::InitializeWithState(
@@ -188,7 +201,8 @@ void ModelTypeSyncWorkerImplTest::InitializeWithState(
   mock_type_sync_proxy_ = new MockModelTypeSyncProxy();
   scoped_ptr<ModelTypeSyncProxy> proxy(mock_type_sync_proxy_);
 
-  worker_.reset(new ModelTypeSyncWorkerImpl(kModelType, state, proxy.Pass()));
+  worker_.reset(new ModelTypeSyncWorkerImpl(
+      kModelType, state, &mock_nudge_handler_, proxy.Pass()));
 }
 
 void ModelTypeSyncWorkerImplTest::CommitRequest(const std::string& name,
@@ -379,6 +393,14 @@ CommitResponseData ModelTypeSyncWorkerImplTest::GetCommitResponseOnModelThread(
   return mock_type_sync_proxy_->GetCommitResponse(tag_hash);
 }
 
+int ModelTypeSyncWorkerImplTest::GetNumCommitNudges() const {
+  return mock_nudge_handler_.GetNumCommitNudges();
+}
+
+int ModelTypeSyncWorkerImplTest::GetNumInitialDownloadNudges() const {
+  return mock_nudge_handler_.GetNumInitialDownloadNudges();
+}
+
 std::string ModelTypeSyncWorkerImplTest::GenerateTagHash(
     const std::string& tag) {
   const std::string& client_tag_hash =
@@ -412,6 +434,8 @@ TEST_F(ModelTypeSyncWorkerImplTest, SimpleCommit) {
 
   CommitRequest("tag1", "value1");
 
+  EXPECT_EQ(1, GetNumCommitNudges());
+
   ASSERT_TRUE(WillCommit());
   DoSuccessfulCommit();
 
@@ -454,6 +478,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, SimpleDelete) {
   // We can't delete an entity that was never committed.
   // Step 1 is to create and commit a new entity.
   CommitRequest("tag1", "value1");
+  EXPECT_EQ(1, GetNumCommitNudges());
   ASSERT_TRUE(WillCommit());
   DoSuccessfulCommit();
 
@@ -502,16 +527,19 @@ TEST_F(ModelTypeSyncWorkerImplTest, NoDeleteUncommitted) {
   // Request the commit of a new, never-before-seen item.
   CommitRequest("tag1", "value1");
   EXPECT_TRUE(WillCommit());
+  EXPECT_EQ(1, GetNumCommitNudges());
 
   // Request a deletion of that item before we've had a chance to commit it.
   DeleteRequest("tag1");
   EXPECT_FALSE(WillCommit());
+  EXPECT_EQ(2, GetNumCommitNudges());
 }
 
 // Verifies the sending of an "initial sync done" signal.
 TEST_F(ModelTypeSyncWorkerImplTest, SendInitialSyncDone) {
   FirstInitialize();  // Initialize with no saved sync state.
   EXPECT_EQ(0U, GetNumModelThreadUpdateResponses());
+  EXPECT_EQ(1, GetNumInitialDownloadNudges());
 
   // Receive an update response that contains only the type root node.
   TriggerTypeRootUpdateFromServer();
@@ -538,6 +566,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, TwoNewItemsCommittedSeparately) {
 
   // Commit the first of two entities.
   CommitRequest("tag1", "value1");
+  EXPECT_EQ(1, GetNumCommitNudges());
   ASSERT_TRUE(WillCommit());
   DoSuccessfulCommit();
   ASSERT_EQ(1U, GetNumCommitMessagesOnServer());
@@ -548,6 +577,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, TwoNewItemsCommittedSeparately) {
 
   // Commit the second of two entities.
   CommitRequest("tag2", "value2");
+  EXPECT_EQ(2, GetNumCommitNudges());
   ASSERT_TRUE(WillCommit());
   DoSuccessfulCommit();
   ASSERT_EQ(2U, GetNumCommitMessagesOnServer());
diff --git a/sync/engine/nudge_handler.cc b/sync/engine/nudge_handler.cc
new file mode 100644
index 0000000..9c0ef7d
--- /dev/null
+++ b/sync/engine/nudge_handler.cc
@@ -0,0 +1,15 @@
+// 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.
+
+#include "sync/engine/nudge_handler.h"
+
+namespace syncer {
+
+NudgeHandler::NudgeHandler() {
+}
+
+NudgeHandler::~NudgeHandler() {
+}
+
+}  // namespace syncer
diff --git a/sync/engine/nudge_handler.h b/sync/engine/nudge_handler.h
new file mode 100644
index 0000000..f5d18ea
--- /dev/null
+++ b/sync/engine/nudge_handler.h
@@ -0,0 +1,26 @@
+// 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 SYNC_ENGINE_NUDGE_HANDLER_H_
+#define SYNC_ENGINE_NUDGE_HANDLER_H_
+
+#include "base/compiler_specific.h"
+#include "sync/base/sync_export.h"
+#include "sync/internal_api/public/base/model_type.h"
+
+namespace syncer {
+
+class SYNC_EXPORT_PRIVATE NudgeHandler {
+ public:
+  NudgeHandler();
+  virtual ~NudgeHandler();
+
+  virtual void NudgeForInitialDownload(syncer::ModelType type) = 0;
+  virtual void NudgeForCommit(syncer::ModelType type) = 0;
+  virtual void NudgeForRefresh(syncer::ModelType type) = 0;
+};
+
+}  // namespace syncer
+
+#endif  // SYNC_ENGINE_NUDGE_HANDLER_H_
diff --git a/sync/engine/sync_scheduler_unittest.cc b/sync/engine/sync_scheduler_unittest.cc
index 8348eab..7cf7360 100644
--- a/sync/engine/sync_scheduler_unittest.cc
+++ b/sync/engine/sync_scheduler_unittest.cc
@@ -19,6 +19,7 @@
 #include "sync/test/callback_counter.h"
 #include "sync/test/engine/fake_model_worker.h"
 #include "sync/test/engine/mock_connection_manager.h"
+#include "sync/test/engine/mock_nudge_handler.h"
 #include "sync/test/engine/test_directory_setter_upper.h"
 #include "sync/test/mock_invalidation.h"
 #include "sync/util/extensions_activity.h"
@@ -131,7 +132,8 @@ class SyncSchedulerTest : public testing::Test {
                                                 &cancelation_signal_));
     connection_->SetServerReachable();
 
-    model_type_registry_.reset(new ModelTypeRegistry(workers_, directory()));
+    model_type_registry_.reset(
+        new ModelTypeRegistry(workers_, directory(), &mock_nudge_handler_));
 
     context_.reset(new SyncSessionContext(
             connection_.get(), directory(),
@@ -240,6 +242,7 @@ class SyncSchedulerTest : public testing::Test {
   scoped_ptr<ModelTypeRegistry> model_type_registry_;
   scoped_ptr<SyncSessionContext> context_;
   scoped_ptr<SyncSchedulerImpl> scheduler_;
+  MockNudgeHandler mock_nudge_handler_;
   MockSyncer* syncer_;
   MockDelayProvider* delay_;
   std::vector<scoped_refptr<ModelSafeWorker> > workers_;
diff --git a/sync/engine/syncer_unittest.cc b/sync/engine/syncer_unittest.cc
index 98cde3b..6f891e8d 100644
--- a/sync/engine/syncer_unittest.cc
+++ b/sync/engine/syncer_unittest.cc
@@ -47,6 +47,7 @@
 #include "sync/syncable/syncable_write_transaction.h"
 #include "sync/test/engine/fake_model_worker.h"
 #include "sync/test/engine/mock_connection_manager.h"
+#include "sync/test/engine/mock_nudge_handler.h"
 #include "sync/test/engine/test_directory_setter_upper.h"
 #include "sync/test/engine/test_id_factory.h"
 #include "sync/test/engine/test_syncable_utils.h"
@@ -294,7 +295,8 @@ class SyncerTest : public testing::Test,
     ModelSafeRoutingInfo routing_info;
     GetModelSafeRoutingInfo(&routing_info);
 
-    model_type_registry_.reset(new ModelTypeRegistry(workers_, directory()));
+    model_type_registry_.reset(
+        new ModelTypeRegistry(workers_, directory(), &mock_nudge_handler_));
     model_type_registry_->RegisterDirectoryTypeDebugInfoObserver(
         &debug_info_cache_);
 
@@ -584,6 +586,7 @@ class SyncerTest : public testing::Test,
 
   scoped_ptr<SyncSession> session_;
   TypeDebugInfoCache debug_info_cache_;
+  MockNudgeHandler mock_nudge_handler_;
   scoped_ptr<ModelTypeRegistry> model_type_registry_;
   scoped_ptr<SyncSessionContext> context_;
   bool saw_syncer_event_;
diff --git a/sync/internal_api/sync_context_proxy_impl_unittest.cc b/sync/internal_api/sync_context_proxy_impl_unittest.cc
index 660670d..49ed02d 100644
--- a/sync/internal_api/sync_context_proxy_impl_unittest.cc
+++ b/sync/internal_api/sync_context_proxy_impl_unittest.cc
@@ -11,6 +11,8 @@
 #include "sync/internal_api/public/sync_context.h"
 #include "sync/internal_api/sync_context_proxy_impl.h"
 #include "sync/sessions/model_type_registry.h"
+#include "sync/test/engine/mock_nudge_handler.h"
+#include "sync/test/engine/test_directory_setter_upper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
@@ -19,22 +21,39 @@ class SyncContextProxyImplTest : public ::testing::Test {
  public:
   SyncContextProxyImplTest()
       : sync_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-        type_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-        registry_(new ModelTypeRegistry()),
-        context_proxy_(sync_task_runner_, registry_->AsWeakPtr()) {}
+        type_task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
+
+  virtual void SetUp() {
+    dir_maker_.SetUp();
+    registry_.reset(new ModelTypeRegistry(
+        workers_, dir_maker_.directory(), &nudge_handler_));
+    context_proxy_.reset(
+        new SyncContextProxyImpl(sync_task_runner_, registry_->AsWeakPtr()));
+  }
+
+  virtual void TearDown() {
+    context_proxy_.reset();
+    registry_.reset();
+    dir_maker_.TearDown();
+  }
 
   // The sync thread could be shut down at any time without warning.  This
   // function simulates such an event.
   void DisableSync() { registry_.reset(); }
 
-  scoped_ptr<SyncContextProxy> GetProxy() { return context_proxy_.Clone(); }
+  scoped_ptr<SyncContextProxy> GetProxy() { return context_proxy_->Clone(); }
 
  private:
   base::MessageLoop loop_;
   scoped_refptr<base::SequencedTaskRunner> sync_task_runner_;
   scoped_refptr<base::SequencedTaskRunner> type_task_runner_;
+
+  std::vector<scoped_refptr<ModelSafeWorker> > workers_;
+  TestDirectorySetterUpper dir_maker_;
+  MockNudgeHandler nudge_handler_;
   scoped_ptr<ModelTypeRegistry> registry_;
-  SyncContextProxyImpl context_proxy_;
+
+  scoped_ptr<SyncContextProxyImpl> context_proxy_;
 };
 
 // Try to connect a type to a SyncContext that has already shut down.
diff --git a/sync/internal_api/sync_manager_impl.cc b/sync/internal_api/sync_manager_impl.cc
index 54ce66d..168c19f 100644
--- a/sync/internal_api/sync_manager_impl.cc
+++ b/sync/internal_api/sync_manager_impl.cc
@@ -396,7 +396,7 @@ void SyncManagerImpl::Init(
   DVLOG(1) << "Setting invalidator client ID: " << invalidator_client_id;
   allstatus_.SetInvalidatorClientId(invalidator_client_id);
 
-  model_type_registry_.reset(new ModelTypeRegistry(workers, directory()));
+  model_type_registry_.reset(new ModelTypeRegistry(workers, directory(), this));
 
   // Bind the SyncContext WeakPtr to this thread.  This helps us crash earlier
   // if the pointer is misused in debug mode.
@@ -900,6 +900,22 @@ void SyncManagerImpl::RequestNudgeForDataTypes(
                                  nudge_location);
 }
 
+void SyncManagerImpl::NudgeForInitialDownload(syncer::ModelType type) {
+  // TODO(rlarocque): Initial downloads should have a separate nudge type.
+  DCHECK(thread_checker_.CalledOnValidThread());
+  RefreshTypes(ModelTypeSet(type));
+}
+
+void SyncManagerImpl::NudgeForCommit(syncer::ModelType type) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  RequestNudgeForDataTypes(FROM_HERE, ModelTypeSet(type));
+}
+
+void SyncManagerImpl::NudgeForRefresh(syncer::ModelType type) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  RefreshTypes(ModelTypeSet(type));
+}
+
 void SyncManagerImpl::OnSyncCycleEvent(const SyncCycleEvent& event) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Only send an event if this is due to a cycle ending and this cycle
diff --git a/sync/internal_api/sync_manager_impl.h b/sync/internal_api/sync_manager_impl.h
index 7efde2d..c447aa1 100644
--- a/sync/internal_api/sync_manager_impl.h
+++ b/sync/internal_api/sync_manager_impl.h
@@ -12,6 +12,7 @@
 #include "sync/base/sync_export.h"
 #include "sync/engine/all_status.h"
 #include "sync/engine/net/server_connection_manager.h"
+#include "sync/engine/nudge_handler.h"
 #include "sync/engine/sync_engine_event_listener.h"
 #include "sync/internal_api/change_reorder_buffer.h"
 #include "sync/internal_api/debug_info_event_listener.h"
@@ -51,15 +52,16 @@ class SyncSessionContext;
 //
 // Unless stated otherwise, all methods of SyncManager should be called on the
 // same thread.
-class SYNC_EXPORT_PRIVATE SyncManagerImpl :
-    public SyncManager,
-    public net::NetworkChangeNotifier::IPAddressObserver,
-    public net::NetworkChangeNotifier::ConnectionTypeObserver,
-    public JsBackend,
-    public SyncEngineEventListener,
-    public ServerConnectionEventListener,
-    public syncable::DirectoryChangeDelegate,
-    public SyncEncryptionHandler::Observer {
+class SYNC_EXPORT_PRIVATE SyncManagerImpl
+    : public SyncManager,
+      public net::NetworkChangeNotifier::IPAddressObserver,
+      public net::NetworkChangeNotifier::ConnectionTypeObserver,
+      public JsBackend,
+      public SyncEngineEventListener,
+      public ServerConnectionEventListener,
+      public syncable::DirectoryChangeDelegate,
+      public SyncEncryptionHandler::Observer,
+      public NudgeHandler {
  public:
   // Create an uninitialized SyncManager.  Callers must Init() before using.
   explicit SyncManagerImpl(const std::string& name);
@@ -194,6 +196,11 @@ class SYNC_EXPORT_PRIVATE SyncManagerImpl :
   virtual void OnConnectionTypeChanged(
       net::NetworkChangeNotifier::ConnectionType) OVERRIDE;
 
+  // NudgeHandler implementation.
+  virtual void NudgeForInitialDownload(syncer::ModelType type) OVERRIDE;
+  virtual void NudgeForCommit(syncer::ModelType type) OVERRIDE;
+  virtual void NudgeForRefresh(syncer::ModelType type) OVERRIDE;
+
   const SyncScheduler* scheduler() const;
 
   bool GetHasInvalidAuthTokenForTest() const;
diff --git a/sync/sessions/model_type_registry.cc b/sync/sessions/model_type_registry.cc
index 0923bba..69a5488 100644
--- a/sync/sessions/model_type_registry.cc
+++ b/sync/sessions/model_type_registry.cc
@@ -102,14 +102,13 @@ void ModelTypeSyncWorkerWrapper::EnqueueForCommit(
 
 }  // namespace
 
-ModelTypeRegistry::ModelTypeRegistry()
-    : directory_(NULL), weak_ptr_factory_(this) {
-}
-
 ModelTypeRegistry::ModelTypeRegistry(
     const std::vector<scoped_refptr<ModelSafeWorker> >& workers,
-    syncable::Directory* directory)
-    : directory_(directory), weak_ptr_factory_(this) {
+    syncable::Directory* directory,
+    NudgeHandler* nudge_handler)
+    : directory_(directory),
+      nudge_handler_(nudge_handler),
+      weak_ptr_factory_(this) {
   for (size_t i = 0u; i < workers.size(); ++i) {
     workers_map_.insert(
         std::make_pair(workers[i]->GetModelSafeGroup(), workers[i]));
@@ -193,8 +192,8 @@ void ModelTypeRegistry::ConnectSyncTypeToWorker(
   // Initialize Worker -> Proxy communication channel.
   scoped_ptr<ModelTypeSyncProxy> proxy(
       new ModelTypeSyncProxyWrapper(proxy_impl, type_task_runner));
-  scoped_ptr<ModelTypeSyncWorkerImpl> worker(
-      new ModelTypeSyncWorkerImpl(type, data_type_state, proxy.Pass()));
+  scoped_ptr<ModelTypeSyncWorkerImpl> worker(new ModelTypeSyncWorkerImpl(
+      type, data_type_state, nudge_handler_, proxy.Pass()));
 
   // Initialize Proxy -> Worker communication channel.
   scoped_ptr<ModelTypeSyncWorker> wrapped_worker(
diff --git a/sync/sessions/model_type_registry.h b/sync/sessions/model_type_registry.h
index 4444682..e18ac9c 100644
--- a/sync/sessions/model_type_registry.h
+++ b/sync/sessions/model_type_registry.h
@@ -12,6 +12,7 @@
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "sync/base/sync_export.h"
+#include "sync/engine/nudge_handler.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/sessions/type_debug_info_observer.h"
@@ -40,14 +41,10 @@ typedef std::map<ModelType, DirectoryTypeDebugInfoEmitter*>
 // Keeps track of the sets of active update handlers and commit contributors.
 class SYNC_EXPORT_PRIVATE ModelTypeRegistry : public SyncContext {
  public:
-  // This alternative constructor does not support any directory types.
-  // It is used only in tests.
-  ModelTypeRegistry();
-
   // Constructs a ModelTypeRegistry that supports directory types.
-  ModelTypeRegistry(
-      const std::vector<scoped_refptr<ModelSafeWorker> >& workers,
-      syncable::Directory* directory);
+  ModelTypeRegistry(const std::vector<scoped_refptr<ModelSafeWorker> >& workers,
+                    syncable::Directory* directory,
+                    NudgeHandler* nudge_handler);
   virtual ~ModelTypeRegistry();
 
   // Sets the set of enabled types.
@@ -115,6 +112,9 @@ class SYNC_EXPORT_PRIVATE ModelTypeRegistry : public SyncContext {
   // The directory.  Not owned.
   syncable::Directory* directory_;
 
+  // The NudgeHandler.  Not owned.
+  NudgeHandler* nudge_handler_;
+
   // The set of enabled directory types.
   ModelTypeSet enabled_directory_types_;
 
diff --git a/sync/sessions/model_type_registry_unittest.cc b/sync/sessions/model_type_registry_unittest.cc
index 7207197..b1f1a49 100644
--- a/sync/sessions/model_type_registry_unittest.cc
+++ b/sync/sessions/model_type_registry_unittest.cc
@@ -11,6 +11,7 @@
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/sessions/model_type_registry.h"
 #include "sync/test/engine/fake_model_worker.h"
+#include "sync/test/engine/mock_nudge_handler.h"
 #include "sync/test/engine/test_directory_setter_upper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -40,6 +41,7 @@ class ModelTypeRegistryTest : public ::testing::Test {
   TestDirectorySetterUpper dir_maker_;
   std::vector<scoped_refptr<ModelSafeWorker> > workers_;
   scoped_ptr<ModelTypeRegistry> registry_;
+  MockNudgeHandler mock_nudge_handler_;
 };
 
 ModelTypeRegistryTest::ModelTypeRegistryTest() {}
@@ -56,7 +58,8 @@ void ModelTypeRegistryTest::SetUp() {
   workers_.push_back(ui_worker);
   workers_.push_back(db_worker);
 
-  registry_.reset(new ModelTypeRegistry(workers_, directory()));
+  registry_.reset(
+      new ModelTypeRegistry(workers_, directory(), &mock_nudge_handler_));
 }
 
 void ModelTypeRegistryTest::TearDown() {
diff --git a/sync/sync_core.gypi b/sync/sync_core.gypi
index 5205208..0474fd4 100644
--- a/sync/sync_core.gypi
+++ b/sync/sync_core.gypi
@@ -82,6 +82,8 @@
     'engine/non_blocking_type_commit_contribution.h',
     'engine/nudge_source.cc',
     'engine/nudge_source.h',
+    'engine/nudge_handler.cc',
+    'engine/nudge_handler.h',
     'engine/process_updates_util.cc',
     'engine/process_updates_util.h',
     'engine/sync_cycle_event.cc',
diff --git a/sync/sync_tests.gypi b/sync/sync_tests.gypi
index 1b48fe4..1cff9bf 100644
--- a/sync/sync_tests.gypi
+++ b/sync/sync_tests.gypi
@@ -46,6 +46,8 @@
         'test/engine/mock_model_type_sync_proxy.h',
         'test/engine/mock_model_type_sync_worker.cc',
         'test/engine/mock_model_type_sync_worker.h',
+        'test/engine/mock_nudge_handler.cc',
+        'test/engine/mock_nudge_handler.h',
         'test/engine/mock_update_handler.cc',
         'test/engine/mock_update_handler.h',
         'test/engine/single_type_mock_server.cc',
diff --git a/sync/test/engine/mock_nudge_handler.cc b/sync/test/engine/mock_nudge_handler.cc
new file mode 100644
index 0000000..4c7e4f5
--- /dev/null
+++ b/sync/test/engine/mock_nudge_handler.cc
@@ -0,0 +1,47 @@
+// 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.
+
+#include "sync/test/engine/mock_nudge_handler.h"
+#include "sync/internal_api/public/base/model_type.h"
+
+namespace syncer {
+
+MockNudgeHandler::MockNudgeHandler()
+    : num_initial_nudges_(0), num_commit_nudges_(0), num_refresh_nudges_(0) {
+}
+
+MockNudgeHandler::~MockNudgeHandler() {
+}
+
+void MockNudgeHandler::NudgeForInitialDownload(syncer::ModelType type) {
+  num_initial_nudges_++;
+}
+
+void MockNudgeHandler::NudgeForCommit(syncer::ModelType type) {
+  num_commit_nudges_++;
+}
+
+void MockNudgeHandler::NudgeForRefresh(syncer::ModelType type) {
+  num_refresh_nudges_++;
+}
+
+int MockNudgeHandler::GetNumInitialDownloadNudges() const {
+  return num_initial_nudges_;
+}
+
+int MockNudgeHandler::GetNumCommitNudges() const {
+  return num_commit_nudges_;
+}
+
+int MockNudgeHandler::GetNumRefreshNudges() const {
+  return num_refresh_nudges_;
+}
+
+void MockNudgeHandler::ClearCounters() {
+  num_initial_nudges_ = 0;
+  num_commit_nudges_ = 0;
+  num_refresh_nudges_ = 0;
+}
+
+}  // namespace syncer
diff --git a/sync/test/engine/mock_nudge_handler.h b/sync/test/engine/mock_nudge_handler.h
new file mode 100644
index 0000000..bbde8ed
--- /dev/null
+++ b/sync/test/engine/mock_nudge_handler.h
@@ -0,0 +1,40 @@
+// 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 SYNC_TEST_ENGINE_MOCK_NUDGE_HANDLER_H_
+#define SYNC_TEST_ENGINE_MOCK_NUDGE_HANDLER_H_
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "sync/engine/nudge_handler.h"
+#include "sync/internal_api/public/base/model_type.h"
+
+namespace syncer {
+
+class MockNudgeHandler : public NudgeHandler {
+ public:
+  MockNudgeHandler();
+  virtual ~MockNudgeHandler();
+
+  virtual void NudgeForInitialDownload(syncer::ModelType type) OVERRIDE;
+  virtual void NudgeForCommit(syncer::ModelType type) OVERRIDE;
+  virtual void NudgeForRefresh(syncer::ModelType type) OVERRIDE;
+
+  int GetNumInitialDownloadNudges() const;
+  int GetNumCommitNudges() const;
+  int GetNumRefreshNudges() const;
+
+  void ClearCounters();
+
+ private:
+  int num_initial_nudges_;
+  int num_commit_nudges_;
+  int num_refresh_nudges_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockNudgeHandler);
+};
+
+}  // namespace syncer
+
+#endif  // SYNC_TEST_ENGINE_MOCK_NUDGE_HANDLER_H_