sync: Add interfaces for per-type sync

Puts the DirectoryCommitContributor and DirectoryUpdateHandler
classes behind interfaces.  These classes were always intended
to form the basis of an abstract interface.  Now we can start
to introduce alternate implementations of them.

This CL includes one such alternate implementation.  It adds
the MockUpdateHandler and uses it to remove some unnecessary
boilerplate from the download unit tests.

This CL also resolves an old TODO.  It renames the SyncDirectory*
classes to Directory*, since the 'Sync' part of the name is redundant.

This should have no effect on program behavior.

BUG=278484

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

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

24 files changed, 422 insertions, 230 deletions

diff --git a/sync/engine/commit.cc b/sync/engine/commit.cc
index 0a37656..90b9742 100644
--- a/sync/engine/commit.cc
+++ b/sync/engine/commit.cc
@@ -5,9 +5,9 @@
 #include "sync/engine/commit.h"
 
 #include "base/debug/trace_event.h"
+#include "sync/engine/commit_contribution.h"
 #include "sync/engine/commit_processor.h"
 #include "sync/engine/commit_util.h"
-#include "sync/engine/sync_directory_commit_contribution.h"
 #include "sync/engine/syncer.h"
 #include "sync/engine/syncer_proto_util.h"
 #include "sync/sessions/sync_session.h"
@@ -15,7 +15,7 @@
 namespace syncer {
 
 Commit::Commit(
-    const std::map<ModelType, SyncDirectoryCommitContribution*>& contributions,
+    const std::map<ModelType, CommitContribution*>& contributions,
     const sync_pb::ClientToServerMessage& message,
     ExtensionsActivity::Records extensions_activity_buffer)
   : contributions_(contributions),
@@ -71,7 +71,7 @@ Commit* Commit::Init(
       commit_message);
 
   // Finally, serialize all our contributions.
-  for (std::map<ModelType, SyncDirectoryCommitContribution*>::iterator it =
+  for (std::map<ModelType, CommitContribution*>::iterator it =
            contributions.begin(); it != contributions.end(); ++it) {
     it->second->AddToCommitMessage(&message);
   }
@@ -130,7 +130,7 @@ SyncerError Commit::PostAndProcessResponse(
 
   // Let the contributors process the responses to each of their requests.
   SyncerError processing_result = SYNCER_OK;
-  for (std::map<ModelType, SyncDirectoryCommitContribution*>::iterator it =
+  for (std::map<ModelType, CommitContribution*>::iterator it =
        contributions_.begin(); it != contributions_.end(); ++it) {
     TRACE_EVENT1("sync", "ProcessCommitResponse",
                  "type", ModelTypeToString(it->first));
diff --git a/sync/engine/commit.h b/sync/engine/commit.h
index 236b514..993bd872 100644
--- a/sync/engine/commit.h
+++ b/sync/engine/commit.h
@@ -9,7 +9,7 @@
 
 #include "base/stl_util.h"
 #include "sync/base/sync_export.h"
-#include "sync/engine/sync_directory_commit_contribution.h"
+#include "sync/engine/commit_contribution.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/util/syncer_error.h"
@@ -37,7 +37,7 @@ class Syncer;
 class SYNC_EXPORT_PRIVATE Commit {
  public:
   Commit(
-      const std::map<ModelType, SyncDirectoryCommitContribution*>&
+      const std::map<ModelType, CommitContribution*>&
           contributions,
       const sync_pb::ClientToServerMessage& message,
       ExtensionsActivity::Records extensions_activity_buffer);
@@ -64,7 +64,7 @@ class SYNC_EXPORT_PRIVATE Commit {
   void CleanUp();
 
  private:
-  typedef std::map<ModelType, SyncDirectoryCommitContribution*> ContributionMap;
+  typedef std::map<ModelType, CommitContribution*> ContributionMap;
 
   ContributionMap contributions_;
   STLValueDeleter<ContributionMap> deleter_;
diff --git a/sync/engine/commit_contribution.cc b/sync/engine/commit_contribution.cc
new file mode 100644
index 0000000..cef02b5
--- /dev/null
+++ b/sync/engine/commit_contribution.cc
@@ -0,0 +1,13 @@
+// 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/commit_contribution.h"
+
+namespace syncer {
+
+CommitContribution::CommitContribution() {}
+
+CommitContribution::~CommitContribution() {}
+
+}  // namespace syncer
diff --git a/sync/engine/commit_contribution.h b/sync/engine/commit_contribution.h
new file mode 100644
index 0000000..e2e9108
--- /dev/null
+++ b/sync/engine/commit_contribution.h
@@ -0,0 +1,54 @@
+// 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_COMMIT_CONTRIBUTION_H_
+#define SYNC_ENGINE_COMMIT_CONTRIBUTION_H_
+
+#include "sync/base/sync_export.h"
+#include "sync/internal_api/public/util/syncer_error.h"
+#include "sync/protocol/sync.pb.h"
+#include "sync/sessions/status_controller.h"
+
+namespace syncer {
+
+namespace sessions {
+class StatusController;
+}  // namespace sessions
+
+// This class represents a set of items belonging to a particular data type that
+// have been selected from a CommitContributor and prepared for commit.
+//
+// This class handles the bookkeeping related to the commit of these items.
+class SYNC_EXPORT_PRIVATE CommitContribution {
+ public:
+  CommitContribution();
+  virtual ~CommitContribution() = 0;
+
+  // Serialize this contribution's entries to the given commit request |msg|.
+  //
+  // This function is not const.  It may update some state in this contribution
+  // that will be used when processing the associated commit response.  This
+  // function should not be called more than once.
+  virtual void AddToCommitMessage(sync_pb::ClientToServerMessage* msg) = 0;
+
+  // Updates this contribution's contents in accordance with the provided
+  // |response|.
+  //
+  // It is not valid to call this function unless AddToCommitMessage() was
+  // called earlier.  This function should not be called more than once.
+  virtual SyncerError ProcessCommitResponse(
+      const sync_pb::ClientToServerResponse& response,
+      sessions::StatusController* status) = 0;
+
+  // Cleans up any temproary state associated with the commit.  Must be called
+  // before destruction.
+  virtual void CleanUp() = 0;
+
+  // Returns the number of entries included in this contribution.
+  virtual size_t GetNumEntries() const = 0;
+};
+
+}  // namespace syncer
+
+#endif  // SYNC_ENGINE_COMMIT_CONTRIBUTION_H_
diff --git a/sync/engine/commit_contributor.cc b/sync/engine/commit_contributor.cc
new file mode 100644
index 0000000..6410c63
--- /dev/null
+++ b/sync/engine/commit_contributor.cc
@@ -0,0 +1,13 @@
+// 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/commit_contributor.h"
+
+namespace syncer {
+
+CommitContributor::CommitContributor() {}
+
+CommitContributor::~CommitContributor() {}
+
+}  // namespace syncer
diff --git a/sync/engine/commit_contributor.h b/sync/engine/commit_contributor.h
new file mode 100644
index 0000000..2d190af
--- /dev/null
+++ b/sync/engine/commit_contributor.h
@@ -0,0 +1,38 @@
+// 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_COMMIT_CONTRIBUTOR_H_
+#define SYNC_ENGINE_COMMIT_CONTRIBUTOR_H_
+
+#include <cstddef>
+
+#include "base/memory/scoped_ptr.h"
+
+namespace syncer {
+
+class CommitContribution;
+
+namespace syncable {
+class Directory;
+}
+
+// This class represents a source of items to commit to the sync server.
+//
+// When asked, it can return CommitContribution objects that contain a set of
+// items to be committed from this source.
+class CommitContributor {
+ public:
+  CommitContributor();
+  virtual ~CommitContributor() = 0;
+
+  // Gathers up to |max_entries| unsynced items from this contributor into a
+  // CommitContribution.  Returns NULL when the contributor has nothing to
+  // contribute.
+  virtual scoped_ptr<CommitContribution> GetContribution(
+      size_t max_entries) = 0;
+};
+
+}  // namespace
+
+#endif  // SYNC_ENGINE_COMMIT_CONTRIBUTOR_H_
diff --git a/sync/engine/commit_processor.cc b/sync/engine/commit_processor.cc
index c54217b..d9bd423 100644
--- a/sync/engine/commit_processor.cc
+++ b/sync/engine/commit_processor.cc
@@ -6,8 +6,8 @@
 
 #include <map>
 
-#include "sync/engine/sync_directory_commit_contribution.h"
-#include "sync/engine/sync_directory_commit_contributor.h"
+#include "sync/engine/commit_contribution.h"
+#include "sync/engine/commit_contributor.h"
 #include "sync/protocol/sync.pb.h"
 
 namespace syncer {
@@ -35,11 +35,11 @@ void CommitProcessor::GatherCommitContributions(
       continue;
     }
     size_t spaces_remaining = max_entries - num_entries;
-    SyncDirectoryCommitContribution* contribution =
+    scoped_ptr<CommitContribution> contribution =
         cm_it->second->GetContribution(spaces_remaining);
     if (contribution) {
       num_entries += contribution->GetNumEntries();
-      contributions->insert(std::make_pair(it.Get(), contribution));
+      contributions->insert(std::make_pair(it.Get(), contribution.release()));
     }
     if (num_entries >= max_entries) {
       DCHECK_EQ(num_entries, max_entries)
diff --git a/sync/engine/commit_processor.h b/sync/engine/commit_processor.h
index 9ab0957..c3af5d81 100644
--- a/sync/engine/commit_processor.h
+++ b/sync/engine/commit_processor.h
@@ -20,8 +20,8 @@ namespace syncable {
 class Directory;
 }  // namespace syncable
 
-class SyncDirectoryCommitContributor;
-class SyncDirectoryCommitContribution;
+class CommitContributor;
+class CommitContribution;
 
 // This class manages the set of per-type committer objects.
 //
@@ -31,12 +31,19 @@ class SyncDirectoryCommitContribution;
 // contains a type which was not previously registered.
 class SYNC_EXPORT_PRIVATE CommitProcessor {
  public:
-  typedef std::map<ModelType, SyncDirectoryCommitContribution*> ContributionMap;
+  typedef std::map<ModelType, CommitContribution*> ContributionMap;
 
+  // Contructs a CommitProcessor from a map of CommitContributors.
+  // The CommitProcessor does not own this map.
   explicit CommitProcessor(CommitContributorMap* commit_contributor_map);
   ~CommitProcessor();
 
   // Gathers a set of contributions to be used to populate a commit message.
+  //
+  // For each of the |commit_types| in this CommitProcessor's CommitContributor
+  // map, gather any entries queued for commit into CommitContributions.  The
+  // total number of entries in all the returned CommitContributions shall not
+  // exceed |max_entries|.
   void GatherCommitContributions(
       ModelTypeSet commit_types,
       size_t max_entries,
diff --git a/sync/engine/sync_directory_commit_contribution.cc b/sync/engine/directory_commit_contribution.cc
index f43131e3..2fd7b30 100644
--- a/sync/engine/sync_directory_commit_contribution.cc
+++ b/sync/engine/directory_commit_contribution.cc
@@ -1,8 +1,8 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
+// 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/sync_directory_commit_contribution.h"
+#include "sync/engine/directory_commit_contribution.h"
 
 #include "sync/engine/commit_util.h"
 #include "sync/engine/get_commit_ids.h"
@@ -15,12 +15,12 @@ namespace syncer {
 using syncable::GET_BY_HANDLE;
 using syncable::SYNCER;
 
-SyncDirectoryCommitContribution::~SyncDirectoryCommitContribution() {
+DirectoryCommitContribution::~DirectoryCommitContribution() {
   DCHECK(!syncing_bits_set_);
 }
 
 // static.
-SyncDirectoryCommitContribution* SyncDirectoryCommitContribution::Build(
+scoped_ptr<DirectoryCommitContribution> DirectoryCommitContribution::Build(
     syncable::Directory* dir,
     ModelType type,
     size_t max_entries) {
@@ -30,7 +30,7 @@ SyncDirectoryCommitContribution* SyncDirectoryCommitContribution::Build(
   GetCommitIdsForType(&trans, type, max_entries, &metahandles);
 
   if (metahandles.empty())
-    return NULL;
+    return scoped_ptr<DirectoryCommitContribution>();
 
   google::protobuf::RepeatedPtrField<sync_pb::SyncEntity> entities;
   for (std::vector<int64>::iterator it = metahandles.begin();
@@ -41,10 +41,11 @@ SyncDirectoryCommitContribution* SyncDirectoryCommitContribution::Build(
     entry.PutSyncing(true);
   }
 
-  return new SyncDirectoryCommitContribution(metahandles, entities, dir);
+  return scoped_ptr<DirectoryCommitContribution>(
+      new DirectoryCommitContribution(metahandles, entities, dir));
 }
 
-void SyncDirectoryCommitContribution::AddToCommitMessage(
+void DirectoryCommitContribution::AddToCommitMessage(
     sync_pb::ClientToServerMessage* msg) {
   DCHECK(syncing_bits_set_);
   sync_pb::CommitMessage* commit_message = msg->mutable_commit();
@@ -54,7 +55,7 @@ void SyncDirectoryCommitContribution::AddToCommitMessage(
             RepeatedPtrFieldBackInserter(commit_message->mutable_entries()));
 }
 
-SyncerError SyncDirectoryCommitContribution::ProcessCommitResponse(
+SyncerError DirectoryCommitContribution::ProcessCommitResponse(
     const sync_pb::ClientToServerResponse& response,
     sessions::StatusController* status) {
   DCHECK(syncing_bits_set_);
@@ -131,16 +132,16 @@ SyncerError SyncDirectoryCommitContribution::ProcessCommitResponse(
   }
 }
 
-void SyncDirectoryCommitContribution::CleanUp() {
+void DirectoryCommitContribution::CleanUp() {
   DCHECK(syncing_bits_set_);
   UnsetSyncingBits();
 }
 
-size_t SyncDirectoryCommitContribution::GetNumEntries() const {
+size_t DirectoryCommitContribution::GetNumEntries() const {
   return metahandles_.size();
 }
 
-SyncDirectoryCommitContribution::SyncDirectoryCommitContribution(
+DirectoryCommitContribution::DirectoryCommitContribution(
     const std::vector<int64>& metahandles,
     const google::protobuf::RepeatedPtrField<sync_pb::SyncEntity>& entities,
     syncable::Directory* dir)
@@ -151,7 +152,7 @@ SyncDirectoryCommitContribution::SyncDirectoryCommitContribution(
     syncing_bits_set_(true) {
 }
 
-void SyncDirectoryCommitContribution::UnsetSyncingBits() {
+void DirectoryCommitContribution::UnsetSyncingBits() {
   syncable::ModelNeutralWriteTransaction trans(FROM_HERE, SYNCER, dir_);
   for (std::vector<int64>::const_iterator it = metahandles_.begin();
        it != metahandles_.end(); ++it) {
diff --git a/sync/engine/sync_directory_commit_contribution.h b/sync/engine/directory_commit_contribution.h
index 8934056..508ac7c 100644
--- a/sync/engine/sync_directory_commit_contribution.h
+++ b/sync/engine/directory_commit_contribution.h
@@ -1,14 +1,16 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
+// 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_SYNC_DIRECTORY_COMMIT_CONTRIBUTION_H_
-#define SYNC_ENGINE_SYNC_DIRECTORY_COMMIT_CONTRIBUTION_H_
+#ifndef SYNC_ENGINE_DIRECTORY_COMMIT_CONTRIBUTION_H_
+#define SYNC_ENGINE_DIRECTORY_COMMIT_CONTRIBUTION_H_
 
 #include <vector>
 
 #include "base/gtest_prod_util.h"
+#include "base/memory/scoped_ptr.h"
 #include "sync/base/sync_export.h"
+#include "sync/engine/commit_contribution.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/util/syncer_error.h"
 #include "sync/protocol/sync.pb.h"
@@ -30,10 +32,11 @@ class Directory;
 // This class handles the bookkeeping related to the commit of these items,
 // including processing the commit response message and setting and unsetting
 // the SYNCING bits.
-class SYNC_EXPORT_PRIVATE SyncDirectoryCommitContribution {
+class SYNC_EXPORT_PRIVATE DirectoryCommitContribution
+    : public CommitContribution {
  public:
   // This destructor will DCHECK if UnsetSyncingBits() has not been called yet.
-  ~SyncDirectoryCommitContribution();
+  virtual ~DirectoryCommitContribution();
 
   // Build a CommitContribution from the IS_UNSYNCED items in |dir| with the
   // given |type|.  The contribution will include at most |max_items| entries.
@@ -41,7 +44,7 @@ class SYNC_EXPORT_PRIVATE SyncDirectoryCommitContribution {
   // This function may return NULL if this type has no items ready for and
   // requiring commit.  This function may make model neutral changes to the
   // directory.
-  static SyncDirectoryCommitContribution* Build(
+  static scoped_ptr<DirectoryCommitContribution> Build(
       syncable::Directory* dir,
       ModelType type,
       size_t max_items);
@@ -51,7 +54,7 @@ class SYNC_EXPORT_PRIVATE SyncDirectoryCommitContribution {
   // This function is not const.  It will update some state in this contribution
   // that will be used when processing the associated commit response.  This
   // function should not be called more than once.
-  void AddToCommitMessage(sync_pb::ClientToServerMessage* msg);
+  virtual void AddToCommitMessage(sync_pb::ClientToServerMessage* msg) OVERRIDE;
 
   // Updates this contribution's contents in accordance with the provided
   // |response|.
@@ -59,24 +62,24 @@ class SYNC_EXPORT_PRIVATE SyncDirectoryCommitContribution {
   // This function may make model-neutral changes to the directory.  It is not
   // valid to call this function unless AddToCommitMessage() was called earlier.
   // This function should not be called more than once.
-  SyncerError ProcessCommitResponse(
+  virtual SyncerError ProcessCommitResponse(
       const sync_pb::ClientToServerResponse& response,
-      sessions::StatusController* status);
+      sessions::StatusController* status) OVERRIDE;
 
   // Cleans up any temproary state associated with the commit.  Must be called
   // before destruction.
-  void CleanUp();
+  virtual void CleanUp() OVERRIDE;
 
   // Returns the number of entries included in this contribution.
-  size_t GetNumEntries() const;
+  virtual size_t GetNumEntries() const OVERRIDE;
 
  private:
-  class SyncDirectoryCommitContributionTest;
-  FRIEND_TEST_ALL_PREFIXES(SyncDirectoryCommitContributionTest, GatherByTypes);
-  FRIEND_TEST_ALL_PREFIXES(SyncDirectoryCommitContributionTest,
+  class DirectoryCommitContributionTest;
+  FRIEND_TEST_ALL_PREFIXES(DirectoryCommitContributionTest, GatherByTypes);
+  FRIEND_TEST_ALL_PREFIXES(DirectoryCommitContributionTest,
                            GatherAndTruncate);
 
-  SyncDirectoryCommitContribution(
+  DirectoryCommitContribution(
       const std::vector<int64>& metahandles,
       const google::protobuf::RepeatedPtrField<sync_pb::SyncEntity>& entities,
       syncable::Directory* directory);
@@ -94,9 +97,9 @@ class SYNC_EXPORT_PRIVATE SyncDirectoryCommitContribution {
   // called.  This flag must be unset by the time our destructor is called.
   bool syncing_bits_set_;
 
-  DISALLOW_COPY_AND_ASSIGN(SyncDirectoryCommitContribution);
+  DISALLOW_COPY_AND_ASSIGN(DirectoryCommitContribution);
 };
 
 }  // namespace syncer
 
-#endif  // SYNC_ENGINE_SYNC_DIRECTORY_COMMIT_CONTRIBUTION_H_
+#endif  // SYNC_ENGINE_DIRECTORY_COMMIT_CONTRIBUTION_H_
diff --git a/sync/engine/sync_directory_commit_contribution_unittest.cc b/sync/engine/directory_commit_contribution_unittest.cc
index 75f88bd..e17817c 100644
--- a/sync/engine/sync_directory_commit_contribution_unittest.cc
+++ b/sync/engine/directory_commit_contribution_unittest.cc
@@ -1,8 +1,8 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
+// 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/sync_directory_commit_contribution.h"
+#include "sync/engine/directory_commit_contribution.h"
 
 #include "base/message_loop/message_loop.h"
 #include "sync/sessions/status_controller.h"
@@ -17,7 +17,7 @@
 
 namespace syncer {
 
-class SyncDirectoryCommitContributionTest : public ::testing::Test {
+class DirectoryCommitContributionTest : public ::testing::Test {
  public:
   virtual void SetUp() OVERRIDE {
     dir_maker_.SetUp();
@@ -74,9 +74,9 @@ class SyncDirectoryCommitContributionTest : public ::testing::Test {
   TestDirectorySetterUpper dir_maker_;
 };
 
-// Verify that the SyncDirectoryCommitContribution contains only entries of its
+// Verify that the DirectoryCommitContribution contains only entries of its
 // specified type.
-TEST_F(SyncDirectoryCommitContributionTest, GatherByTypes) {
+TEST_F(DirectoryCommitContributionTest, GatherByTypes) {
   int64 pref1;
   {
     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
@@ -85,8 +85,8 @@ TEST_F(SyncDirectoryCommitContributionTest, GatherByTypes) {
     CreateUnsyncedItem(&trans, EXTENSIONS, "extension1");
   }
 
-  scoped_ptr<SyncDirectoryCommitContribution> cc(
-      SyncDirectoryCommitContribution::Build(dir(), PREFERENCES, 5));
+  scoped_ptr<DirectoryCommitContribution> cc(
+      DirectoryCommitContribution::Build(dir(), PREFERENCES, 5));
   ASSERT_EQ(2U, cc->GetNumEntries());
 
   const std::vector<int64>& metahandles = cc->metahandles_;
@@ -98,9 +98,9 @@ TEST_F(SyncDirectoryCommitContributionTest, GatherByTypes) {
   cc->CleanUp();
 }
 
-// Verify that the SyncDirectoryCommitContributionTest builder function
+// Verify that the DirectoryCommitContributionTest builder function
 // truncates if necessary.
-TEST_F(SyncDirectoryCommitContributionTest, GatherAndTruncate) {
+TEST_F(DirectoryCommitContributionTest, GatherAndTruncate) {
   int64 pref1;
   int64 pref2;
   {
@@ -110,8 +110,8 @@ TEST_F(SyncDirectoryCommitContributionTest, GatherAndTruncate) {
     CreateUnsyncedItem(&trans, EXTENSIONS, "extension1");
   }
 
-  scoped_ptr<SyncDirectoryCommitContribution> cc(
-      SyncDirectoryCommitContribution::Build(dir(), PREFERENCES, 1));
+  scoped_ptr<DirectoryCommitContribution> cc(
+      DirectoryCommitContribution::Build(dir(), PREFERENCES, 1));
   ASSERT_EQ(1U, cc->GetNumEntries());
 
   int64 only_metahandle = cc->metahandles_[0];
@@ -120,11 +120,11 @@ TEST_F(SyncDirectoryCommitContributionTest, GatherAndTruncate) {
   cc->CleanUp();
 }
 
-// Sanity check for building commits from SyncDirectoryCommitContributions.
+// Sanity check for building commits from DirectoryCommitContributions.
 // This test makes two CommitContribution objects of different types and uses
 // them to initialize a commit message.  Then it checks that the contents of the
 // commit message match those of the directory they came from.
-TEST_F(SyncDirectoryCommitContributionTest, PrepareCommit) {
+TEST_F(DirectoryCommitContributionTest, PrepareCommit) {
   {
     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
     CreateUnsyncedItem(&trans, PREFERENCES, "pref1");
@@ -132,10 +132,10 @@ TEST_F(SyncDirectoryCommitContributionTest, PrepareCommit) {
     CreateUnsyncedItem(&trans, EXTENSIONS, "extension1");
   }
 
-  scoped_ptr<SyncDirectoryCommitContribution> pref_cc(
-      SyncDirectoryCommitContribution::Build(dir(), PREFERENCES, 25));
-  scoped_ptr<SyncDirectoryCommitContribution> ext_cc(
-      SyncDirectoryCommitContribution::Build(dir(), EXTENSIONS, 25));
+  scoped_ptr<DirectoryCommitContribution> pref_cc(
+      DirectoryCommitContribution::Build(dir(), PREFERENCES, 25));
+  scoped_ptr<DirectoryCommitContribution> ext_cc(
+      DirectoryCommitContribution::Build(dir(), EXTENSIONS, 25));
 
   sync_pb::ClientToServerMessage message;
   pref_cc->AddToCommitMessage(&message);
@@ -173,7 +173,7 @@ TEST_F(SyncDirectoryCommitContributionTest, PrepareCommit) {
 // Creates some unsynced items, pretends to commit them, and hands back a
 // specially crafted response to the syncer in order to test commit response
 // processing.  The response simulates a succesful commit scenario.
-TEST_F(SyncDirectoryCommitContributionTest, ProcessCommitResponse) {
+TEST_F(DirectoryCommitContributionTest, ProcessCommitResponse) {
   int64 pref1_handle;
   int64 pref2_handle;
   int64 ext1_handle;
@@ -184,10 +184,10 @@ TEST_F(SyncDirectoryCommitContributionTest, ProcessCommitResponse) {
     ext1_handle = CreateUnsyncedItem(&trans, EXTENSIONS, "extension1");
   }
 
-  scoped_ptr<SyncDirectoryCommitContribution> pref_cc(
-      SyncDirectoryCommitContribution::Build(dir(), PREFERENCES, 25));
-  scoped_ptr<SyncDirectoryCommitContribution> ext_cc(
-      SyncDirectoryCommitContribution::Build(dir(), EXTENSIONS, 25));
+  scoped_ptr<DirectoryCommitContribution> pref_cc(
+      DirectoryCommitContribution::Build(dir(), PREFERENCES, 25));
+  scoped_ptr<DirectoryCommitContribution> ext_cc(
+      DirectoryCommitContribution::Build(dir(), EXTENSIONS, 25));
 
   sync_pb::ClientToServerMessage message;
   pref_cc->AddToCommitMessage(&message);
diff --git a/sync/engine/directory_commit_contributor.cc b/sync/engine/directory_commit_contributor.cc
new file mode 100644
index 0000000..41d1e12
--- /dev/null
+++ b/sync/engine/directory_commit_contributor.cc
@@ -0,0 +1,25 @@
+// 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/directory_commit_contributor.h"
+
+#include "sync/engine/directory_commit_contribution.h"
+
+namespace syncer {
+
+DirectoryCommitContributor::DirectoryCommitContributor(
+    syncable::Directory* dir,
+    ModelType type)
+    : dir_(dir),
+      type_(type) {}
+
+DirectoryCommitContributor::~DirectoryCommitContributor() {}
+
+scoped_ptr<CommitContribution>
+DirectoryCommitContributor::GetContribution(size_t max_entries) {
+  return DirectoryCommitContribution::Build(dir_, type_, max_entries)
+      .PassAs<CommitContribution>();
+}
+
+}  // namespace syncer
diff --git a/sync/engine/directory_commit_contributor.h b/sync/engine/directory_commit_contributor.h
new file mode 100644
index 0000000..abc1a6c
--- /dev/null
+++ b/sync/engine/directory_commit_contributor.h
@@ -0,0 +1,45 @@
+// 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_DIRECTORY_COMMIT_CONTRIBUTOR_H_
+#define SYNC_ENGINE_DIRECTORY_COMMIT_CONTRIBUTOR_H_
+
+#include <map>
+
+#include "base/memory/scoped_ptr.h"
+#include "sync/engine/commit_contributor.h"
+#include "sync/engine/directory_commit_contribution.h"
+#include "sync/internal_api/public/base/model_type.h"
+
+namespace syncer {
+
+namespace syncable {
+class Directory;
+}
+
+// This class represents the syncable::Directory as a source of items to commit
+// to the sync server.
+//
+// Each instance of this class represents a particular type within the
+// syncable::Directory.  When asked, it will iterate through the directory, grab
+// any items of its type that are ready for commit, and return them in the form
+// of a DirectoryCommitContribution.
+class DirectoryCommitContributor : public CommitContributor {
+ public:
+  DirectoryCommitContributor(syncable::Directory* dir, ModelType type);
+  virtual ~DirectoryCommitContributor();
+
+  virtual scoped_ptr<CommitContribution> GetContribution(
+      size_t max_entries) OVERRIDE;
+
+ private:
+  syncable::Directory* dir_;
+  ModelType type_;
+
+  DISALLOW_COPY_AND_ASSIGN(DirectoryCommitContributor);
+};
+
+}  // namespace
+
+#endif  // SYNC_ENGINE_DIRECTORY_COMMIT_CONTRIBUTOR_H_
diff --git a/sync/engine/sync_directory_update_handler.cc b/sync/engine/directory_update_handler.cc
index 3acfea4..be36082 100644
--- a/sync/engine/sync_directory_update_handler.cc
+++ b/sync/engine/directory_update_handler.cc
@@ -1,8 +1,8 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
+// 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/sync_directory_update_handler.h"
+#include "sync/engine/directory_update_handler.h"
 
 #include "sync/engine/conflict_resolver.h"
 #include "sync/engine/process_updates_util.h"
@@ -16,7 +16,7 @@ namespace syncer {
 
 using syncable::SYNCER;
 
-SyncDirectoryUpdateHandler::SyncDirectoryUpdateHandler(
+DirectoryUpdateHandler::DirectoryUpdateHandler(
     syncable::Directory* dir,
     ModelType type,
     scoped_refptr<ModelSafeWorker> worker)
@@ -24,14 +24,14 @@ SyncDirectoryUpdateHandler::SyncDirectoryUpdateHandler(
     type_(type),
     worker_(worker) {}
 
-SyncDirectoryUpdateHandler::~SyncDirectoryUpdateHandler() {}
+DirectoryUpdateHandler::~DirectoryUpdateHandler() {}
 
-void SyncDirectoryUpdateHandler::GetDownloadProgress(
+void DirectoryUpdateHandler::GetDownloadProgress(
     sync_pb::DataTypeProgressMarker* progress_marker) const {
   dir_->GetDownloadProgress(type_, progress_marker);
 }
 
-void SyncDirectoryUpdateHandler::ProcessGetUpdatesResponse(
+void DirectoryUpdateHandler::ProcessGetUpdatesResponse(
     const sync_pb::DataTypeProgressMarker& progress_marker,
     const SyncEntityList& applicable_updates,
     sessions::StatusController* status) {
@@ -40,8 +40,7 @@ void SyncDirectoryUpdateHandler::ProcessGetUpdatesResponse(
   UpdateProgressMarker(progress_marker);
 }
 
-void SyncDirectoryUpdateHandler::ApplyUpdates(
-    sessions::StatusController* status) {
+void DirectoryUpdateHandler::ApplyUpdates(sessions::StatusController* status) {
   if (!IsApplyUpdatesRequired()) {
     return;
   }
@@ -49,14 +48,14 @@ void SyncDirectoryUpdateHandler::ApplyUpdates(
   // This will invoke handlers that belong to the model and its thread, so we
   // switch to the appropriate thread before we start this work.
   WorkCallback c = base::Bind(
-      &SyncDirectoryUpdateHandler::ApplyUpdatesImpl,
+      &DirectoryUpdateHandler::ApplyUpdatesImpl,
       // We wait until the callback is executed.  We can safely use Unretained.
       base::Unretained(this),
       base::Unretained(status));
   worker_->DoWorkAndWaitUntilDone(c);
 }
 
-void SyncDirectoryUpdateHandler::PassiveApplyUpdates(
+void DirectoryUpdateHandler::PassiveApplyUpdates(
     sessions::StatusController* status) {
   if (!IsApplyUpdatesRequired()) {
     return;
@@ -66,7 +65,7 @@ void SyncDirectoryUpdateHandler::PassiveApplyUpdates(
   ApplyUpdatesImpl(status);
 }
 
-SyncerError SyncDirectoryUpdateHandler::ApplyUpdatesImpl(
+SyncerError DirectoryUpdateHandler::ApplyUpdatesImpl(
     sessions::StatusController* status) {
   syncable::WriteTransaction trans(FROM_HERE, syncable::SYNCER, dir_);
 
@@ -133,7 +132,7 @@ SyncerError SyncDirectoryUpdateHandler::ApplyUpdatesImpl(
   return SYNCER_OK;
 }
 
-bool SyncDirectoryUpdateHandler::IsApplyUpdatesRequired() {
+bool DirectoryUpdateHandler::IsApplyUpdatesRequired() {
   if (IsControlType(type_)) {
     return false;  // We don't process control types here.
   }
@@ -141,14 +140,14 @@ bool SyncDirectoryUpdateHandler::IsApplyUpdatesRequired() {
   return dir_->TypeHasUnappliedUpdates(type_);
 }
 
-void SyncDirectoryUpdateHandler::UpdateSyncEntities(
+void DirectoryUpdateHandler::UpdateSyncEntities(
     syncable::ModelNeutralWriteTransaction* trans,
     const SyncEntityList& applicable_updates,
     sessions::StatusController* status) {
   ProcessDownloadedUpdates(dir_, trans, type_, applicable_updates, status);
 }
 
-void SyncDirectoryUpdateHandler::UpdateProgressMarker(
+void DirectoryUpdateHandler::UpdateProgressMarker(
     const sync_pb::DataTypeProgressMarker& progress_marker) {
   int field_number = progress_marker.data_type_id();
   ModelType model_type = GetModelTypeFromSpecificsFieldNumber(field_number);
diff --git a/sync/engine/sync_directory_update_handler.h b/sync/engine/directory_update_handler.h
index 2e4f33e..25acbd9 100644
--- a/sync/engine/sync_directory_update_handler.h
+++ b/sync/engine/directory_update_handler.h
@@ -1,9 +1,9 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
+// 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_SYNC_DIRECTORY_UPDATE_HANDLER_H_
-#define SYNC_ENGINE_SYNC_DIRECTORY_UPDATE_HANDLER_H_
+#ifndef SYNC_ENGINE_DIRECTORY_UPDATE_HANDLER_H_
+#define SYNC_ENGINE_DIRECTORY_UPDATE_HANDLER_H_
 
 #include <map>
 
@@ -11,6 +11,7 @@
 #include "base/memory/ref_counted.h"
 #include "sync/base/sync_export.h"
 #include "sync/engine/process_updates_util.h"
+#include "sync/engine/update_handler.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/util/syncer_error.h"
 
@@ -37,16 +38,16 @@ class ModelSafeWorker;
 // Each instance of this class represents a particular type in the
 // syncable::Directory.  It can store and retreive that type's progress markers.
 // It can also process a set of received SyncEntities and store their data.
-class SYNC_EXPORT_PRIVATE SyncDirectoryUpdateHandler {
+class SYNC_EXPORT_PRIVATE DirectoryUpdateHandler : public UpdateHandler {
  public:
-  SyncDirectoryUpdateHandler(syncable::Directory* dir,
-                             ModelType type,
-                             scoped_refptr<ModelSafeWorker> worker);
-  ~SyncDirectoryUpdateHandler();
+  DirectoryUpdateHandler(syncable::Directory* dir,
+                         ModelType type,
+                         scoped_refptr<ModelSafeWorker> worker);
+  virtual ~DirectoryUpdateHandler();
 
   // Fills the given parameter with the stored progress marker for this type.
-  void GetDownloadProgress(
-      sync_pb::DataTypeProgressMarker* progress_marker) const;
+  virtual void GetDownloadProgress(
+      sync_pb::DataTypeProgressMarker* progress_marker) const OVERRIDE;
 
   // Processes the contents of a GetUpdates response message.
   //
@@ -54,22 +55,22 @@ class SYNC_EXPORT_PRIVATE SyncDirectoryUpdateHandler {
   // single GetUpdates response message.  The progress marker's type must match
   // this update handler's type, and the set of SyncEntities must include all
   // entities of this type found in the response message.
-  void ProcessGetUpdatesResponse(
+  virtual void ProcessGetUpdatesResponse(
       const sync_pb::DataTypeProgressMarker& progress_marker,
       const SyncEntityList& applicable_updates,
-      sessions::StatusController* status);
+      sessions::StatusController* status) OVERRIDE;
 
   // If there are updates to apply, apply them on the proper thread.
   // Delegates to ApplyUpdatesImpl().
-  void ApplyUpdates(sessions::StatusController* status);
+  virtual void ApplyUpdates(sessions::StatusController* status) OVERRIDE;
 
   // Apply updates on the sync thread.  This is for use during initial sync
   // prior to model association.
-  void PassiveApplyUpdates(sessions::StatusController* status);
+  virtual void PassiveApplyUpdates(sessions::StatusController* status) OVERRIDE;
 
  private:
-  friend class SyncDirectoryUpdateHandlerApplyUpdateTest;
-  friend class SyncDirectoryUpdateHandlerProcessUpdateTest;
+  friend class DirectoryUpdateHandlerApplyUpdateTest;
+  friend class DirectoryUpdateHandlerProcessUpdateTest;
 
   // Sometimes there is nothing to do, so we can return without doing anything.
   bool IsApplyUpdatesRequired();
@@ -93,9 +94,9 @@ class SYNC_EXPORT_PRIVATE SyncDirectoryUpdateHandler {
   ModelType type_;
   scoped_refptr<ModelSafeWorker> worker_;
 
-  DISALLOW_COPY_AND_ASSIGN(SyncDirectoryUpdateHandler);
+  DISALLOW_COPY_AND_ASSIGN(DirectoryUpdateHandler);
 };
 
 }  // namespace syncer
 
-#endif  // SYNC_ENGINE_SYNC_DIRECTORY_UPDATE_HANDLER_H_
+#endif  // SYNC_ENGINE_DIRECTORY_UPDATE_HANDLER_H_
diff --git a/sync/engine/sync_directory_update_handler_unittest.cc b/sync/engine/directory_update_handler_unittest.cc
index 3cc8e7d..0352505 100644
--- a/sync/engine/sync_directory_update_handler_unittest.cc
+++ b/sync/engine/directory_update_handler_unittest.cc
@@ -1,8 +1,8 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
+// 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/sync_directory_update_handler.h"
+#include "sync/engine/directory_update_handler.h"
 
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
@@ -34,13 +34,13 @@ using syncable::UNITTEST;
 // Update processing is what occurs when we first download updates.  It converts
 // the received protobuf message into information in the syncable::Directory.
 // Any invalid or redundant updates will be dropped at this point.
-class SyncDirectoryUpdateHandlerProcessUpdateTest : public ::testing::Test {
+class DirectoryUpdateHandlerProcessUpdateTest : public ::testing::Test {
  public:
-  SyncDirectoryUpdateHandlerProcessUpdateTest()
+  DirectoryUpdateHandlerProcessUpdateTest()
       : ui_worker_(new FakeModelWorker(GROUP_UI)) {
   }
 
-  virtual ~SyncDirectoryUpdateHandlerProcessUpdateTest() {}
+  virtual ~DirectoryUpdateHandlerProcessUpdateTest() {}
 
   virtual void SetUp() OVERRIDE {
     dir_maker_.SetUp();
@@ -62,13 +62,13 @@ class SyncDirectoryUpdateHandlerProcessUpdateTest : public ::testing::Test {
   // This exists mostly to give tests access to the protected member function.
   // Warning: This takes the syncable directory lock.
   void UpdateSyncEntities(
-      SyncDirectoryUpdateHandler* handler,
+      DirectoryUpdateHandler* handler,
       const SyncEntityList& applicable_updates,
       sessions::StatusController* status);
 
   // Another function to access private member functions.
   void UpdateProgressMarkers(
-      SyncDirectoryUpdateHandler* handler,
+      DirectoryUpdateHandler* handler,
       const sync_pb::DataTypeProgressMarker& progress);
 
   scoped_refptr<FakeModelWorker> ui_worker() {
@@ -82,7 +82,7 @@ class SyncDirectoryUpdateHandlerProcessUpdateTest : public ::testing::Test {
 };
 
 scoped_ptr<sync_pb::SyncEntity>
-SyncDirectoryUpdateHandlerProcessUpdateTest::CreateUpdate(
+DirectoryUpdateHandlerProcessUpdateTest::CreateUpdate(
     const std::string& id,
     const std::string& parent,
     const ModelType& type) {
@@ -96,16 +96,16 @@ SyncDirectoryUpdateHandlerProcessUpdateTest::CreateUpdate(
   return e.Pass();
 }
 
-void SyncDirectoryUpdateHandlerProcessUpdateTest::UpdateSyncEntities(
-    SyncDirectoryUpdateHandler* handler,
+void DirectoryUpdateHandlerProcessUpdateTest::UpdateSyncEntities(
+    DirectoryUpdateHandler* handler,
     const SyncEntityList& applicable_updates,
     sessions::StatusController* status) {
   syncable::ModelNeutralWriteTransaction trans(FROM_HERE, UNITTEST, dir());
   handler->UpdateSyncEntities(&trans, applicable_updates, status);
 }
 
-void SyncDirectoryUpdateHandlerProcessUpdateTest::UpdateProgressMarkers(
-    SyncDirectoryUpdateHandler* handler,
+void DirectoryUpdateHandlerProcessUpdateTest::UpdateProgressMarkers(
+    DirectoryUpdateHandler* handler,
     const sync_pb::DataTypeProgressMarker& progress) {
   handler->UpdateProgressMarker(progress);
 }
@@ -113,8 +113,8 @@ void SyncDirectoryUpdateHandlerProcessUpdateTest::UpdateProgressMarkers(
 static const char kCacheGuid[] = "IrcjZ2jyzHDV9Io4+zKcXQ==";
 
 // Test that the bookmark tag is set on newly downloaded items.
-TEST_F(SyncDirectoryUpdateHandlerProcessUpdateTest, NewBookmarkTag) {
-  SyncDirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker());
+TEST_F(DirectoryUpdateHandlerProcessUpdateTest, NewBookmarkTag) {
+  DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker());
   sync_pb::GetUpdatesResponse gu_response;
   sessions::StatusController status;
 
@@ -150,9 +150,9 @@ TEST_F(SyncDirectoryUpdateHandlerProcessUpdateTest, NewBookmarkTag) {
 }
 
 // Test the receipt of a type root node.
-TEST_F(SyncDirectoryUpdateHandlerProcessUpdateTest,
+TEST_F(DirectoryUpdateHandlerProcessUpdateTest,
        ReceiveServerCreatedBookmarkFolders) {
-  SyncDirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker());
+  DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker());
   sync_pb::GetUpdatesResponse gu_response;
   sessions::StatusController status;
 
@@ -185,8 +185,8 @@ TEST_F(SyncDirectoryUpdateHandlerProcessUpdateTest,
 }
 
 // Test the receipt of a non-bookmark item.
-TEST_F(SyncDirectoryUpdateHandlerProcessUpdateTest, ReceiveNonBookmarkItem) {
-  SyncDirectoryUpdateHandler handler(dir(), PREFERENCES, ui_worker());
+TEST_F(DirectoryUpdateHandlerProcessUpdateTest, ReceiveNonBookmarkItem) {
+  DirectoryUpdateHandler handler(dir(), PREFERENCES, ui_worker());
   sync_pb::GetUpdatesResponse gu_response;
   sessions::StatusController status;
 
@@ -216,8 +216,8 @@ TEST_F(SyncDirectoryUpdateHandlerProcessUpdateTest, ReceiveNonBookmarkItem) {
 }
 
 // Tests the setting of progress markers.
-TEST_F(SyncDirectoryUpdateHandlerProcessUpdateTest, ProcessNewProgressMarkers) {
-  SyncDirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker());
+TEST_F(DirectoryUpdateHandlerProcessUpdateTest, ProcessNewProgressMarkers) {
+  DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker());
 
   sync_pb::DataTypeProgressMarker progress;
   progress.set_data_type_id(GetSpecificsFieldNumberFromModelType(BOOKMARKS));
@@ -247,9 +247,9 @@ TEST_F(SyncDirectoryUpdateHandlerProcessUpdateTest, ProcessNewProgressMarkers) {
 // update processing tests.  Currently, we're bypassing most of those issues by
 // using FakeModelWorkers, so there's not much difference between the two test
 // harnesses.
-class SyncDirectoryUpdateHandlerApplyUpdateTest : public ::testing::Test {
+class DirectoryUpdateHandlerApplyUpdateTest : public ::testing::Test {
  public:
-  SyncDirectoryUpdateHandlerApplyUpdateTest()
+  DirectoryUpdateHandlerApplyUpdateTest()
       : ui_worker_(new FakeModelWorker(GROUP_UI)),
         password_worker_(new FakeModelWorker(GROUP_PASSWORD)),
         passive_worker_(new FakeModelWorker(GROUP_PASSIVE)),
@@ -261,10 +261,10 @@ class SyncDirectoryUpdateHandlerApplyUpdateTest : public ::testing::Test {
 
     update_handler_map_.insert(std::make_pair(
         BOOKMARKS,
-        new SyncDirectoryUpdateHandler(directory(), BOOKMARKS, ui_worker_)));
+        new DirectoryUpdateHandler(directory(), BOOKMARKS, ui_worker_)));
     update_handler_map_.insert(std::make_pair(
         PASSWORDS,
-        new SyncDirectoryUpdateHandler(directory(),
+        new DirectoryUpdateHandler(directory(),
                                        PASSWORDS,
                                        password_worker_)));
   }
@@ -291,7 +291,7 @@ class SyncDirectoryUpdateHandlerApplyUpdateTest : public ::testing::Test {
   }
 
  private:
-  typedef std::map<ModelType, SyncDirectoryUpdateHandler*> UpdateHandlerMap;
+  typedef std::map<ModelType, UpdateHandler*> UpdateHandlerMap;
 
   base::MessageLoop loop_;  // Needed to initialize the directory.
   TestDirectorySetterUpper dir_maker_;
@@ -314,7 +314,7 @@ sync_pb::EntitySpecifics DefaultBookmarkSpecifics() {
 } // namespace
 
 // Test update application for a few bookmark items.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, SimpleBookmark) {
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest, SimpleBookmark) {
   sessions::StatusController status;
 
   std::string root_server_id = syncable::GetNullId().GetServerId();
@@ -351,7 +351,7 @@ TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, SimpleBookmark) {
 }
 
 // Test that the applicator can handle updates delivered out of order.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest,
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
        BookmarkChildrenBeforeParent) {
   // Start with some bookmarks whose parents are unknown.
   std::string root_server_id = syncable::GetNullId().GetServerId();
@@ -409,7 +409,7 @@ TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest,
 
 // Try to apply changes on an item that is both IS_UNSYNCED and
 // IS_UNAPPLIED_UPDATE.  Conflict resolution should be performed.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, SimpleBookmarkConflict) {
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest, SimpleBookmarkConflict) {
   int64 handle = entry_factory()->CreateUnappliedAndUnsyncedBookmarkItem("x");
 
   int original_server_version = -10;
@@ -445,7 +445,7 @@ TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, SimpleBookmarkConflict) {
 // follow the normal "server wins" logic, we'd end up violating hierarchy
 // constraints.  The hierarchy conflict must take precedence.  We can not allow
 // the update to be applied.  The item must remain in the conflict state.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, HierarchyAndSimpleConflict) {
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest, HierarchyAndSimpleConflict) {
   // Create a simply-conflicting item.  It will start with valid parent ids.
   int64 handle = entry_factory()->CreateUnappliedAndUnsyncedBookmarkItem(
       "orphaned_by_server");
@@ -476,7 +476,7 @@ TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, HierarchyAndSimpleConflict) {
 
 // Attempt to apply an udpate that would create a bookmark folder loop.  This
 // application should fail.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, BookmarkFolderLoop) {
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest, BookmarkFolderLoop) {
   // Item 'X' locally has parent of 'root'.  Server is updating it to have
   // parent of 'Y'.
 
@@ -521,7 +521,7 @@ TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, BookmarkFolderLoop) {
 
 // Test update application where the update has been orphaned by a local folder
 // deletion.  The update application attempt should fail.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest,
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
        HierarchyConflictDeletedParent) {
   // Create a locally deleted parent item.
   int64 parent_handle;
@@ -559,7 +559,7 @@ TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest,
 
 // Attempt to apply an update that deletes a folder where the folder has
 // locally-created children.  The update application should fail.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest,
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
        HierarchyConflictDeleteNonEmptyDirectory) {
   // Create a server-deleted folder as a child of root node.
   int64 parent_handle =
@@ -603,7 +603,7 @@ TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest,
 
 // Attempt to apply updates where the updated item's parent is not known to this
 // client.  The update application attempt should fail.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest,
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
        HierarchyConflictUnknownParent) {
   // We shouldn't be able to do anything with either of these items.
   int64 x_handle = entry_factory()->CreateUnappliedNewItemWithParent(
@@ -634,7 +634,7 @@ TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest,
 
 // Attempt application of a mix of items.  Some update application attempts will
 // fail due to hierarchy conflicts.  Others should succeed.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, ItemsBothKnownAndUnknown) {
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest, ItemsBothKnownAndUnknown) {
   // See what happens when there's a mixture of good and bad updates.
   std::string root_server_id = syncable::GetNullId().GetServerId();
   int64 u1_handle = entry_factory()->CreateUnappliedNewItemWithParent(
@@ -682,7 +682,7 @@ TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, ItemsBothKnownAndUnknown) {
 }
 
 // Attempt application of password upates where the passphrase is known.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, DecryptablePassword) {
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest, DecryptablePassword) {
   // Decryptable password updates should be applied.
   Cryptographer* cryptographer;
   {
@@ -720,7 +720,7 @@ TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, DecryptablePassword) {
 }
 
 // Attempt application of encrypted items when the passphrase is not known.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, UndecryptableData) {
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest, UndecryptableData) {
   // Undecryptable updates should not be applied.
   sync_pb::EntitySpecifics encrypted_bookmark;
   encrypted_bookmark.mutable_encrypted();
@@ -765,7 +765,7 @@ TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, UndecryptableData) {
 }
 
 // Test a mix of decryptable and undecryptable updates.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, SomeUndecryptablePassword) {
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest, SomeUndecryptablePassword) {
   Cryptographer* cryptographer;
 
   int64 decryptable_handle = -1;
diff --git a/sync/engine/download_unittest.cc b/sync/engine/download_unittest.cc
index 1a0c5b9..e114022 100644
--- a/sync/engine/download_unittest.cc
+++ b/sync/engine/download_unittest.cc
@@ -7,15 +7,14 @@
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "sync/engine/get_updates_delegate.h"
-#include "sync/engine/sync_directory_update_handler.h"
+#include "sync/engine/update_handler.h"
 #include "sync/internal_api/public/base/model_type_test_util.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/sessions/debug_info_getter.h"
 #include "sync/sessions/nudge_tracker.h"
 #include "sync/sessions/status_controller.h"
-#include "sync/syncable/directory.h"
 #include "sync/test/engine/fake_model_worker.h"
-#include "sync/test/engine/test_directory_setter_upper.h"
+#include "sync/test/engine/mock_update_handler.h"
 #include "sync/test/sessions/mock_debug_info_getter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -31,25 +30,15 @@ class DownloadUpdatesTest : public ::testing::Test {
     update_handler_deleter_(&update_handler_map_) {}
 
   virtual void SetUp() {
-    dir_maker_.SetUp();
-
-    AddUpdateHandler(AUTOFILL, GROUP_DB);
-    AddUpdateHandler(BOOKMARKS, GROUP_UI);
-    AddUpdateHandler(PREFERENCES, GROUP_UI);
-  }
-
-  virtual void TearDown() {
-    dir_maker_.TearDown();
+    AddUpdateHandler(AUTOFILL);
+    AddUpdateHandler(BOOKMARKS);
+    AddUpdateHandler(PREFERENCES);
   }
 
   ModelTypeSet request_types() {
     return request_types_;
   }
 
-  syncable::Directory* directory() {
-    return dir_maker_.directory();
-  }
-
   scoped_ptr<GetUpdatesProcessor> BuildGetUpdatesProcessor(
       const GetUpdatesDelegate& delegate) {
     return scoped_ptr<GetUpdatesProcessor>(
@@ -72,20 +61,13 @@ class DownloadUpdatesTest : public ::testing::Test {
   const base::TimeTicks kTestStartTime;
 
  private:
-  void AddUpdateHandler(ModelType type, ModelSafeGroup group) {
-    DCHECK(directory());
-
+  void AddUpdateHandler(ModelType type) {
     request_types_.Put(type);
 
-    scoped_refptr<ModelSafeWorker> worker = new FakeModelWorker(group);
-    SyncDirectoryUpdateHandler* handler =
-        new SyncDirectoryUpdateHandler(directory(), type, worker);
+    UpdateHandler* handler = new MockUpdateHandler(type);
     update_handler_map_.insert(std::make_pair(type, handler));
   }
 
-  base::MessageLoop loop_;  // Needed for directory init.
-  TestDirectorySetterUpper dir_maker_;
-
   ModelTypeSet request_types_;
   UpdateHandlerMap update_handler_map_;
   STLValueDeleter<UpdateHandlerMap> update_handler_deleter_;
diff --git a/sync/engine/get_updates_delegate.cc b/sync/engine/get_updates_delegate.cc
index 32cc0f1..d0c7a17 100644
--- a/sync/engine/get_updates_delegate.cc
+++ b/sync/engine/get_updates_delegate.cc
@@ -4,8 +4,8 @@
 
 #include "sync/engine/get_updates_delegate.h"
 
+#include "sync/engine/directory_update_handler.h"
 #include "sync/engine/get_updates_processor.h"
-#include "sync/engine/sync_directory_update_handler.h"
 
 namespace syncer {
 
diff --git a/sync/engine/get_updates_processor.cc b/sync/engine/get_updates_processor.cc
index 16207b8..449f718 100644
--- a/sync/engine/get_updates_processor.cc
+++ b/sync/engine/get_updates_processor.cc
@@ -7,9 +7,12 @@
 #include <map>
 
 #include "sync/engine/get_updates_delegate.h"
-#include "sync/engine/sync_directory_update_handler.h"
+#include "sync/engine/update_handler.h"
 #include "sync/protocol/sync.pb.h"
 
+typedef std::vector<const sync_pb::SyncEntity*> SyncEntityList;
+typedef std::map<syncer::ModelType, SyncEntityList> TypeSyncEntityMap;
+
 namespace syncer {
 
 typedef std::map<ModelType, size_t> TypeToIndexMap;
diff --git a/sync/engine/get_updates_processor.h b/sync/engine/get_updates_processor.h
index 4058091..13a9c83 100644
--- a/sync/engine/get_updates_processor.h
+++ b/sync/engine/get_updates_processor.h
@@ -30,10 +30,6 @@ class Directory;
 }  // namespace syncable
 
 class GetUpdatesDelegate;
-class SyncDirectoryUpdateHandler;
-
-typedef std::vector<const sync_pb::SyncEntity*> SyncEntityList;
-typedef std::map<ModelType, SyncEntityList> TypeSyncEntityMap;
 
 // This class manages the set of per-type syncer objects.
 //
diff --git a/sync/engine/sync_directory_commit_contributor.cc b/sync/engine/sync_directory_commit_contributor.cc
deleted file mode 100644
index c87c8ed..0000000
--- a/sync/engine/sync_directory_commit_contributor.cc
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright 2013 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/sync_directory_commit_contributor.h"
-
-#include "sync/engine/sync_directory_commit_contribution.h"
-
-namespace syncer {
-
-SyncDirectoryCommitContributor::SyncDirectoryCommitContributor(
-    syncable::Directory* dir,
-    ModelType type)
-    : dir_(dir),
-      type_(type) {}
-
-SyncDirectoryCommitContributor::~SyncDirectoryCommitContributor() {}
-
-SyncDirectoryCommitContribution*
-SyncDirectoryCommitContributor::GetContribution(size_t max_entries) {
-  return SyncDirectoryCommitContribution::Build(dir_, type_, max_entries);
-}
-
-}  // namespace syncer
diff --git a/sync/engine/sync_directory_commit_contributor.h b/sync/engine/sync_directory_commit_contributor.h
deleted file mode 100644
index 4a90075..0000000
--- a/sync/engine/sync_directory_commit_contributor.h
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright 2013 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_SYNC_DIRECTORY_COMMIT_CONTRIBUTOR_H_
-#define SYNC_ENGINE_SYNC_DIRECTORY_COMMIT_CONTRIBUTOR_H_
-
-#include <map>
-
-#include "sync/internal_api/public/base/model_type.h"
-
-namespace syncer {
-
-class SyncDirectoryCommitContribution;
-
-namespace syncable {
-class Directory;
-}
-
-// This class represents the syncable::Directory as a source of items to commit
-// to the sync server.
-//
-// Each instance of this class represents a particular type within the
-// syncable::Directory.  When asked, it will iterate through the directory, grab
-// any items of its type that are ready for commit, and return them in the form
-// of a SyncDirectoryCommitContribution.
-class SyncDirectoryCommitContributor {
- public:
-  SyncDirectoryCommitContributor(syncable::Directory* dir, ModelType type);
-  ~SyncDirectoryCommitContributor();
-
-  SyncDirectoryCommitContribution* GetContribution(size_t max_entries);
-
- private:
-  syncable::Directory* dir_;
-  ModelType type_;
-};
-
-}  // namespace
-
-#endif  // SYNC_ENGINE_SYNC_DIRECTORY_COMMIT_CONTRIBUTOR_H_
diff --git a/sync/engine/update_handler.cc b/sync/engine/update_handler.cc
new file mode 100644
index 0000000..308fee9
--- /dev/null
+++ b/sync/engine/update_handler.cc
@@ -0,0 +1,14 @@
+// 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/update_handler.h"
+
+namespace syncer {
+
+UpdateHandler::UpdateHandler() {}
+
+UpdateHandler::~UpdateHandler() {}
+
+
+}  // namespace syncer
diff --git a/sync/engine/update_handler.h b/sync/engine/update_handler.h
new file mode 100644
index 0000000..eb1ee4d
--- /dev/null
+++ b/sync/engine/update_handler.h
@@ -0,0 +1,63 @@
+// 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_UPDATE_HANDLER_H_
+#define SYNC_ENGINE_UPDATE_HANDLER_H_
+
+#include <vector>
+
+#include "sync/base/sync_export.h"
+
+namespace sync_pb {
+class DataTypeProgressMarker;
+class SyncEntity;
+}
+
+typedef std::vector<const sync_pb::SyncEntity*> SyncEntityList;
+
+namespace syncer {
+
+namespace sessions {
+class StatusController;
+}
+
+class ModelSafeWorker;
+
+// This class represents an entity that can request, receive, and apply updates
+// from the sync server.
+class SYNC_EXPORT_PRIVATE UpdateHandler {
+ public:
+  UpdateHandler();
+  virtual ~UpdateHandler() = 0;
+
+  // Fills the given parameter with the stored progress marker for this type.
+  virtual void GetDownloadProgress(
+      sync_pb::DataTypeProgressMarker* progress_marker) const = 0;
+
+  // Processes the contents of a GetUpdates response message.
+  //
+  // Should be invoked with the progress marker and set of SyncEntities from a
+  // single GetUpdates response message.  The progress marker's type must match
+  // this update handler's type, and the set of SyncEntities must include all
+  // entities of this type found in the response message.
+  //
+  // In this context, "applicable_updates" means the set of updates belonging to
+  // this type.
+  virtual void ProcessGetUpdatesResponse(
+      const sync_pb::DataTypeProgressMarker& progress_marker,
+      const SyncEntityList& applicable_updates,
+      sessions::StatusController* status) = 0;
+
+  // Called at the end of a non-configure GetUpdates loop to apply any unapplied
+  // updates.
+  virtual void ApplyUpdates(sessions::StatusController* status) = 0;
+
+  // Called at the end of a configure GetUpdates loop to perform any required
+  // post-initial-download update application.
+  virtual void PassiveApplyUpdates(sessions::StatusController* status) = 0;
+};
+
+}  // namespace syncer
+
+#endif  // SYNC_ENGINE_UPDATE_HANDLER_H_