Relieve SyncerSession,SyncCycleState, SyncProcessState, SyncerSession, Syncer...

chrome/browser/sync/engine/syncer_unittest.cc

 // Copyright (c) 2009 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 entry.
 //
 // Syncer unit tests. Unfortunately a lot of these tests
 // are outdated and need to be reworked and updated.
 
 #include <list>
 #include <map>
 #include <set>
 
 #include "base/at_exit.h"
 
 #include "base/scoped_ptr.h"
 #include "build/build_config.h"
-#include "chrome/browser/sync/engine/client_command_channel.h"
-#include "chrome/browser/sync/engine/conflict_resolution_view.h"
 #include "chrome/browser/sync/engine/conflict_resolver.h"
 #include "chrome/browser/sync/engine/get_commit_ids_command.h"
 #include "chrome/browser/sync/engine/model_safe_worker.h"
 #include "chrome/browser/sync/engine/net/server_connection_manager.h"
 #include "chrome/browser/sync/engine/process_updates_command.h"
 #include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/engine/syncer_util.h"
 #include "chrome/browser/sync/engine/syncer_proto_util.h"
-#include "chrome/browser/sync/engine/syncer_session.h"
 #include "chrome/browser/sync/protocol/sync.pb.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/syncable.h"
 #include "chrome/browser/sync/util/closure.h"
 #include "chrome/browser/sync/util/event_sys-inl.h"
 #include "chrome/test/sync/engine/mock_server_connection.h"
 #include "chrome/test/sync/engine/test_directory_setter_upper.h"
 #include "chrome/test/sync/engine/test_id_factory.h"
 #include "chrome/test/sync/engine/test_syncable_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using base::TimeDelta;
+
 using std::map;
 using std::multimap;
 using std::set;
 using std::string;
 
 namespace browser_sync {
 
 using syncable::BaseTransaction;
 using syncable::Blob;
 using syncable::CountEntriesWithName;
@@ skipping 29 matching lines @@
 using syncable::PARENT_ID;
 using syncable::PREV_ID;
 using syncable::SERVER_IS_DEL;
 using syncable::SERVER_NON_UNIQUE_NAME;
 using syncable::SERVER_PARENT_ID;
 using syncable::SERVER_POSITION_IN_PARENT;
 using syncable::SERVER_VERSION;
 using syncable::SINGLETON_TAG;
 using syncable::UNITTEST;
 
+using sessions::ConflictProgress;
+using sessions::ScopedSetSessionWriteTransaction;
+using sessions::StatusController;
+using sessions::SyncSessionContext;
+using sessions::SyncSession;
+
 namespace {
 const char* kTestData = "Hello World!";
 const int kTestDataLen = 12;
 const int64 kTestLogRequestTimestamp = 123456;
 }  // namespace
 
-class SyncerTest : public testing::Test {
+class SyncerTest : public testing::Test, public SyncSession::Delegate {
  protected:
-  SyncerTest() : client_command_channel_(0) {
+  SyncerTest() : syncer_(NULL) {}
+
+  // SyncSession::Delegate implementation.
+  virtual void OnSilencedUntil(const base::TimeTicks& silenced_until) {
+    FAIL() << "Should not get silenced.";
   }
-
-  void HandleClientCommand(const sync_pb::ClientCommand* event) {
-    last_client_command_ = *event;
+  virtual bool IsSyncingCurrentlySilenced() {
+    return false;
+  }
+  virtual void OnReceivedLongPollIntervalUpdate(
+      const base::TimeDelta& new_interval) {
+    last_long_poll_interval_received_ = new_interval;
+  }
+  virtual void OnReceivedShortPollIntervalUpdate(
+      const base::TimeDelta& new_interval) {
+    last_short_poll_interval_received_ = new_interval;
   }
 
   void HandleSyncerEvent(SyncerEvent event) {
     LOG(INFO) << "HandleSyncerEvent in unittest " << event.what_happened;
     // we only test for entry-specific events, not status changed ones.
     switch (event.what_happened) {
       case SyncerEvent::STATUS_CHANGED:
         // fall through
       case SyncerEvent::SYNC_CYCLE_ENDED:
         // fall through
       case SyncerEvent::COMMITS_SUCCEEDED:
         return;
       case SyncerEvent::SHUTDOWN_USE_WITH_CARE:
       case SyncerEvent::OVER_QUOTA:
       case SyncerEvent::REQUEST_SYNC_NUDGE:
         LOG(INFO) << "Handling event type " << event.what_happened;
         break;
       default:
         CHECK(false) << "Handling unknown error type in unit tests!!";
     }
     syncer_events_.insert(event);
   }
 
   void LoopSyncShare(Syncer* syncer) {
-    SyncProcessState state(syncdb_.manager(), syncdb_.name(),
-                           mock_server_.get(),
-                           syncer->conflict_resolver(),
-                           syncer->channel(),
-                           syncer->model_safe_worker());
     bool should_loop = false;
     int loop_iterations = 0;
     do {
       ASSERT_LT(++loop_iterations, 100) << "infinite loop detected. please fix";
-      should_loop = syncer->SyncShare(&state);
+      should_loop = syncer->SyncShare(this);
     } while (should_loop);
   }
 
   virtual void SetUp() {
     syncdb_.SetUp();
 
     mock_server_.reset(
         new MockConnectionManager(syncdb_.manager(), syncdb_.name()));
-    model_safe_worker_.reset(new ModelSafeWorker());
-    // Safe to pass NULL as Authwatcher for now since the code path that
-    // uses it is not unittested yet.
-    syncer_ = new Syncer(syncdb_.manager(), syncdb_.name(),
-        mock_server_.get(),
-        model_safe_worker_.get());
-    CHECK(syncer_->channel());
 
-    hookup_.reset(NewEventListenerHookup(syncer_->channel(), this,
+    context_.reset(new SyncSessionContext(mock_server_.get(), syncdb_.manager(),
+        new ModelSafeWorker()));
+    context_->set_account_name(syncdb_.name());
+    ASSERT_FALSE(context_->syncer_event_channel());
+    ASSERT_FALSE(context_->resolver());
+    syncer_ = new Syncer(context_.get());
+    // The Syncer installs some components on the context.
+    ASSERT_TRUE(context_->syncer_event_channel());
+    ASSERT_TRUE(context_->resolver());
+
+    hookup_.reset(NewEventListenerHookup(context_->syncer_event_channel(), this,
                                          &SyncerTest::HandleSyncerEvent));
-
-    command_channel_hookup_.reset(NewEventListenerHookup(
-        &client_command_channel_, this, &SyncerTest::HandleClientCommand));
-    syncer_->set_command_channel(&client_command_channel_);
-
-    state_.reset(new SyncProcessState(syncdb_.manager(), syncdb_.name(),
-                                      mock_server_.get(),
-                                      syncer_->conflict_resolver(),
-                                      syncer_->channel(),
-                                      syncer_->model_safe_worker()));
+    session_.reset(new SyncSession(context_.get(), this));
 
     ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
     CHECK(dir.good());
     ReadTransaction trans(dir, __FILE__, __LINE__);
     syncable::Directory::ChildHandles children;
     dir->GetChildHandles(&trans, trans.root_id(), &children);
     ASSERT_TRUE(0 == children.size());
     syncer_events_.clear();
     root_id_ = TestIdFactory::root();
     parent_id_ = ids_.MakeServer("parent id");
     child_id_ = ids_.MakeServer("child id");
   }
 
   virtual void TearDown() {
     mock_server_.reset();
     hookup_.reset();
-    command_channel_hookup_.reset();
     delete syncer_;
+    syncer_ = NULL;
     syncdb_.TearDown();
   }
   void WriteTestDataToEntry(WriteTransaction* trans, MutableEntry* entry) {
     EXPECT_FALSE(entry->Get(IS_DIR));
     EXPECT_FALSE(entry->Get(IS_DEL));
     Blob test_value(kTestData, kTestData + kTestDataLen);
     ExtendedAttributeKey key(entry->Get(META_HANDLE), PSTR("DATA"));
     MutableExtendedAttribute attr(trans, CREATE, key);
     attr.mutable_value()->swap(test_value);
     entry->Put(syncable::IS_UNSYNCED, true);
   }
   void VerifyTestDataInEntry(BaseTransaction* trans, Entry* entry) {
     EXPECT_FALSE(entry->Get(IS_DIR));
     EXPECT_FALSE(entry->Get(IS_DEL));
     Blob test_value(kTestData, kTestData + kTestDataLen);
     ExtendedAttributeKey key(entry->Get(META_HANDLE), PSTR("DATA"));
     ExtendedAttribute attr(trans, GET_BY_HANDLE, key);
     EXPECT_FALSE(attr.is_deleted());
     EXPECT_TRUE(test_value == attr.value());
   }
-  bool SyncerStuck(SyncProcessState* state) {
-    SyncerStatus status(NULL, state);
-    return status.syncer_stuck();
+  void SyncRepeatedlyToTriggerConflictResolution(SyncSession* session) {
+    // We should trigger after less than 6 syncs, but extra does no harm.
+    for (int i = 0 ; i < 6 ; ++i)
+      syncer_->SyncShare(session);
   }
-  void SyncRepeatedlyToTriggerConflictResolution(SyncProcessState* state) {
-    // We should trigger after less than 6 syncs, but we want to avoid brittle
-    // tests.
-    for (int i = 0 ; i < 6 ; ++i)
-      syncer_->SyncShare(state);
-  }
-  void SyncRepeatedlyToTriggerStuckSignal(SyncProcessState* state) {
+  void SyncRepeatedlyToTriggerStuckSignal(SyncSession* session) {
     // We should trigger after less than 10 syncs, but we want to avoid brittle
     // tests.
     for (int i = 0 ; i < 12 ; ++i)
-      syncer_->SyncShare(state);
+      syncer_->SyncShare(session);
   }
 
   // Enumeration of alterations to entries for commit ordering tests.
   enum EntryFeature {
     LIST_END = 0,  // Denotes the end of the list of features from below.
     SYNCED,  // Items are unsynced by default
     DELETED,
     OLD_MTIME,
     MOVED_FROM_ROOT,
   };
@@ skipping 70 matching lines @@
       EXPECT_TRUE(1 == expected_positions.count(i));
       EXPECT_TRUE(expected_positions[i] == mock_server_->committed_ids()[i]);
     }
   }
 
   void DoTruncationTest(const ScopedDirLookup& dir,
                         const vector<int64>& unsynced_handle_view,
                         const vector<syncable::Id>& expected_id_order) {
     // The expected order is "x", "b", "c", "e", truncated appropriately.
     for (size_t limit = expected_id_order.size() + 2; limit > 0; --limit) {
-      SyncCycleState cycle_state;
-      SyncerSession session(&cycle_state, state_.get());
+      StatusController* status = session_->status_controller();
+      status->ResetTransientState();
       WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
-      SyncerSession::ScopedSetWriteTransaction set_trans(&session, &wtrans);
-      session.set_unsynced_handles(unsynced_handle_view);
+      ScopedSetSessionWriteTransaction set_trans(session_.get(), &wtrans);
+      status->set_unsynced_handles(unsynced_handle_view);
 
       GetCommitIdsCommand command(limit);
-      command.BuildCommitIds(&session);
+      command.BuildCommitIds(session_->status_controller()->unsynced_handles(),
+          session_->write_transaction());
       vector<syncable::Id> output = command.ordered_commit_set_.GetCommitIds();
       size_t truncated_size = std::min(limit, expected_id_order.size());
       ASSERT_TRUE(truncated_size == output.size());
       for (size_t i = 0; i < truncated_size; ++i) {
         ASSERT_TRUE(expected_id_order[i] == output[i])
             << "At index " << i << " with batch size limited to " << limit;
       }
     }
   }
 
@@ skipping 24 matching lines @@
   // more confusing.
   syncable::Id root_id_;
   syncable::Id parent_id_;
   syncable::Id child_id_;
 
   TestIdFactory ids_;
 
   TestDirectorySetterUpper syncdb_;
   scoped_ptr<MockConnectionManager> mock_server_;
   scoped_ptr<EventListenerHookup> hookup_;
-  scoped_ptr<EventListenerHookup> command_channel_hookup_;
-  ClientCommandChannel client_command_channel_;
 
   Syncer* syncer_;
-  scoped_ptr<SyncProcessState> state_;
-  scoped_ptr<ModelSafeWorker> model_safe_worker_;
+
+  scoped_ptr<SyncSession> session_;
+  scoped_ptr<SyncSessionContext> context_;
   std::set<SyncerEvent> syncer_events_;
-  sync_pb::ClientCommand last_client_command_;
+  base::TimeDelta last_short_poll_interval_received_;
+  base::TimeDelta last_long_poll_interval_received_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncerTest);
 };
 
 TEST_F(SyncerTest, TestCallGatherUnsyncedEntries) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   {
     Syncer::UnsyncedMetaHandles handles;
     {
@@ skipping 41 matching lines @@
   unsynced_handle_view.push_back(handle_e);
   expected_order.push_back(ids_.MakeLocal("x"));
   expected_order.push_back(ids_.MakeLocal("b"));
   expected_order.push_back(ids_.MakeLocal("c"));
   expected_order.push_back(ids_.MakeLocal("e"));
   DoTruncationTest(dir, unsynced_handle_view, expected_order);
 }
 
 // TODO(chron): More corner case unit tests around validation.
 TEST_F(SyncerTest, TestCommitMetahandleIterator) {
-  SyncCycleState cycle_state;
-  SyncerSession session(&cycle_state, state_.get());
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
+  StatusController* status = session_->status_controller();
+  const vector<int64>& unsynced(status->unsynced_handles());
 
   {
     WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
-    SyncerSession::ScopedSetWriteTransaction set_trans(&session, &wtrans);
+    ScopedSetSessionWriteTransaction set_trans(session_.get(), &wtrans);
 
     GetCommitIdsCommand::OrderedCommitSet commit_set;
-    GetCommitIdsCommand::CommitMetahandleIterator iterator(&session,
+    GetCommitIdsCommand::CommitMetahandleIterator iterator(unsynced, &wtrans,
         &commit_set);
     EXPECT_FALSE(iterator.Valid());
     EXPECT_FALSE(iterator.Increment());
   }
 
   {
     vector<int64> session_metahandles;
     session_metahandles.push_back(
         CreateUnsyncedDirectory(PSTR("test1"), "testid1"));
     session_metahandles.push_back(
         CreateUnsyncedDirectory(PSTR("test2"), "testid2"));
     session_metahandles.push_back(
         CreateUnsyncedDirectory(PSTR("test3"), "testid3"));
-    session.set_unsynced_handles(session_metahandles);
+    status->set_unsynced_handles(session_metahandles);
 
     WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
-    SyncerSession::ScopedSetWriteTransaction set_trans(&session, &wtrans);
+    ScopedSetSessionWriteTransaction set_trans(session_.get(), &wtrans);
     GetCommitIdsCommand::OrderedCommitSet commit_set;
-    GetCommitIdsCommand::CommitMetahandleIterator iterator(&session,
+    GetCommitIdsCommand::CommitMetahandleIterator iterator(unsynced, &wtrans,
         &commit_set);
 
     EXPECT_TRUE(iterator.Valid());
     EXPECT_TRUE(iterator.Current() == session_metahandles[0]);
     EXPECT_TRUE(iterator.Increment());
 
     EXPECT_TRUE(iterator.Valid());
     EXPECT_TRUE(iterator.Current() == session_metahandles[1]);
     EXPECT_TRUE(iterator.Increment());
 
@@ skipping 18 matching lines @@
     parent.Put(syncable::IS_DIR, true);
     parent.Put(syncable::BASE_VERSION, 1);
     parent.Put(syncable::ID, parent_id_);
     MutableEntry child(&wtrans, syncable::CREATE, parent_id_, PSTR("Pete"));
     ASSERT_TRUE(child.good());
     child.Put(syncable::ID, child_id_);
     child.Put(syncable::BASE_VERSION, 1);
     WriteTestDataToEntry(&wtrans, &child);
   }
 
-  SyncCycleState cycle_state;
-  SyncerSession session(&cycle_state, state_.get());
-
-  syncer_->SyncShare(&session);
-  EXPECT_TRUE(2 == session.unsynced_count());
+  StatusController* status = session_->status_controller();
+  syncer_->SyncShare(session_.get());
+  EXPECT_TRUE(2 == status->unsynced_handles().size());
   ASSERT_TRUE(2 == mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_TRUE(parent_id_ == mock_server_->committed_ids()[0]);
   EXPECT_TRUE(child_id_ == mock_server_->committed_ids()[1]);
   {
     ReadTransaction rt(dir, __FILE__, __LINE__);
     Entry entry(&rt, syncable::GET_BY_ID, child_id_);
     ASSERT_TRUE(entry.good());
     VerifyTestDataInEntry(&rt, &entry);
   }
@@ skipping 183 matching lines @@
       ASSERT_TRUE(grandchild.good());
       grandchild.Put(syncable::IS_UNSYNCED, true);
       grandchild.Put(syncable::ID, ids_.FromNumber(105));
       grandchild.Put(syncable::IS_DEL, true);
       grandchild.Put(syncable::IS_DIR, false);
       grandchild.Put(syncable::BASE_VERSION, 1);
       grandchild.Put(syncable::MTIME, now_minus_2h);
     }
   }
 
-  SyncCycleState cycle_state;
-  SyncerSession session(&cycle_state, state_.get());
-  syncer_->SyncShare(&session);
-  EXPECT_TRUE(6 == session.unsynced_count());
+  syncer_->SyncShare(session_.get());
+  EXPECT_TRUE(6 == session_->status_controller()->unsynced_handles().size());
   ASSERT_TRUE(6 == mock_server_->committed_ids().size());
   // This test will NOT unroll deletes because SERVER_PARENT_ID is not set.
   // It will treat these like moves.
   vector<syncable::Id> commit_ids(mock_server_->committed_ids());
   EXPECT_TRUE(ids_.FromNumber(100) == commit_ids[0]);
   EXPECT_TRUE(ids_.FromNumber(101) == commit_ids[1]);
   EXPECT_TRUE(ids_.FromNumber(102) == commit_ids[2]);
   // We don't guarantee the delete orders in this test, only that they occur
   // at the end.
   std::sort(commit_ids.begin() + 3, commit_ids.end());
@@ skipping 42 matching lines @@
     parent.Put(syncable::IS_DIR, true);
     parent.Put(syncable::ID, ids_.FromNumber(-104));
     MutableEntry child(&wtrans, syncable::CREATE, child_id_, PSTR("B"));
     ASSERT_TRUE(child.good());
     child.Put(syncable::IS_UNSYNCED, true);
     child.Put(syncable::IS_DIR, true);
     child.Put(syncable::ID, ids_.FromNumber(105));
     child.Put(syncable::BASE_VERSION, 1);
   }
 
-  SyncCycleState cycle_state;
-  SyncerSession session(&cycle_state, state_.get());
-  syncer_->SyncShare(&session);
-  EXPECT_TRUE(6 == session.unsynced_count());
+  syncer_->SyncShare(session_.get());
+  EXPECT_TRUE(6 == session_->status_controller()->unsynced_handles().size());
   ASSERT_TRUE(6 == mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_TRUE(parent_id_ == mock_server_->committed_ids()[0]);
   EXPECT_TRUE(child_id_ == mock_server_->committed_ids()[1]);
   EXPECT_TRUE(ids_.FromNumber(102) == mock_server_->committed_ids()[2]);
   EXPECT_TRUE(ids_.FromNumber(-103) == mock_server_->committed_ids()[3]);
   EXPECT_TRUE(ids_.FromNumber(-104) == mock_server_->committed_ids()[4]);
   EXPECT_TRUE(ids_.FromNumber(105) == mock_server_->committed_ids()[5]);
 }
 
@@ skipping 16 matching lines @@
     child1.Put(syncable::ID, child_id_);
     MutableEntry child2(&wtrans, syncable::CREATE, parent_id_, PSTR("2"));
     ASSERT_TRUE(child2.good());
     child2.Put(syncable::IS_UNSYNCED, true);
     child2.Put(syncable::ID, child2_id);
     parent.Put(syncable::BASE_VERSION, 1);
     child1.Put(syncable::BASE_VERSION, 1);
     child2.Put(syncable::BASE_VERSION, 1);
   }
 
-  SyncCycleState cycle_state;
-  SyncerSession session(&cycle_state, state_.get());
-  syncer_->SyncShare(&session);
-  EXPECT_TRUE(3 == session.unsynced_count());
+  syncer_->SyncShare(session_.get());
+  EXPECT_TRUE(3 == session_->status_controller()->unsynced_handles().size());
   ASSERT_TRUE(3 == mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_TRUE(parent_id_ == mock_server_->committed_ids()[0]);
   EXPECT_TRUE(child_id_ == mock_server_->committed_ids()[1]);
   EXPECT_TRUE(child2_id == mock_server_->committed_ids()[2]);
 }
 
 TEST_F(SyncerTest, TestCommitListOrderingAndNewParent) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
@@ skipping 23 matching lines @@
     parent2.Put(syncable::ID, parent2_id);
 
     MutableEntry child(&wtrans, syncable::CREATE, parent2_id, child_name);
     ASSERT_TRUE(child.good());
     child.Put(syncable::IS_UNSYNCED, true);
     child.Put(syncable::IS_DIR, true);
     child.Put(syncable::ID, child_id);
     child.Put(syncable::BASE_VERSION, 1);
   }
 
-  SyncCycleState cycle_state;
-  SyncerSession session(&cycle_state, state_.get());
-
-  syncer_->SyncShare(&session);
-  EXPECT_TRUE(3 == session.unsynced_count());
+  syncer_->SyncShare(session_.get());
+  EXPECT_TRUE(3 == session_->status_controller()->unsynced_handles().size());
   ASSERT_TRUE(3 == mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_TRUE(parent_id_ == mock_server_->committed_ids()[0]);
   EXPECT_TRUE(parent2_id == mock_server_->committed_ids()[1]);
   EXPECT_TRUE(child_id == mock_server_->committed_ids()[2]);
   {
     ReadTransaction rtrans(dir, __FILE__, __LINE__);
     // Check that things committed correctly.
     Entry entry_1(&rtrans, syncable::GET_BY_ID, parent_id_);
     EXPECT_EQ(entry_1.Get(NON_UNIQUE_NAME), parent1_name);
@@ skipping 50 matching lines @@
     parent2.Put(syncable::ID, parent2_local_id);
     meta_handle_a = parent2.Get(syncable::META_HANDLE);
     MutableEntry child(&wtrans, syncable::CREATE, parent2_local_id, child_name);
     ASSERT_TRUE(child.good());
     child.Put(syncable::IS_UNSYNCED, true);
     child.Put(syncable::IS_DIR, true);
     child.Put(syncable::ID, child_local_id);
     meta_handle_b = child.Get(syncable::META_HANDLE);
   }
 
-  SyncCycleState cycle_state;
-  SyncerSession session(&cycle_state, state_.get());
-
-  syncer_->SyncShare(&session);
-  EXPECT_TRUE(3 == session.unsynced_count());
+  syncer_->SyncShare(session_.get());
+  EXPECT_TRUE(3 == session_->status_controller()->unsynced_handles().size());
   ASSERT_TRUE(3 == mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_TRUE(parent_id_ == mock_server_->committed_ids()[0]);
   EXPECT_TRUE(parent2_local_id == mock_server_->committed_ids()[1]);
   EXPECT_TRUE(child_local_id == mock_server_->committed_ids()[2]);
   {
     ReadTransaction rtrans(dir, __FILE__, __LINE__);
 
     Entry parent(&rtrans, syncable::GET_BY_ID,
                  GetOnlyEntryWithName(&rtrans, rtrans.root_id(), parent_name));
@@ skipping 17 matching lines @@
   }
 }
 
 TEST_F(SyncerTest, UpdateWithZeroLengthName) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   // One illegal update
   mock_server_->AddUpdateDirectory(1, 0, "", 1, 10);
   // And one legal one that we're going to delete.
   mock_server_->AddUpdateDirectory(2, 0, "FOO", 1, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   // Delete the legal one. The new update has a null name.
   mock_server_->AddUpdateDirectory(2, 0, "", 2, 20);
   mock_server_->SetLastUpdateDeleted();
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
 }
 
 TEST_F(SyncerTest, DontGetStuckWithTwoSameNames) {
   // We should not get stuck here because we get
   // two server updates with exactly the same name.
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "foo:", 1, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   mock_server_->AddUpdateDirectory(2, 0, "foo:", 1, 20);
-  SyncRepeatedlyToTriggerStuckSignal(state_.get());
-  EXPECT_FALSE(SyncerStuck(state_.get()));
+  SyncRepeatedlyToTriggerStuckSignal(session_.get());
+  EXPECT_FALSE(session_->status_controller()->syncer_status().syncer_stuck);
   syncer_events_.clear();
 }
 
 TEST_F(SyncerTest, ExtendedAttributeWithNullCharacter) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   size_t xattr_count = 2;
   PathString xattr_keys[] = { PSTR("key"), PSTR("key2") };
   syncable::Blob xattr_values[2];
   const char* value[] = { "value", "val\0ue" };
   int value_length[] = { 5, 6 };
   for (size_t i = 0; i < xattr_count; i++) {
     for (int j = 0; j < value_length[i]; j++)
       xattr_values[i].push_back(value[i][j]);
   }
   sync_pb::SyncEntity* ent =
       mock_server_->AddUpdateBookmark(1, 0, "bob", 1, 10);
   mock_server_->AddUpdateExtendedAttributes(
       ent, xattr_keys, xattr_values, xattr_count);
 
   // Add some other items.
   mock_server_->AddUpdateBookmark(2, 0, "fred", 2, 10);
   mock_server_->AddUpdateBookmark(3, 0, "sue", 15, 10);
 
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   ReadTransaction trans(dir, __FILE__, __LINE__);
   Entry entry1(&trans, syncable::GET_BY_ID, ids_.FromNumber(1));
   ASSERT_TRUE(entry1.good());
   EXPECT_TRUE(1 == entry1.Get(syncable::BASE_VERSION));
   EXPECT_TRUE(1 == entry1.Get(syncable::SERVER_VERSION));
   set<ExtendedAttribute> client_extended_attributes;
   entry1.GetAllExtendedAttributes(&trans, &client_extended_attributes);
   EXPECT_TRUE(xattr_count == client_extended_attributes.size());
   for (size_t i = 0; i < xattr_count; i++) {
     ExtendedAttributeKey key(entry1.Get(syncable::META_HANDLE), xattr_keys[i]);
@@ skipping 13 matching lines @@
 TEST_F(SyncerTest, TestBasicUpdate) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   string id = "some_id";
   string parent_id = "0";
   string name = "in_root";
   int64 version = 10;
   int64 timestamp = 10;
   mock_server_->AddUpdateDirectory(id, parent_id, name, version, timestamp);
 
-  syncer_->SyncShare(state_.get());
-  SyncerStatus status(NULL, state_.get());
+  syncer_->SyncShare(this);
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     Entry entry(&trans, GET_BY_ID,
                syncable::Id::CreateFromServerId("some_id"));
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.Get(IS_DIR));
     EXPECT_TRUE(entry.Get(SERVER_VERSION) == version);
     EXPECT_TRUE(entry.Get(BASE_VERSION) == version);
     EXPECT_FALSE(entry.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(entry.Get(IS_UNSYNCED));
@@ skipping 12 matching lines @@
   // Same name. But this SHOULD work.
   mock_server_->AddUpdateDirectory(2, 0, "in_root", 10, 10);
 
   // Unknown parent: should never be applied. "-80" is a legal server ID,
   // because any string sent by the server is a legal server ID in the sync
   // protocol, but it's not the ID of any item known to the client.  This
   // update should succeed validation, but be stuck in the unapplied state
   // until an item with the server ID "-80" arrives.
   mock_server_->AddUpdateDirectory(3, -80, "bad_parent", 10, 10);
 
-  syncer_->SyncShare(state_.get());
+  syncer_->SyncShare(session_.get());
+  StatusController* status = session_->status_controller();
 
-  ConflictResolutionView conflict_view(state_.get());
-  SyncerStatus status(NULL, state_.get());
   // Id 3 should be in conflict now.
-  EXPECT_TRUE(1 == conflict_view.conflicting_updates());
+  EXPECT_TRUE(1 == status->conflict_progress()->ConflictingItemsSize());
 
   // These entries will be used in the second set of updates.
   mock_server_->AddUpdateDirectory(4, 0, "newer_version", 20, 10);
   mock_server_->AddUpdateDirectory(5, 0, "circular1", 10, 10);
   mock_server_->AddUpdateDirectory(6, 5, "circular2", 10, 10);
   mock_server_->AddUpdateDirectory(9, 3, "bad_parent_child", 10, 10);
   mock_server_->AddUpdateDirectory(100, 9, "bad_parent_child2", 10, 10);
   mock_server_->AddUpdateDirectory(10, 0, "dir_to_bookmark", 10, 10);
 
-  syncer_->SyncShare(state_.get());
+  syncer_->SyncShare(session_.get());
   // The three items with an unresolved parent should be unapplied (3, 9, 100).
-  EXPECT_TRUE(3 == conflict_view.conflicting_updates());
+  // The name clash should also still be in conflict.
+  EXPECT_TRUE(3 ==  status->conflict_progress()->ConflictingItemsSize());
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     // Even though it has the same name, it should work.
     Entry name_clash(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(name_clash.good());
     EXPECT_FALSE(name_clash.Get(IS_UNAPPLIED_UPDATE))
         << "Duplicate name SHOULD be OK.";
 
     Entry bad_parent(&trans, GET_BY_ID, ids_.FromNumber(3));
     ASSERT_TRUE(bad_parent.good());
@@ skipping 12 matching lines @@
   }
 
   // Updating 1 should not affect item 2 of the same name.
   mock_server_->AddUpdateDirectory(1, 0, "new_name", 20, 20);
 
   // Moving 5 under 6 will create a cycle: a conflict.
   mock_server_->AddUpdateDirectory(5, 6, "circular3", 20, 20);
 
   // Flip the is_dir bit: should fail verify & be dropped.
   mock_server_->AddUpdateBookmark(10, 0, "dir_to_bookmark", 20, 20);
-  syncer_->SyncShare(state_.get());
+  syncer_->SyncShare(session_.get());
 
   // Version number older than last known: should fail verify & be dropped.
   mock_server_->AddUpdateDirectory(4, 0, "old_version", 10, 10);
-  syncer_->SyncShare(state_.get());
+  syncer_->SyncShare(session_.get());
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
 
     Entry still_a_dir(&trans, GET_BY_ID, ids_.FromNumber(10));
     ASSERT_TRUE(still_a_dir.good());
     EXPECT_FALSE(still_a_dir.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(10 == still_a_dir.Get(BASE_VERSION));
     EXPECT_TRUE(10 == still_a_dir.Get(SERVER_VERSION));
     EXPECT_TRUE(still_a_dir.Get(IS_DIR));
 
@@ skipping 30 matching lines @@
 
     Entry circular_parent_target(&trans, GET_BY_ID, ids_.FromNumber(6));
     ASSERT_TRUE(circular_parent_target.good());
     EXPECT_FALSE(circular_parent_target.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(circular_parent_issue.Get(ID) ==
         circular_parent_target.Get(PARENT_ID));
     EXPECT_TRUE(10 == circular_parent_target.Get(BASE_VERSION));
   }
 
   EXPECT_TRUE(0 == syncer_events_.size());
-  EXPECT_TRUE(4 == conflict_view.conflicting_updates());
+  EXPECT_TRUE(4 == status->conflict_progress()->ConflictingItemsSize());
 }
 
 TEST_F(SyncerTest, CommitTimeRename) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   int64 metahandle_folder;
   int64 metahandle_new_entry;
 
   // Create a folder and an entry.
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry parent(&trans, CREATE, root_id_, PSTR("Folder"));
     ASSERT_TRUE(parent.good());
     parent.Put(IS_DIR, true);
     parent.Put(IS_UNSYNCED, true);
     metahandle_folder = parent.Get(META_HANDLE);
 
     MutableEntry entry(&trans, CREATE, parent.Get(ID), PSTR("new_entry"));
     ASSERT_TRUE(entry.good());
     metahandle_new_entry = entry.Get(META_HANDLE);
     WriteTestDataToEntry(&trans, &entry);
   }
 
   // Mix in a directory creation too for later.
   mock_server_->AddUpdateDirectory(2, 0, "dir_in_root", 10, 10);
   mock_server_->SetCommitTimeRename("renamed_");
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
 
   // Verify it was correctly renamed.
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry entry_folder(&trans, GET_BY_HANDLE, metahandle_folder);
     ASSERT_TRUE(entry_folder.good());
     EXPECT_EQ(PSTR("renamed_Folder"), entry_folder.Get(NON_UNIQUE_NAME));
 
     Entry entry_new(&trans, GET_BY_HANDLE, metahandle_new_entry);
     ASSERT_TRUE(entry_new.good());
@@ skipping 21 matching lines @@
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry parent(&trans, CREATE, root_id_, PSTR("Folder"));
     ASSERT_TRUE(parent.good());
     parent.Put(IS_DIR, true);
     parent.Put(IS_UNSYNCED, true);
     metahandle = parent.Get(META_HANDLE);
   }
 
   mock_server_->SetCommitTimeRename(i18nString);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
 
   // Verify it was correctly renamed.
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     PathString expected_folder_name(i18nString);
     expected_folder_name.append("Folder");
 
 
     Entry entry_folder(&trans, GET_BY_HANDLE, metahandle);
     ASSERT_TRUE(entry_folder.good());
@@ skipping 61 matching lines @@
   // well as reassociate the id.
   mock_server_->AddUpdateDirectory(new_folder_id, root_id_,
       "new_folder", new_version, timestamp);
   mock_server_->SetLastUpdateOriginatorFields(
       dir->cache_guid(), folder_id.GetServerId());
 
   // We don't want it accidentally committed, just the update applied.
   mock_server_->set_conflict_all_commits(true);
 
   // Alright! Apply that update!
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     // The folder's ID should have been updated.
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry folder(&trans, GET_BY_HANDLE, metahandle_folder);
     ASSERT_TRUE(folder.good());
     EXPECT_EQ(PSTR("new_folder"), folder.Get(NON_UNIQUE_NAME));
     EXPECT_TRUE(new_version == folder.Get(BASE_VERSION));
     EXPECT_TRUE(new_folder_id == folder.Get(ID));
     EXPECT_TRUE(folder.Get(ID).ServerKnows());
     EXPECT_EQ(trans.root_id(), folder.Get(PARENT_ID));
@@ skipping 48 matching lines @@
   // Generate an update from the server with a relevant ID reassignment.
   mock_server_->AddUpdateBookmark(new_entry_id, root_id_,
       "new_entry", new_version, timestamp);
   mock_server_->SetLastUpdateOriginatorFields(
       dir->cache_guid(), entry_id.GetServerId());
 
   // We don't want it accidentally committed, just the update applied.
   mock_server_->set_conflict_all_commits(true);
 
   // Alright! Apply that update!
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry entry(&trans, GET_BY_HANDLE, entry_metahandle);
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(new_version == entry.Get(BASE_VERSION));
     EXPECT_TRUE(new_entry_id == entry.Get(ID));
     EXPECT_EQ(PSTR("new_entry"), entry.Get(NON_UNIQUE_NAME));
   }
 }
 
@@ skipping 45 matching lines @@
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     Id new_entry_id = GetOnlyEntryWithName(
         &trans, trans.root_id(), PSTR("new_entry"));
     MutableEntry entry(&trans, GET_BY_ID, new_entry_id);
     ASSERT_TRUE(entry.good());
     entry.Put(syncable::IS_DEL, true);
   }
 
   // Just don't CHECK fail in sync, have the update split.
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Id new_entry_id = GetOnlyEntryWithName(
         &trans, trans.root_id(), PSTR("new_entry"));
     Entry entry(&trans, GET_BY_ID, new_entry_id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.Get(IS_DEL));
 
     Entry old_entry(&trans, GET_BY_ID, entry_id);
     ASSERT_TRUE(old_entry.good());
     EXPECT_TRUE(old_entry.Get(IS_DEL));
   }
 }
 
 // TODO(chron): Add more unsanitized name tests.
 TEST_F(SyncerTest, ConflictMatchingEntryHandlesUnsanitizedNames) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "A/A", 10, 10);
   mock_server_->AddUpdateDirectory(2, 0, "B/B", 10, 10);
   mock_server_->set_conflict_all_commits(true);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
 
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.Put(IS_UNSYNCED, true);
     A.Put(IS_UNAPPLIED_UPDATE, true);
     A.Put(SERVER_VERSION, 20);
 
     MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
@@ skipping 21 matching lines @@
     EXPECT_TRUE(B.Get(SERVER_VERSION) == 20);
   }
 }
 
 TEST_F(SyncerTest, ConflictMatchingEntryHandlesNormalNames) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10);
   mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10);
   mock_server_->set_conflict_all_commits(true);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
 
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.Put(IS_UNSYNCED, true);
     A.Put(IS_UNAPPLIED_UPDATE, true);
     A.Put(SERVER_VERSION, 20);
 
     MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
@@ skipping 38 matching lines @@
   Entry child(&trans, GET_BY_ID, child_id);
   ASSERT_TRUE(child.good());
 }
 
 class EntryCreatedInNewFolderTest : public SyncerTest {
  public:
   void CreateFolderInBob() {
     ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
     CHECK(dir.good());
 
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+  WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry bob(&trans,
                      syncable::GET_BY_ID,
                      GetOnlyEntryWithName(&trans,
                                           TestIdFactory::root(),
                                           PSTR("bob")));
     CHECK(bob.good());
 
-    MutableEntry entry2(&trans, syncable::CREATE, bob.Get(syncable::ID),
-                        PSTR("bob"));
-    CHECK(entry2.good());
-    entry2.Put(syncable::IS_DIR, true);
-    entry2.Put(syncable::IS_UNSYNCED, true);
-  }
+  MutableEntry entry2(&trans, syncable::CREATE, bob.Get(syncable::ID),
+                      PSTR("bob"));
+  CHECK(entry2.good());
+  entry2.Put(syncable::IS_DIR, true);
+  entry2.Put(syncable::IS_UNSYNCED, true);
+}
 };
 
 TEST_F(EntryCreatedInNewFolderTest, EntryCreatedInNewFolderMidSync) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry entry(&trans, syncable::CREATE, trans.root_id(),
                        PSTR("bob"));
     ASSERT_TRUE(entry.good());
     entry.Put(syncable::IS_DIR, true);
     entry.Put(syncable::IS_UNSYNCED, true);
   }
 
   mock_server_->SetMidCommitCallback(
       NewCallback<EntryCreatedInNewFolderTest>(this,
           &EntryCreatedInNewFolderTest::CreateFolderInBob));
-  syncer_->SyncShare(BUILD_COMMIT_REQUEST, SYNCER_END);
+  syncer_->SyncShare(BUILD_COMMIT_REQUEST, SYNCER_END, this);
   EXPECT_TRUE(1 == mock_server_->committed_ids().size());
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry parent_entry(&trans, syncable::GET_BY_ID,
         GetOnlyEntryWithName(&trans, TestIdFactory::root(), PSTR("bob")));
     ASSERT_TRUE(parent_entry.good());
 
     Id child_id =
         GetOnlyEntryWithName(&trans, parent_entry.Get(ID), PSTR("bob"));
     Entry child(&trans, syncable::GET_BY_ID, child_id);
     ASSERT_TRUE(child.good());
     EXPECT_EQ(parent_entry.Get(ID), child.Get(PARENT_ID));
-  }
+}
 }
 
 TEST_F(SyncerTest, NegativeIDInUpdate) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateBookmark(-10, 0, "bad", 40, 40);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   // The negative id would make us CHECK!
 }
 
 TEST_F(SyncerTest, UnappliedUpdateOnCreatedItemItemDoesNotCrash) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
 
   int64 metahandle_fred;
   {
     // Create an item.
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry fred_match(&trans, CREATE, trans.root_id(),
                             PSTR("fred_match"));
     ASSERT_TRUE(fred_match.good());
     metahandle_fred = fred_match.Get(META_HANDLE);
     WriteTestDataToEntry(&trans, &fred_match);
   }
   // Commit it.
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   EXPECT_TRUE(1 == mock_server_->committed_ids().size());
   mock_server_->set_conflict_all_commits(true);
   syncable::Id fred_match_id;
   {
     // Now receive a change from outside.
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry fred_match(&trans, GET_BY_HANDLE, metahandle_fred);
     ASSERT_TRUE(fred_match.good());
     EXPECT_TRUE(fred_match.Get(ID).ServerKnows());
     fred_match_id = fred_match.Get(ID);
     mock_server_->AddUpdateBookmark(fred_match_id, trans.root_id(),
         "fred_match", 40, 40);
   }
   // Run the syncer.
   for (int i = 0 ; i < 30 ; ++i) {
-    syncer_->SyncShare();
+  syncer_->SyncShare(this);
   }
 }
 
 /**
  * In the event that we have a double changed entry, that is changed on both
  * the client and the server, the conflict resolver should just drop one of
  * them and accept the other.
  */
+
 TEST_F(SyncerTest, DoublyChangedWithResolver) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   {
     WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry parent(&wtrans, syncable::CREATE, root_id_, PSTR("Folder"));
     ASSERT_TRUE(parent.good());
     parent.Put(syncable::IS_DIR, true);
     parent.Put(syncable::ID, parent_id_);
     parent.Put(syncable::BASE_VERSION, 5);
@@ skipping 32 matching lines @@
   {
     WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry entry(&wtrans, syncable::CREATE, root_id_, PSTR("Pete"));
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.Get(ID).ServerKnows());
     entry.Put(syncable::IS_DIR, true);
     entry.Put(syncable::IS_UNSYNCED, true);
     entry.Put(syncable::MTIME, test_time);
     entry_metahandle = entry.Get(META_HANDLE);
   }
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   syncable::Id id;
   int64 version;
   int64 server_position_in_parent;
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry entry(&trans, syncable::GET_BY_HANDLE, entry_metahandle);
     ASSERT_TRUE(entry.good());
     id = entry.Get(ID);
     EXPECT_TRUE(id.ServerKnows());
     version = entry.Get(BASE_VERSION);
     server_position_in_parent = entry.Get(SERVER_POSITION_IN_PARENT);
   }
   mock_server_->AddUpdateDirectory(id, root_id_, "Pete", version, 10);
   mock_server_->SetLastUpdatePosition(server_position_in_parent);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry entry(&trans, syncable::GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.Get(MTIME) == test_time);
   }
 }
 
 TEST_F(SyncerTest, ParentAndChildBothMatch) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
@@ skipping 14 matching lines @@
     MutableEntry child(&wtrans, CREATE, parent.Get(ID), PSTR("test.htm"));
     ASSERT_TRUE(child.good());
     child.Put(ID, child_id);
     child.Put(BASE_VERSION, 1);
     child.Put(IS_BOOKMARK_OBJECT, true);
     WriteTestDataToEntry(&wtrans, &child);
   }
   mock_server_->AddUpdateDirectory(parent_id, root_id_, "Folder", 10, 10);
   mock_server_->AddUpdateBookmark(child_id, parent_id, "test.htm", 10, 10);
   mock_server_->set_conflict_all_commits(true);
-  syncer_->SyncShare();
-  syncer_->SyncShare();
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
+  syncer_->SyncShare(this);
+  syncer_->SyncShare(this);
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Directory::ChildHandles children;
     dir->GetChildHandles(&trans, root_id_, &children);
     EXPECT_TRUE(1 == children.size());
     dir->GetChildHandles(&trans, parent_id, &children);
     EXPECT_TRUE(1 == children.size());
     Directory::UnappliedUpdateMetaHandles unapplied;
     dir->GetUnappliedUpdateMetaHandles(&trans, &unapplied);
     EXPECT_TRUE(0 == unapplied.size());
     syncable::Directory::UnsyncedMetaHandles unsynced;
     dir->GetUnsyncedMetaHandles(&trans, &unsynced);
     EXPECT_TRUE(0 == unsynced.size());
     syncer_events_.clear();
   }
 }
 
 TEST_F(SyncerTest, CommittingNewDeleted) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry entry(&trans, CREATE, trans.root_id(), PSTR("bob"));
     entry.Put(IS_UNSYNCED, true);
     entry.Put(IS_DEL, true);
   }
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   EXPECT_TRUE(0 == mock_server_->committed_ids().size());
 }
 
 // Original problem synopsis:
 // Check failed: entry->Get(BASE_VERSION) <= entry->Get(SERVER_VERSION)
 // Client creates entry, client finishes committing entry. Between
 // commit and getting update back, we delete the entry.
 // We get the update for the entry, but the local one was modified
 // so we store the entry but don't apply it. IS_UNAPPLIED_UPDATE is set.
 // We commit deletion and get a new version number.
 // We apply unapplied updates again before we get the update about the deletion.
 // This means we have an unapplied update where server_version < base_version.
 TEST_F(SyncerTest, UnappliedUpdateDuringCommit) {
   // This test is a little fake.
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry entry(&trans, CREATE, trans.root_id(), PSTR("bob"));
     entry.Put(ID, ids_.FromNumber(20));
     entry.Put(BASE_VERSION, 1);
     entry.Put(SERVER_VERSION, 1);
     entry.Put(SERVER_PARENT_ID, ids_.FromNumber(9999));  // Bad parent.
     entry.Put(IS_UNSYNCED, true);
     entry.Put(IS_UNAPPLIED_UPDATE, true);
     entry.Put(IS_DEL, false);
   }
-  syncer_->SyncShare(state_.get());
-  syncer_->SyncShare(state_.get());
-  SyncerStatus status(NULL, state_.get());
-  EXPECT_TRUE(0 == status.conflicting_updates());
+  syncer_->SyncShare(session_.get());
+  syncer_->SyncShare(session_.get());
+  const ConflictProgress* progress =
+      session_->status_controller()->conflict_progress();
+  EXPECT_TRUE(0 == progress->ConflictingItemsSize());
   syncer_events_.clear();
 }
 
 // Original problem synopsis:
 //   Illegal parent
 // Unexpected error during sync if we:
 //   make a new folder bob
 //   wait for sync
 //   make a new folder fred
 //   move bob into fred
 //   remove bob
 //   remove fred
 // if no syncing occured midway, bob will have an illegal parent
 TEST_F(SyncerTest, DeletingEntryInFolder) {
   // This test is a little fake.
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
 
   int64 existing_metahandle;
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry entry(&trans, CREATE, trans.root_id(), PSTR("existing"));
     ASSERT_TRUE(entry.good());
     entry.Put(IS_DIR, true);
     entry.Put(IS_UNSYNCED, true);
     existing_metahandle = entry.Get(META_HANDLE);
   }
-  syncer_->SyncShare(state_.get());
+  syncer_->SyncShare(session_.get());
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry newfolder(&trans, CREATE, trans.root_id(), PSTR("new"));
     ASSERT_TRUE(newfolder.good());
     newfolder.Put(IS_DIR, true);
     newfolder.Put(IS_UNSYNCED, true);
 
     MutableEntry existing(&trans, GET_BY_HANDLE, existing_metahandle);
     ASSERT_TRUE(existing.good());
     existing.Put(PARENT_ID, newfolder.Get(ID));
     existing.Put(IS_UNSYNCED, true);
     EXPECT_TRUE(existing.Get(ID).ServerKnows());
 
     newfolder.Put(IS_DEL, true);
     existing.Put(IS_DEL, true);
   }
-  syncer_->SyncShare(state_.get());
-  SyncerStatus status(NULL, state_.get());
-  EXPECT_TRUE(0 == status.conflicting_commits());
+  syncer_->SyncShare(session_.get());
+  StatusController* status(session_->status_controller());
+  EXPECT_TRUE(0 == status->error_counters().num_conflicting_commits);
 }
 
 TEST_F(SyncerTest, DeletingEntryWithLocalEdits) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   int64 newfolder_metahandle;
 
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry newfolder(&trans, CREATE, ids_.FromNumber(1), PSTR("local"));
     ASSERT_TRUE(newfolder.good());
     newfolder.Put(IS_UNSYNCED, true);
     newfolder_metahandle = newfolder.Get(META_HANDLE);
   }
   mock_server_->AddUpdateDirectory(1, 0, "bob", 2, 20);
   mock_server_->SetLastUpdateDeleted();
-  syncer_->SyncShare(SYNCER_BEGIN, APPLY_UPDATES);
+  syncer_->SyncShare(SYNCER_BEGIN, APPLY_UPDATES, this);
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry entry(&trans, syncable::GET_BY_HANDLE, newfolder_metahandle);
     ASSERT_TRUE(entry.good());
   }
 }
 
 TEST_F(SyncerTest, FolderSwapUpdate) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(7801, 0, "bob", 1, 10);
   mock_server_->AddUpdateDirectory(1024, 0, "fred", 1, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   mock_server_->AddUpdateDirectory(1024, 0, "bob", 2, 20);
   mock_server_->AddUpdateDirectory(7801, 0, "fred", 2, 20);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry id1(&trans, GET_BY_ID, ids_.FromNumber(7801));
     ASSERT_TRUE(id1.good());
     EXPECT_TRUE(PSTR("fred") == id1.Get(NON_UNIQUE_NAME));
     EXPECT_TRUE(root_id_ == id1.Get(PARENT_ID));
     Entry id2(&trans, GET_BY_ID, ids_.FromNumber(1024));
     ASSERT_TRUE(id2.good());
     EXPECT_TRUE(PSTR("bob") == id2.Get(NON_UNIQUE_NAME));
     EXPECT_TRUE(root_id_ == id2.Get(PARENT_ID));
   }
   syncer_events_.clear();
 }
 
 TEST_F(SyncerTest, NameCollidingFolderSwapWorksFine) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(7801, 0, "bob", 1, 10);
   mock_server_->AddUpdateDirectory(1024, 0, "fred", 1, 10);
   mock_server_->AddUpdateDirectory(4096, 0, "alice", 1, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry id1(&trans, GET_BY_ID, ids_.FromNumber(7801));
     ASSERT_TRUE(id1.good());
     EXPECT_TRUE(PSTR("bob") == id1.Get(NON_UNIQUE_NAME));
     EXPECT_TRUE(root_id_ == id1.Get(PARENT_ID));
     Entry id2(&trans, GET_BY_ID, ids_.FromNumber(1024));
     ASSERT_TRUE(id2.good());
     EXPECT_TRUE(PSTR("fred") == id2.Get(NON_UNIQUE_NAME));
     EXPECT_TRUE(root_id_ == id2.Get(PARENT_ID));
     Entry id3(&trans, GET_BY_ID, ids_.FromNumber(4096));
     ASSERT_TRUE(id3.good());
     EXPECT_TRUE(PSTR("alice") == id3.Get(NON_UNIQUE_NAME));
     EXPECT_TRUE(root_id_ == id3.Get(PARENT_ID));
   }
   mock_server_->AddUpdateDirectory(1024, 0, "bob", 2, 20);
   mock_server_->AddUpdateDirectory(7801, 0, "fred", 2, 20);
   mock_server_->AddUpdateDirectory(4096, 0, "bob", 2, 20);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry id1(&trans, GET_BY_ID, ids_.FromNumber(7801));
     ASSERT_TRUE(id1.good());
     EXPECT_TRUE(PSTR("fred") == id1.Get(NON_UNIQUE_NAME));
     EXPECT_TRUE(root_id_ == id1.Get(PARENT_ID));
     Entry id2(&trans, GET_BY_ID, ids_.FromNumber(1024));
     ASSERT_TRUE(id2.good());
     EXPECT_TRUE(PSTR("bob") == id2.Get(NON_UNIQUE_NAME));
     EXPECT_TRUE(root_id_ == id2.Get(PARENT_ID));
@@ skipping 14 matching lines @@
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     for (uint32 i = 0; i < items_to_commit; i++) {
       string nameutf8 = StringPrintf("%d", i);
       PathString name(nameutf8.begin(), nameutf8.end());
       MutableEntry e(&trans, CREATE, trans.root_id(), name);
       e.Put(IS_UNSYNCED, true);
       e.Put(IS_DIR, true);
     }
   }
   uint32 num_loops = 0;
-  while (syncer_->SyncShare()) {
+  while (syncer_->SyncShare(this)) {
     num_loops++;
     ASSERT_LT(num_loops, max_batches * 2);
   }
   EXPECT_GE(mock_server_->commit_messages().size(), max_batches);
 }
 
 TEST_F(SyncerTest, HugeConflict) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   int item_count = 300;  // We should be able to do 300 or 3000 w/o issue.
   CHECK(dir.good());
 
   syncable::Id parent_id = ids_.NewServerId();
   syncable::Id last_id = parent_id;
   vector<syncable::Id> tree_ids;
 
   // Create a lot of updates for which the parent does not exist yet.
   // Generate a huge deep tree which should all fail to apply at first.
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
-    for (int i = 0; i < item_count; i++) {
+    for (int i = 0; i < item_count ; i++) {
       syncable::Id next_id = ids_.NewServerId();
       tree_ids.push_back(next_id);
       mock_server_->AddUpdateDirectory(next_id, last_id, "BOB", 2, 20);
       last_id = next_id;
     }
   }
-
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
 
   // Check they're in the expected conflict state.
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     for (int i = 0; i < item_count; i++) {
       Entry e(&trans, GET_BY_ID, tree_ids[i]);
       // They should all exist but none should be applied.
       ASSERT_TRUE(e.good());
       EXPECT_TRUE(e.Get(IS_DEL));
       EXPECT_TRUE(e.Get(IS_UNAPPLIED_UPDATE));
     }
   }
 
   // Add the missing parent directory.
   mock_server_->AddUpdateDirectory(parent_id, TestIdFactory::root(),
       "BOB", 2, 20);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
 
   // Now they should all be OK.
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     for (int i = 0; i < item_count; i++) {
       Entry e(&trans, GET_BY_ID, tree_ids[i]);
       ASSERT_TRUE(e.good());
       EXPECT_FALSE(e.Get(IS_DEL));
       EXPECT_FALSE(e.Get(IS_UNAPPLIED_UPDATE));
     }
   }
 }
 
 TEST_F(SyncerTest, DontCrashOnCaseChange) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry e(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(e.good());
     e.Put(IS_UNSYNCED, true);
   }
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateDirectory(1, 0, "BOB", 2, 20);
-  syncer_->SyncShare();  // USED TO CAUSE AN ASSERT
+  syncer_->SyncShare(this);  // USED TO CAUSE AN ASSERT
   syncer_events_.clear();
 }
 
 TEST_F(SyncerTest, UnsyncedItemAndUpdate) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateDirectory(2, 0, "bob", 2, 20);
-  syncer_->SyncShare();  // USED TO CAUSE AN ASSERT
+  syncer_->SyncShare(this);  // USED TO CAUSE AN ASSERT
   syncer_events_.clear();
 }
 
 TEST_F(SyncerTest, NewEntryAndAlteredServerEntrySharePath) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateBookmark(1, 0, "Foo.htm", 10, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   int64 local_folder_handle;
   syncable::Id local_folder_id;
   {
     WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry new_entry(&wtrans, CREATE, wtrans.root_id(), PSTR("Bar.htm"));
     ASSERT_TRUE(new_entry.good());
     local_folder_id = new_entry.Get(ID);
     local_folder_handle = new_entry.Get(META_HANDLE);
     new_entry.Put(IS_UNSYNCED, true);
     MutableEntry old(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(old.good());
     WriteTestDataToEntry(&wtrans, &old);
   }
   mock_server_->AddUpdateBookmark(1, 0, "Bar.htm", 20, 20);
   mock_server_->set_conflict_all_commits(true);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   syncer_events_.clear();
 }
 
 // Circular links should be resolved by the server.
 TEST_F(SyncerTest, SiblingDirectoriesBecomeCircular) {
   // we don't currently resolve this. This test ensures we don't.
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10);
   mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.Put(IS_UNSYNCED, true);
     ASSERT_TRUE(A.Put(PARENT_ID, ids_.FromNumber(2)));
     ASSERT_TRUE(A.Put(NON_UNIQUE_NAME, PSTR("B")));
   }
   mock_server_->AddUpdateDirectory(2, 1, "A", 20, 20);
   mock_server_->set_conflict_all_commits(true);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   syncer_events_.clear();
   {
     WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     EXPECT_TRUE(A.Get(NON_UNIQUE_NAME) == PSTR("B"));
     EXPECT_TRUE(B.Get(NON_UNIQUE_NAME) == PSTR("B"));
   }
 }
 
 TEST_F(SyncerTest, ConflictSetClassificationError) {
   // This code used to cause a CHECK failure because we incorrectly thought
   // a set was only unapplied updates.
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10);
   mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10);
   mock_server_->set_conflict_all_commits(true);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.Put(IS_UNSYNCED, true);
     A.Put(IS_UNAPPLIED_UPDATE, true);
     A.Put(SERVER_NON_UNIQUE_NAME, PSTR("B"));
     MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     B.Put(IS_UNAPPLIED_UPDATE, true);
     B.Put(SERVER_NON_UNIQUE_NAME, PSTR("A"));
   }
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   syncer_events_.clear();
 }
 
 TEST_F(SyncerTest, SwapEntryNames) {
   // Simple transaction test.
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10);
   mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10);
   mock_server_->set_conflict_all_commits(true);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.Put(IS_UNSYNCED, true);
     MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     B.Put(IS_UNSYNCED, true);
     ASSERT_TRUE(A.Put(NON_UNIQUE_NAME, PSTR("C")));
     ASSERT_TRUE(B.Put(NON_UNIQUE_NAME, PSTR("A")));
     ASSERT_TRUE(A.Put(NON_UNIQUE_NAME, PSTR("B")));
   }
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   syncer_events_.clear();
 }
 
 TEST_F(SyncerTest, DualDeletionWithNewItemNameClash) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10);
   mock_server_->AddUpdateBookmark(2, 0, "B", 10, 10);
   mock_server_->set_conflict_all_commits(true);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry B(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     WriteTestDataToEntry(&trans, &B);
     B.Put(IS_DEL, true);
   }
   mock_server_->AddUpdateBookmark(2, 0, "A", 11, 11);
   mock_server_->SetLastUpdateDeleted();
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry B(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     EXPECT_FALSE(B.Get(IS_UNSYNCED));
     EXPECT_FALSE(B.Get(IS_UNAPPLIED_UPDATE));
   }
   syncer_events_.clear();
 }
 
 TEST_F(SyncerTest, FixDirectoryLoopConflict) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10);
   mock_server_->AddUpdateDirectory(2, 0, "fred", 1, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     bob.Put(IS_UNSYNCED, true);
     bob.Put(PARENT_ID, ids_.FromNumber(2));
   }
   mock_server_->AddUpdateDirectory(2, 1, "fred", 2, 20);
   mock_server_->set_conflict_all_commits(true);
-  syncer_->SyncShare();
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
+  syncer_->SyncShare(this);
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     Entry fred(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(fred.good());
     EXPECT_TRUE(fred.Get(IS_UNSYNCED));
     EXPECT_TRUE(bob.Get(IS_UNSYNCED));
     EXPECT_FALSE(fred.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(bob.Get(IS_UNAPPLIED_UPDATE));
   }
   syncer_events_.clear();
 }
 
 TEST_F(SyncerTest, ResolveWeWroteTheyDeleted) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
 
   int64 bob_metahandle;
 
   mock_server_->AddUpdateBookmark(1, 0, "bob", 1, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     bob_metahandle = bob.Get(META_HANDLE);
     WriteTestDataToEntry(&trans, &bob);
   }
   mock_server_->AddUpdateBookmark(1, 0, "bob", 2, 10);
   mock_server_->SetLastUpdateDeleted();
   mock_server_->set_conflict_all_commits(true);
-  syncer_->SyncShare();
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
+  syncer_->SyncShare(this);
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry bob(&trans, GET_BY_HANDLE, bob_metahandle);
     ASSERT_TRUE(bob.good());
     EXPECT_TRUE(bob.Get(IS_UNSYNCED));
     EXPECT_FALSE(bob.Get(ID).ServerKnows());
     EXPECT_FALSE(bob.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(bob.Get(IS_DEL));
   }
   syncer_events_.clear();
 }
 
 TEST_F(SyncerTest, ServerDeletingFolderWeHaveMovedSomethingInto) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
 
   syncable::Id bob_id = ids_.NewServerId();
   syncable::Id fred_id = ids_.NewServerId();
 
   mock_server_->AddUpdateDirectory(bob_id, TestIdFactory::root(),
       "bob", 1, 10);
   mock_server_->AddUpdateDirectory(fred_id, TestIdFactory::root(),
       "fred", 1, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
     bob.Put(IS_UNSYNCED, true);
     bob.Put(PARENT_ID, fred_id);
   }
   mock_server_->AddUpdateDirectory(fred_id, TestIdFactory::root(),
       "fred", 2, 20);
   mock_server_->SetLastUpdateDeleted();
   mock_server_->set_conflict_all_commits(true);
-  syncer_->SyncShare();
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
+  syncer_->SyncShare(this);
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
 
     Entry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
     EXPECT_TRUE(bob.Get(IS_UNSYNCED));
     EXPECT_FALSE(bob.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(bob.Get(NON_UNIQUE_NAME) == PSTR("bob"));
     EXPECT_NE(bob.Get(PARENT_ID), fred_id);
 
@@ skipping 14 matching lines @@
 
 // TODO(ncarter): This test is bogus, but it actually seems to hit an
 // interesting case the 4th time SyncShare is called.
 // TODO(chron): The fourth time that SyncShare is called it crashes.
 // This seems to be due to a bug in the conflict set building logic.
 TEST_F(SyncerTest, DISABLED_ServerDeletingFolderWeHaveAnOpenEntryIn) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateBookmark(1, 0, "bob", 1, 10);
   mock_server_->AddUpdateDirectory(2, 0, "fred", 1, 10);
-  syncer_->SyncShare(state_.get());
+  syncer_->SyncShare(this);
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     bob.Put(IS_UNSYNCED, true);
     WriteTestDataToEntry(&trans, &bob);
   }
-  syncer_->SyncShare(state_.get());
+  syncer_->SyncShare(this);
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     EXPECT_FALSE(bob.Get(IS_UNSYNCED));
     bob.Put(IS_UNSYNCED, true);
     bob.Put(PARENT_ID, ids_.FromNumber(2));
   }
   mock_server_->AddUpdateDirectory(2, 0, "fred", 2, 20);
   mock_server_->SetLastUpdateDeleted();
   mock_server_->set_conflict_all_commits(true);
   syncer_events_.clear();
   // These SyncShares would cause a CHECK because we'd think we were stuck.
-  syncer_->SyncShare(state_.get());
-  syncer_->SyncShare(state_.get());
-  syncer_->SyncShare(state_.get());
-  syncer_->SyncShare(state_.get());
-  syncer_->SyncShare(state_.get());
-  syncer_->SyncShare(state_.get());
-  syncer_->SyncShare(state_.get());
-  syncer_->SyncShare(state_.get());
+  syncer_->SyncShare(this);
+  syncer_->SyncShare(this);
+  syncer_->SyncShare(this);
+  syncer_->SyncShare(this);
+  syncer_->SyncShare(this);
+  syncer_->SyncShare(this);
+  syncer_->SyncShare(this);
+  syncer_->SyncShare(this);
   EXPECT_TRUE(0 == syncer_events_.size());
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     Id fred_id =
         GetOnlyEntryWithName(&trans, TestIdFactory::root(), PSTR("fred"));
     Entry fred(&trans, GET_BY_ID, fred_id);
     ASSERT_TRUE(fred.good());
     EXPECT_FALSE(fred.Get(IS_UNSYNCED));
     EXPECT_TRUE(fred.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(bob.Get(PARENT_ID) == fred.Get(ID));
     EXPECT_FALSE(bob.Get(IS_UNAPPLIED_UPDATE));
   }
   syncer_events_.clear();
 }
 
 
 TEST_F(SyncerTest, WeMovedSomethingIntoAFolderServerHasDeleted) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
 
   syncable::Id bob_id = ids_.NewServerId();
   syncable::Id fred_id = ids_.NewServerId();
 
   mock_server_->AddUpdateDirectory(bob_id, TestIdFactory::root(),
       "bob", 1, 10);
   mock_server_->AddUpdateDirectory(fred_id, TestIdFactory::root(),
       "fred", 1, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     Entry fred(&trans, GET_BY_ID, fred_id);
     ASSERT_TRUE(fred.good());
 
     MutableEntry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
     bob.Put(IS_UNSYNCED, true);
     bob.Put(PARENT_ID, fred_id);
   }
   mock_server_->AddUpdateDirectory(fred_id, TestIdFactory::root(),
       "fred", 2, 20);
   mock_server_->SetLastUpdateDeleted();
   mock_server_->set_conflict_all_commits(true);
-  syncer_->SyncShare();
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
+  syncer_->SyncShare(this);
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
 
     // Entry was deleted by server. We'll make a new one though with a new ID.
     Entry dead_fred(&trans, GET_BY_ID, fred_id);
     EXPECT_FALSE(dead_fred.good());
 
     // Fred is reborn with a local ID.
@@ skipping 28 matching lines @@
 
  protected:
   int move_bob_count_;
   bool done_;
 
   bool MoveBobIntoID2() {
     ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
     CHECK(dir.good());
 
     if (--move_bob_count_ > 0) {
-      return false;
+    return false;
     }
 
     if (move_bob_count_ == 0) {
-      WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
       Entry alice(&trans, GET_BY_ID,
                   TestIdFactory::FromNumber(fred_id_number));
-      CHECK(alice.good());
-      CHECK(!alice.Get(IS_DEL));
+    CHECK(alice.good());
+    CHECK(!alice.Get(IS_DEL));
       MutableEntry bob(&trans, GET_BY_ID,
                        TestIdFactory::FromNumber(bob_id_number));
-      CHECK(bob.good());
-      bob.Put(IS_UNSYNCED, true);
-      bob.Put(PARENT_ID, alice.Get(ID));
-      return true;
-    }
-    return false;
+    CHECK(bob.good());
+    bob.Put(IS_UNSYNCED, true);
+    bob.Put(PARENT_ID, alice.Get(ID));
+    return true;
   }
+  return false;
+}
 };
 
 TEST_F(FolderMoveDeleteRenameTest,
        WeMovedSomethingIntoAFolderServerHasDeletedAndWeRenamed) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
 
   const syncable::Id bob_id = TestIdFactory::FromNumber(
       FolderMoveDeleteRenameTest::bob_id_number);
   const syncable::Id fred_id = TestIdFactory::FromNumber(
       FolderMoveDeleteRenameTest::fred_id_number);
 
   mock_server_->AddUpdateDirectory(bob_id, TestIdFactory::root(),
       "bob", 1, 10);
   mock_server_->AddUpdateDirectory(fred_id, TestIdFactory::root(),
       "fred", 1, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry fred(&trans, GET_BY_ID, fred_id);
     ASSERT_TRUE(fred.good());
     fred.Put(IS_UNSYNCED, true);
     fred.Put(NON_UNIQUE_NAME, PSTR("Alice"));
   }
   mock_server_->AddUpdateDirectory(fred_id, TestIdFactory::root(),
       "fred", 2, 20);
   mock_server_->SetLastUpdateDeleted();
   mock_server_->set_conflict_all_commits(true);
   // This test is a little brittle. We want to move the item into the folder
   // such that we think we're dealing with a simple conflict, but in reality
   // it's actually a conflict set.
   move_bob_count_ = 2;
   mock_server_->SetMidCommitCallback(
       NewCallback<FolderMoveDeleteRenameTest>(this,
           &FolderMoveDeleteRenameTest::MoveBobIntoID2Runner));
-  syncer_->SyncShare();
-  syncer_->SyncShare();
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
+  syncer_->SyncShare(this);
+  syncer_->SyncShare(this);
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
 
     // Old entry is dead
     Entry dead_fred(&trans, GET_BY_ID, fred_id);
     EXPECT_FALSE(dead_fred.good());
 
     // New ID is created to fill parent folder, named correctly
@@ skipping 17 matching lines @@
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
 
   syncable::Id bob_id = ids_.NewServerId();
   syncable::Id fred_id = ids_.NewServerId();
 
   mock_server_->AddUpdateDirectory(bob_id, TestIdFactory::root(),
       "bob", 1, 10);
   mock_server_->AddUpdateDirectory(fred_id, TestIdFactory::root(),
       "fred", 1, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   syncable::Id new_item_id;
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
     bob.Put(IS_UNSYNCED, true);
     bob.Put(PARENT_ID, fred_id);
     MutableEntry new_item(&trans, CREATE, fred_id, PSTR("new_item"));
     WriteTestDataToEntry(&trans, &new_item);
     new_item_id = new_item.Get(ID);
   }
   mock_server_->AddUpdateDirectory(fred_id, TestIdFactory::root(),
       "fred", 2, 20);
   mock_server_->SetLastUpdateDeleted();
   mock_server_->set_conflict_all_commits(true);
-  syncer_->SyncShare();
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
+  syncer_->SyncShare(this);
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
 
     Entry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
     EXPECT_TRUE(bob.Get(IS_UNSYNCED));
     EXPECT_FALSE(bob.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_NE(bob.Get(PARENT_ID), fred_id);
 
     // Was recreated. Old one shouldn't exist.
@@ skipping 47 matching lines @@
   }
   syncer_events_.clear();
 }
 
 TEST_F(SyncerTest, ServerMovedAFolderIntoAFolderWeHaveDeletedAndMovedIntoIt) {
   // This test combines circular folders and deleted parents.
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10);
   mock_server_->AddUpdateDirectory(2, 0, "fred", 1, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     bob.Put(IS_UNSYNCED, true);
     bob.Put(IS_DEL, true);
     bob.Put(PARENT_ID, ids_.FromNumber(2));
   }
   mock_server_->AddUpdateDirectory(2, 1, "fred", 2, 20);
   mock_server_->set_conflict_all_commits(true);
-  syncer_->SyncShare();
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
+  syncer_->SyncShare(this);
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     Entry fred(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(fred.good());
     EXPECT_TRUE(fred.Get(IS_UNSYNCED));
     EXPECT_TRUE(bob.Get(IS_UNSYNCED));
     EXPECT_TRUE(bob.Get(IS_DEL));
     EXPECT_TRUE(fred.Get(PARENT_ID) == root_id_);
@@ skipping 135 matching lines @@
 
   static const int64 susan_int_id_ = 4;
 
   void DeleteSusanInRoot() {
     ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
     ASSERT_TRUE(dir.good());
 
     const syncable::Id susan_id = TestIdFactory::FromNumber(susan_int_id_);
     ASSERT_GT(countdown_till_delete_, 0);
     if (0 != --countdown_till_delete_)
-      return;
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    return;
+  WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry susan(&trans, GET_BY_ID, susan_id);
-    Directory::ChildHandles children;
-    dir->GetChildHandles(&trans, susan.Get(ID), &children);
-    ASSERT_TRUE(0 == children.size());
-    susan.Put(IS_DEL, true);
-    susan.Put(IS_UNSYNCED, true);
-  }
+  Directory::ChildHandles children;
+  dir->GetChildHandles(&trans, susan.Get(ID), &children);
+  ASSERT_TRUE(0 == children.size());
+  susan.Put(IS_DEL, true);
+  susan.Put(IS_UNSYNCED, true);
+}
 
  protected:
   int countdown_till_delete_;
 };
 
 TEST_F(SusanDeletingTest,
        NewServerItemInAFolderHierarchyWeHaveDeleted3) {
   // Same as 2, except we deleted the folder the set is in between set building
   // and conflict resolution.
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
@@ skipping 20 matching lines @@
     ASSERT_TRUE(joe.good());
     joe.Put(IS_UNSYNCED, true);
     joe.Put(IS_DEL, true);
   }
   mock_server_->AddUpdateDirectory(fred_id, joe_id, "fred", 2, 20);
   mock_server_->set_conflict_all_commits(true);
   countdown_till_delete_ = 2;
   syncer_->pre_conflict_resolution_closure_ =
       NewCallback<SusanDeletingTest>(this,
           &SusanDeletingTest::DeleteSusanInRoot);
-  syncer_->SyncShare();
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
+  syncer_->SyncShare(this);
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
     Entry joe(&trans, GET_BY_ID, joe_id);
     ASSERT_TRUE(joe.good());
     Entry fred(&trans, GET_BY_ID, fred_id);
     ASSERT_TRUE(fred.good());
     Entry susan(&trans, GET_BY_ID, susan_id);
     ASSERT_TRUE(susan.good());
@@ skipping 42 matching lines @@
 
   const syncable::Id bob_id = ids_.NewServerId();
   const syncable::Id fred_id = ids_.NewServerId();
   const syncable::Id alice_id = ids_.NewServerId();
 
   mock_server_->AddUpdateDirectory(bob_id, TestIdFactory::root(),
       "bob", 1, 10);
   mock_server_->AddUpdateDirectory(fred_id, TestIdFactory::root(),
       "fred", 1, 10);
   mock_server_->AddUpdateDirectory(alice_id, fred_id, "alice", 1, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
     bob.Put(IS_UNSYNCED, true);
     bob.Put(PARENT_ID, alice_id);  // Move into alice.
   }
   mock_server_->AddUpdateDirectory(fred_id, TestIdFactory::root(),
       "fred", 2, 20);
   mock_server_->SetLastUpdateDeleted();
   mock_server_->AddUpdateDirectory(alice_id, TestIdFactory::root(),
       "alice", 2, 20);
   mock_server_->SetLastUpdateDeleted();
   mock_server_->set_conflict_all_commits(true);
-  syncer_->SyncShare();
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
+  syncer_->SyncShare(this);
   {
     // Bob is the entry at the bottom of the tree.
     // The tree should be regenerated and old IDs removed.
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
     EXPECT_FALSE(bob.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(bob.Get(IS_UNSYNCED));
 
     // Old one should be deleted, but new one should have been made.
@@ skipping 35 matching lines @@
   const syncable::Id fred_id = ids_.NewServerId();
   const syncable::Id alice_id = ids_.NewServerId();
   const syncable::Id susan_id = ids_.NewServerId();
 
   mock_server_->AddUpdateDirectory(bob_id, TestIdFactory::root(),
       "bob", 1, 10);
   mock_server_->AddUpdateDirectory(susan_id, TestIdFactory::root(),
       "susan", 1, 10);
   mock_server_->AddUpdateDirectory(fred_id, susan_id, "fred", 1, 10);
   mock_server_->AddUpdateDirectory(alice_id, fred_id, "alice", 1, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
     bob.Put(IS_UNSYNCED, true);
     bob.Put(PARENT_ID, alice_id);  // Move into alice.
   }
   mock_server_->AddUpdateDirectory(fred_id, TestIdFactory::root(),
       "fred", 2, 20);
   mock_server_->SetLastUpdateDeleted();
   mock_server_->AddUpdateDirectory(alice_id, TestIdFactory::root(),
       "alice", 2, 20);
   mock_server_->SetLastUpdateDeleted();
   mock_server_->set_conflict_all_commits(true);
-  syncer_->SyncShare();
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
+  syncer_->SyncShare(this);
   {
     // Root
     //   |- Susan
     //        |- Fred
     //            |- Alice
     //                 |- Bob
 
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
@@ skipping 46 matching lines @@
     folder.Put(IS_DIR, true);
     MutableEntry folder2(&trans, CREATE, trans.root_id(), PSTR("fred"));
     ASSERT_TRUE(folder2.good());
     folder2.Put(IS_UNSYNCED, false);
     folder2.Put(IS_DIR, true);
     folder2.Put(BASE_VERSION, 3);
     folder2.Put(ID, syncable::Id::CreateFromServerId("mock_server:10000"));
   }
   mock_server_->set_next_new_id(10000);
   EXPECT_TRUE(1 == dir->unsynced_entity_count());
-  syncer_->SyncShare();  // we get back a bad id in here (should never happen).
+  syncer_->SyncShare(this);  // we get back a bad id in here (should never happen).
   EXPECT_TRUE(1 == dir->unsynced_entity_count());
-  syncer_->SyncShare();  // another bad id in here.
+  syncer_->SyncShare(this);  // another bad id in here.
   EXPECT_TRUE(0 == dir->unsynced_entity_count());
   syncer_events_.clear();
 }
 
 TEST_F(SyncerTest, DeletedEntryWithBadParentInLoopCalculation) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     // This is valid, because the parent could have gone away a long time ago.
     bob.Put(PARENT_ID, ids_.FromNumber(54));
     bob.Put(IS_DEL, true);
     bob.Put(IS_UNSYNCED, true);
   }
   mock_server_->AddUpdateDirectory(2, 1, "fred", 1, 10);
-  syncer_->SyncShare();
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
+  syncer_->SyncShare(this);
 }
 
 TEST_F(SyncerTest, ConflictResolverMergeOverwritesLocalEntry) {
   // This test would die because it would rename a entry to a name that was
   // taken in the namespace
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
 
   ConflictSet conflict_set;
   {
@@ skipping 12 matching lines @@
     MutableEntry update(&trans, CREATE_NEW_UPDATE_ITEM, ids_.FromNumber(3));
     update.Put(BASE_VERSION, 1);
     update.Put(SERVER_NON_UNIQUE_NAME, PSTR("name"));
     update.Put(PARENT_ID, ids_.FromNumber(0));
     update.Put(IS_UNAPPLIED_UPDATE, true);
 
     conflict_set.push_back(ids_.FromNumber(1));
     conflict_set.push_back(ids_.FromNumber(3));
   }
   {
-    SyncCycleState cycle_state;
-    SyncerSession session(&cycle_state, state_.get());
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
-    syncer_->conflict_resolver()->ProcessConflictSet(&trans, &conflict_set, 50,
-                                                     &session);
+    context_->resolver()->ProcessConflictSet(&trans, &conflict_set, 50);
   }
 }
 
 TEST_F(SyncerTest, ConflictResolverMergesLocalDeleteAndServerUpdate) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
 
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
 
     MutableEntry local_deleted(&trans, CREATE, trans.root_id(), PSTR("name"));
     local_deleted.Put(ID, ids_.FromNumber(1));
     local_deleted.Put(BASE_VERSION, 1);
     local_deleted.Put(IS_DEL, true);
     local_deleted.Put(IS_DIR, false);
     local_deleted.Put(IS_UNSYNCED, true);
     local_deleted.Put(IS_BOOKMARK_OBJECT, true);
   }
 
   mock_server_->AddUpdateBookmark(ids_.FromNumber(1), root_id_, "name", 10, 10);
 
   // We don't care about actually committing, just the resolution.
   mock_server_->set_conflict_all_commits(true);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
 
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry local_deleted(&trans, GET_BY_ID, ids_.FromNumber(1));
     EXPECT_TRUE(local_deleted.Get(BASE_VERSION) == 10);
     EXPECT_TRUE(local_deleted.Get(IS_UNAPPLIED_UPDATE) == false);
     EXPECT_TRUE(local_deleted.Get(IS_UNSYNCED) == true);
     EXPECT_TRUE(local_deleted.Get(IS_DEL) == true);
     EXPECT_TRUE(local_deleted.Get(IS_DIR) == false);
   }
@@ skipping 17 matching lines @@
     local_deleted.Put(IS_UNSYNCED, true);
   }
 
   // Server update: entry-type object (not a container), revision 10.
   mock_server_->AddUpdateBookmark(ids_.FromNumber(1), root_id_, "name", 10, 10);
 
   // Don't attempt to commit.
   mock_server_->set_conflict_all_commits(true);
 
   // The syncer should not attempt to apply the invalid update.
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
 
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry local_deleted(&trans, GET_BY_ID, ids_.FromNumber(1));
     EXPECT_TRUE(local_deleted.Get(BASE_VERSION) == 1);
     EXPECT_TRUE(local_deleted.Get(IS_UNAPPLIED_UPDATE) == false);
     EXPECT_TRUE(local_deleted.Get(IS_UNSYNCED) == true);
     EXPECT_TRUE(local_deleted.Get(IS_DEL) == true);
     EXPECT_TRUE(local_deleted.Get(IS_DIR) == true);
   }
 }
 
 TEST(SyncerSyncProcessState, MergeSetsTest) {
   TestIdFactory id_factory;
   syncable::Id id[7];
   for (int i = 1; i < 7; i++) {
     id[i] = id_factory.NewServerId();
   }
-  SyncProcessState c;
+  ConflictProgress c;
   c.MergeSets(id[1], id[2]);
   c.MergeSets(id[2], id[3]);
   c.MergeSets(id[4], id[5]);
   c.MergeSets(id[5], id[6]);
   EXPECT_TRUE(6 == c.IdToConflictSetSize());
   for (int i = 1; i < 7; i++) {
     EXPECT_TRUE(NULL != c.IdToConflictSetGet(id[i]));
     EXPECT_TRUE(c.IdToConflictSetGet(id[(i & ~3) + 1]) ==
                 c.IdToConflictSetGet(id[i]));
   }
   c.MergeSets(id[1], id[6]);
   for (int i = 1; i < 7; i++) {
     EXPECT_TRUE(NULL != c.IdToConflictSetGet(id[i]));
     EXPECT_TRUE(c.IdToConflictSetGet(id[1]) == c.IdToConflictSetGet(id[i]));
   }
 
   // Check dupes don't cause double sets.
-  SyncProcessState identical_set;
+  ConflictProgress identical_set;
   identical_set.MergeSets(id[1], id[1]);
   EXPECT_TRUE(identical_set.IdToConflictSetSize() == 1);
   EXPECT_TRUE(identical_set.IdToConflictSetGet(id[1])->size() == 1);
 }
 
 // Bug Synopsis:
 // Merge conflict resolution will merge a new local entry with another entry
 // that needs updates, resulting in CHECK.
 TEST_F(SyncerTest, MergingExistingItems) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateBookmark(1, 0, "base", 10, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry entry(&trans, CREATE, trans.root_id(), PSTR("Copy of base"));
     WriteTestDataToEntry(&trans, &entry);
   }
   mock_server_->AddUpdateBookmark(1, 0, "Copy of base", 50, 50);
-  SyncRepeatedlyToTriggerConflictResolution(state_.get());
+  SyncRepeatedlyToTriggerConflictResolution(session_.get());
 }
 
 // In this test a long changelog contains a child at the start of the changelog
 // and a parent at the end. While these updates are in progress the client would
 // appear stuck.
 TEST_F(SyncerTest, LongChangelistWithApplicationConflict) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   const int DEPTH = 400;
   syncable::Id folder_id = ids_.FromNumber(1);
 
   // First we an item in a folder in the root. However the folder won't come
   // till much later.
   syncable::Id stuck_entry_id = TestIdFactory::FromNumber(99999);
   mock_server_->AddUpdateDirectory(stuck_entry_id,
       folder_id, "stuck", 1, 1);
   mock_server_->SetChangesRemaining(DEPTH - 1);
-  syncer_->SyncShare(state_.get());
+  syncer_->SyncShare(session_.get());
 
   // Very long changelist. We should never be stuck.
   for (int i = 0; i < DEPTH; i++) {
     mock_server_->SetNewTimestamp(i);
     mock_server_->SetChangesRemaining(DEPTH - i);
-    syncer_->SyncShare(state_.get());
-    EXPECT_FALSE(SyncerStuck(state_.get()));
+    syncer_->SyncShare(session_.get());
+    EXPECT_FALSE(session_->status_controller()->syncer_status().syncer_stuck);
 
     // Ensure our folder hasn't somehow applied.
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry child(&trans, GET_BY_ID, stuck_entry_id);
     EXPECT_TRUE(child.good());
     EXPECT_TRUE(child.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(child.Get(IS_DEL));
     EXPECT_FALSE(child.Get(IS_UNSYNCED));
   }
 
@@ skipping 14 matching lines @@
     EXPECT_TRUE(child.good());
   }
 }
 
 TEST_F(SyncerTest, DontMergeTwoExistingItems) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   EXPECT_TRUE(dir.good());
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateBookmark(1, 0, "base", 10, 10);
   mock_server_->AddUpdateBookmark(2, 0, "base2", 10, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.Put(NON_UNIQUE_NAME, PSTR("Copy of base")));
     entry.Put(IS_UNSYNCED, true);
   }
   mock_server_->AddUpdateBookmark(1, 0, "Copy of base", 50, 50);
-  SyncRepeatedlyToTriggerConflictResolution(state_.get());
+  SyncRepeatedlyToTriggerConflictResolution(session_.get());
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry entry1(&trans, GET_BY_ID, ids_.FromNumber(1));
     EXPECT_FALSE(entry1.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(entry1.Get(IS_UNSYNCED));
     EXPECT_FALSE(entry1.Get(IS_DEL));
     Entry entry2(&trans, GET_BY_ID, ids_.FromNumber(2));
     EXPECT_FALSE(entry2.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(entry2.Get(IS_UNSYNCED));
     EXPECT_FALSE(entry2.Get(IS_DEL));
     EXPECT_EQ(entry1.Get(NON_UNIQUE_NAME), entry2.Get(NON_UNIQUE_NAME));
   }
 }
 
 TEST_F(SyncerTest, TestUndeleteUpdate) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   EXPECT_TRUE(dir.good());
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateDirectory(1, 0, "foo", 1, 1);
   mock_server_->AddUpdateDirectory(2, 1, "bar", 1, 2);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   mock_server_->AddUpdateDirectory(2, 1, "bar", 2, 3);
   mock_server_->SetLastUpdateDeleted();
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.Get(IS_DEL));
   }
   mock_server_->AddUpdateDirectory(1, 0, "foo", 2, 4);
   mock_server_->SetLastUpdateDeleted();
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   // This used to be rejected as it's an undeletion. Now, it results in moving
   // the delete path aside.
   mock_server_->AddUpdateDirectory(2, 1, "bar", 3, 5);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.Get(IS_DEL));
     EXPECT_FALSE(entry.Get(SERVER_IS_DEL));
     EXPECT_TRUE(entry.Get(IS_UNAPPLIED_UPDATE));
   }
 }
 
 TEST_F(SyncerTest, TestMoveSanitizedNamedFolder) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   EXPECT_TRUE(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "foo", 1, 1);
   mock_server_->AddUpdateDirectory(2, 0, ":::", 1, 2);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.Put(PARENT_ID, ids_.FromNumber(1)));
     EXPECT_TRUE(entry.Put(IS_UNSYNCED, true));
   }
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   // We use the same sync ts as before so our times match up.
   mock_server_->AddUpdateDirectory(2, 1, ":::", 2, 2);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
 }
 
 TEST(SortedCollectionsIntersect, SortedCollectionsIntersectTest) {
   int negative[] = {-3, -2, -1};
   int straddle[] = {-1, 0, 1};
   int positive[] = {1, 2, 3};
   EXPECT_TRUE(SortedCollectionsIntersect(negative, negative + 3,
                                          straddle, straddle + 3));
   EXPECT_FALSE(SortedCollectionsIntersect(negative, negative + 3,
                                           positive, positive + 3));
   EXPECT_TRUE(SortedCollectionsIntersect(straddle, straddle + 3,
                                          positive, positive + 3));
   EXPECT_FALSE(SortedCollectionsIntersect(straddle + 2, straddle + 3,
                                           positive, positive));
   EXPECT_FALSE(SortedCollectionsIntersect(straddle, straddle + 3,
                                           positive + 1, positive + 1));
   EXPECT_TRUE(SortedCollectionsIntersect(straddle, straddle + 3,
                                          positive, positive + 1));
 }
 
 // Don't crash when this occurs.
 TEST_F(SyncerTest, UpdateWhereParentIsNotAFolder) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateBookmark(1, 0, "B", 10, 10);
   mock_server_->AddUpdateDirectory(2, 1, "BookmarkParent", 10, 10);
   // Used to cause a CHECK
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     ReadTransaction rtrans(dir, __FILE__, __LINE__);
     Entry good_entry(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(good_entry.good());
     EXPECT_FALSE(good_entry.Get(IS_UNAPPLIED_UPDATE));
     Entry bad_parent(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(bad_parent.good());
     EXPECT_TRUE(bad_parent.Get(IS_UNAPPLIED_UPDATE));
   }
 }
 
 const char kRootId[] = "0";
 
 TEST_F(SyncerTest, DirectoryUpdateTest) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
 
   Id in_root_id = ids_.NewServerId();
   Id in_in_root_id = ids_.NewServerId();
 
   mock_server_->AddUpdateDirectory(in_root_id, TestIdFactory::root(),
                                    "in_root_name", 2, 2);
   mock_server_->AddUpdateDirectory(in_in_root_id, in_root_id,
                                    "in_in_root_name", 3, 3);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry in_root(&trans, GET_BY_ID, in_root_id);
     ASSERT_TRUE(in_root.good());
     EXPECT_EQ(PSTR("in_root_name"), in_root.Get(NON_UNIQUE_NAME));
     EXPECT_EQ(TestIdFactory::root(), in_root.Get(PARENT_ID));
 
     Entry in_in_root(&trans, GET_BY_ID, in_in_root_id);
     ASSERT_TRUE(in_in_root.good());
     EXPECT_EQ(PSTR("in_in_root_name"), in_in_root.Get(NON_UNIQUE_NAME));
@@ skipping 18 matching lines @@
     in_root_id = parent.Get(syncable::ID);
     foo_metahandle = parent.Get(META_HANDLE);
 
     MutableEntry child(&wtrans, syncable::CREATE, parent.Get(ID), PSTR("bar"));
     ASSERT_TRUE(child.good());
     child.Put(syncable::IS_UNSYNCED, true);
     child.Put(syncable::IS_DIR, true);
     bar_metahandle = child.Get(META_HANDLE);
     in_dir_id = parent.Get(syncable::ID);
   }
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry fail_by_old_id_entry(&trans, GET_BY_ID, in_root_id);
     ASSERT_FALSE(fail_by_old_id_entry.good());
 
     Entry foo_entry(&trans, GET_BY_HANDLE, foo_metahandle);
     ASSERT_TRUE(foo_entry.good());
     EXPECT_EQ(PSTR("foo"), foo_entry.Get(NON_UNIQUE_NAME));
     EXPECT_NE(foo_entry.Get(syncable::ID), in_root_id);
 
     Entry bar_entry(&trans, GET_BY_HANDLE, bar_metahandle);
     ASSERT_TRUE(bar_entry.good());
     EXPECT_EQ(PSTR("bar"), bar_entry.Get(NON_UNIQUE_NAME));
     EXPECT_NE(bar_entry.Get(syncable::ID), in_dir_id);
     EXPECT_EQ(foo_entry.Get(syncable::ID), bar_entry.Get(PARENT_ID));
   }
 }
 
 TEST_F(SyncerTest, ConflictSetSizeReducedToOne) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
 
   syncable::Id in_root_id = ids_.NewServerId();
 
   mock_server_->AddUpdateBookmark(in_root_id, TestIdFactory::root(),
       "in_root", 1, 1);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry oentry(&trans, GET_BY_ID, in_root_id);
     ASSERT_TRUE(oentry.good());
     oentry.Put(NON_UNIQUE_NAME, PSTR("old_in_root"));
     WriteTestDataToEntry(&trans, &oentry);
     MutableEntry entry(&trans, CREATE, trans.root_id(), PSTR("in_root"));
     ASSERT_TRUE(entry.good());
     WriteTestDataToEntry(&trans, &entry);
   }
   mock_server_->set_conflict_all_commits(true);
   // This SyncShare call used to result in a CHECK failure.
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   syncer_events_.clear();
 }
 
 TEST_F(SyncerTest, TestClientCommand) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   using sync_pb::ClientCommand;
 
   ClientCommand* command = mock_server_->GetNextClientCommand();
   command->set_set_sync_poll_interval(8);
   command->set_set_sync_long_poll_interval(800);
   mock_server_->AddUpdateDirectory(1, 0, "in_root", 1, 1);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
 
-  EXPECT_TRUE(last_client_command_.has_set_sync_poll_interval());
-  EXPECT_TRUE(last_client_command_.has_set_sync_long_poll_interval());
-  EXPECT_TRUE(8 == last_client_command_.set_sync_poll_interval());
-  EXPECT_TRUE(800 == last_client_command_.set_sync_long_poll_interval());
+  EXPECT_TRUE(TimeDelta::FromSeconds(8) ==
+              last_short_poll_interval_received_);
+  EXPECT_TRUE(TimeDelta::FromSeconds(800) ==
+              last_long_poll_interval_received_);
 
   command = mock_server_->GetNextClientCommand();
   command->set_set_sync_poll_interval(180);
   command->set_set_sync_long_poll_interval(190);
   mock_server_->AddUpdateDirectory(1, 0, "in_root", 1, 1);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
 
-  EXPECT_TRUE(last_client_command_.has_set_sync_poll_interval());
-  EXPECT_TRUE(last_client_command_.has_set_sync_long_poll_interval());
-  EXPECT_TRUE(180 == last_client_command_.set_sync_poll_interval());
-  EXPECT_TRUE(190 == last_client_command_.set_sync_long_poll_interval());
+  EXPECT_TRUE(TimeDelta::FromSeconds(180) ==
+              last_short_poll_interval_received_);
+  EXPECT_TRUE(TimeDelta::FromSeconds(190) ==
+              last_long_poll_interval_received_);
 }
 
 TEST_F(SyncerTest, EnsureWeSendUpOldParent) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
 
   syncable::Id folder_one_id = ids_.FromNumber(1);
   syncable::Id folder_two_id = ids_.FromNumber(2);
 
   mock_server_->AddUpdateDirectory(folder_one_id, TestIdFactory::root(),
       "folder_one", 1, 1);
   mock_server_->AddUpdateDirectory(folder_two_id, TestIdFactory::root(),
       "folder_two", 1, 1);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   {
     // A moved entry should send an old parent.
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry entry(&trans, GET_BY_ID, folder_one_id);
     ASSERT_TRUE(entry.good());
     entry.Put(PARENT_ID, folder_two_id);
     entry.Put(IS_UNSYNCED, true);
     // A new entry should send no parent.
     MutableEntry create(&trans, CREATE, trans.root_id(), PSTR("new_folder"));
     create.Put(IS_UNSYNCED, true);
   }
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   const sync_pb::CommitMessage& commit = mock_server_->last_sent_commit();
   ASSERT_TRUE(2 == commit.entries_size());
   EXPECT_TRUE(commit.entries(0).parent_id_string() == "2");
   EXPECT_TRUE(commit.entries(0).old_parent_id() == "0");
   EXPECT_FALSE(commit.entries(1).has_old_parent_id());
 }
 
 TEST_F(SyncerTest, Test64BitVersionSupport) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
@@ skipping 18 matching lines @@
   EXPECT_TRUE(really_big_int == entry.Get(syncable::BASE_VERSION));
 }
 
 TEST_F(SyncerTest, TestSimpleUndelete) {
   Id id = ids_.MakeServer("undeletion item"), root = TestIdFactory::root();
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   EXPECT_TRUE(dir.good());
   mock_server_->set_conflict_all_commits(true);
   // Let there be an entry from the server.
   mock_server_->AddUpdateBookmark(id, root, "foo", 1, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   // Check it out and delete it.
   {
     WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry entry(&wtrans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(entry.Get(IS_UNSYNCED));
     EXPECT_FALSE(entry.Get(IS_DEL));
     // Delete it locally.
     entry.Put(IS_DEL, true);
   }
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   // Confirm we see IS_DEL and not SERVER_IS_DEL.
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry entry(&trans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(entry.Get(IS_UNSYNCED));
     EXPECT_TRUE(entry.Get(IS_DEL));
     EXPECT_FALSE(entry.Get(SERVER_IS_DEL));
   }
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   // Update from server confirming deletion.
   mock_server_->AddUpdateBookmark(id, root, "foo", 2, 11);
   mock_server_->SetLastUpdateDeleted();
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   // IS_DEL AND SERVER_IS_DEL now both true.
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry entry(&trans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(entry.Get(IS_UNSYNCED));
     EXPECT_TRUE(entry.Get(IS_DEL));
     EXPECT_TRUE(entry.Get(SERVER_IS_DEL));
   }
   // Undelete from server.
   mock_server_->AddUpdateBookmark(id, root, "foo", 2, 12);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   // IS_DEL and SERVER_IS_DEL now both false.
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry entry(&trans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(entry.Get(IS_UNSYNCED));
     EXPECT_FALSE(entry.Get(IS_DEL));
     EXPECT_FALSE(entry.Get(SERVER_IS_DEL));
   }
 }
 
 TEST_F(SyncerTest, TestUndeleteWithMissingDeleteUpdate) {
   Id id = ids_.MakeServer("undeletion item"), root = TestIdFactory::root();
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   EXPECT_TRUE(dir.good());
   // Let there be a entry, from the server.
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateBookmark(id, root, "foo", 1, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   // Check it out and delete it.
   {
     WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry entry(&wtrans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(entry.Get(IS_UNSYNCED));
     EXPECT_FALSE(entry.Get(IS_DEL));
     // Delete it locally.
     entry.Put(IS_DEL, true);
   }
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   // Confirm we see IS_DEL and not SERVER_IS_DEL.
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry entry(&trans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(entry.Get(IS_UNSYNCED));
     EXPECT_TRUE(entry.Get(IS_DEL));
     EXPECT_FALSE(entry.Get(SERVER_IS_DEL));
   }
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   // Say we do not get an update from server confirming deletion. Undelete
   // from server
   mock_server_->AddUpdateBookmark(id, root, "foo", 2, 12);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   // IS_DEL and SERVER_IS_DEL now both false.
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry entry(&trans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(entry.Get(IS_UNSYNCED));
     EXPECT_FALSE(entry.Get(IS_DEL));
     EXPECT_FALSE(entry.Get(SERVER_IS_DEL));
   }
 }
 
 TEST_F(SyncerTest, TestUndeleteIgnoreCorrectlyUnappliedUpdate) {
   Id id1 = ids_.MakeServer("first"), id2 = ids_.MakeServer("second");
   Id root = TestIdFactory::root();
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   EXPECT_TRUE(dir.good());
   // Duplicate! expect path clashing!
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateBookmark(id1, root, "foo", 1, 10);
   mock_server_->AddUpdateBookmark(id2, root, "foo", 1, 10);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   mock_server_->AddUpdateBookmark(id2, root, "foo2", 1, 10);
-  syncer_->SyncShare();  // Now just don't explode.
-}
-
-TEST_F(SyncerTest, CopySyncProcessState) {
-  scoped_ptr<SyncProcessState> b;
-  {
-    SyncProcessState a;
-    a.MergeSets(ids_.FromNumber(1), ids_.FromNumber(2));
-    a.MergeSets(ids_.FromNumber(2), ids_.FromNumber(3));
-    a.MergeSets(ids_.FromNumber(4), ids_.FromNumber(5));
-    EXPECT_TRUE(a.ConflictSetsSize() == 2);
-    {
-      SyncProcessState b = a;
-      b = b;
-      EXPECT_TRUE(b.ConflictSetsSize() == 2);
-    }
-    EXPECT_TRUE(a.ConflictSetsSize() == 2);
-    a.MergeSets(ids_.FromNumber(3), ids_.FromNumber(4));
-    EXPECT_TRUE(a.ConflictSetsSize() == 1);
-    b.reset(new SyncProcessState(a));
-  }
-  EXPECT_TRUE(b->ConflictSetsSize() == 1);
+  syncer_->SyncShare(this);  // Now just don't explode.
 }
 
 TEST_F(SyncerTest, SingletonTagUpdates) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   EXPECT_TRUE(dir.good());
   // As a hurdle, introduce an item whose name is the same as the tag value
   // we'll use later.
   int64 hurdle_handle = CreateUnsyncedDirectory(PSTR("bob"), "id_bob");
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
     Entry hurdle(&trans, GET_BY_HANDLE, hurdle_handle);
     ASSERT_TRUE(hurdle.good());
     ASSERT_TRUE(!hurdle.Get(IS_DEL));
     ASSERT_TRUE(hurdle.Get(SINGLETON_TAG).empty());
     ASSERT_TRUE(hurdle.Get(NON_UNIQUE_NAME) == PSTR("bob"));
 
     // Try to lookup by the tagname.  These should fail.
     Entry tag_alpha(&trans, GET_BY_TAG, PSTR("alpha"));
     EXPECT_FALSE(tag_alpha.good());
     Entry tag_bob(&trans, GET_BY_TAG, PSTR("bob"));
     EXPECT_FALSE(tag_bob.good());
   }
 
   // Now download some tagged items as updates.
   mock_server_->AddUpdateDirectory(1, 0, "update1", 1, 10);
   mock_server_->SetLastUpdateSingletonTag("alpha");
   mock_server_->AddUpdateDirectory(2, 0, "update2", 2, 20);
   mock_server_->SetLastUpdateSingletonTag("bob");
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
 
   {
     ReadTransaction trans(dir, __FILE__, __LINE__);
 
     // The new items should be applied as new entries, and we should be able
     // to look them up by their tag values.
     Entry tag_alpha(&trans, GET_BY_TAG, PSTR("alpha"));
     ASSERT_TRUE(tag_alpha.good());
     ASSERT_TRUE(!tag_alpha.Get(IS_DEL));
     ASSERT_TRUE(tag_alpha.Get(SINGLETON_TAG) == PSTR("alpha"));
@@ skipping 63 matching lines @@
 
 TEST_F(SyncerPositionUpdateTest, InOrderPositive) {
   // Add a bunch of items in increasing order, starting with just positive
   // position values.
   AddRootItemWithPosition(100);
   AddRootItemWithPosition(199);
   AddRootItemWithPosition(200);
   AddRootItemWithPosition(201);
   AddRootItemWithPosition(400);
 
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   ExpectLocalItemsInServerOrder();
 }
 
 TEST_F(SyncerPositionUpdateTest, InOrderNegative) {
   // Test negative position values, but in increasing order.
   AddRootItemWithPosition(-400);
   AddRootItemWithPosition(-201);
   AddRootItemWithPosition(-200);
   AddRootItemWithPosition(-150);
   AddRootItemWithPosition(100);
 
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   ExpectLocalItemsInServerOrder();
 }
 
 TEST_F(SyncerPositionUpdateTest, ReverseOrder) {
   // Test when items are sent in the reverse order.
   AddRootItemWithPosition(400);
   AddRootItemWithPosition(201);
   AddRootItemWithPosition(200);
   AddRootItemWithPosition(100);
   AddRootItemWithPosition(-150);
   AddRootItemWithPosition(-201);
   AddRootItemWithPosition(-200);
   AddRootItemWithPosition(-400);
 
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   ExpectLocalItemsInServerOrder();
 }
 
 TEST_F(SyncerPositionUpdateTest, RandomOrderInBatches) {
   // Mix it all up, interleaving position values, and try multiple batches of
   // updates.
   AddRootItemWithPosition(400);
   AddRootItemWithPosition(201);
   AddRootItemWithPosition(-400);
   AddRootItemWithPosition(100);
 
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   ExpectLocalItemsInServerOrder();
 
   AddRootItemWithPosition(-150);
   AddRootItemWithPosition(-200);
   AddRootItemWithPosition(200);
   AddRootItemWithPosition(-201);
 
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   ExpectLocalItemsInServerOrder();
 
   AddRootItemWithPosition(-144);
 
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   ExpectLocalItemsInServerOrder();
 }
 
 class SyncerPositionTiebreakingTest : public SyncerTest {
  public:
   SyncerPositionTiebreakingTest()
       : low_id_(Id::CreateFromServerId("A")),
         mid_id_(Id::CreateFromServerId("M")),
         high_id_(Id::CreateFromServerId("Z")),
         next_revision_(1) {
@@ skipping 41 matching lines @@
 
  private:
   int next_revision_;
   DISALLOW_COPY_AND_ASSIGN(SyncerPositionTiebreakingTest);
 };
 
 TEST_F(SyncerPositionTiebreakingTest, LowMidHigh) {
   Add(low_id_);
   Add(mid_id_);
   Add(high_id_);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   ExpectLocalOrderIsByServerId();
 }
 
 TEST_F(SyncerPositionTiebreakingTest, LowHighMid) {
   Add(low_id_);
   Add(high_id_);
   Add(mid_id_);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   ExpectLocalOrderIsByServerId();
 }
 
 TEST_F(SyncerPositionTiebreakingTest, HighMidLow) {
   Add(high_id_);
   Add(mid_id_);
   Add(low_id_);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   ExpectLocalOrderIsByServerId();
 }
 
 TEST_F(SyncerPositionTiebreakingTest, HighLowMid) {
   Add(high_id_);
   Add(low_id_);
   Add(mid_id_);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   ExpectLocalOrderIsByServerId();
 }
 
 TEST_F(SyncerPositionTiebreakingTest, MidHighLow) {
   Add(mid_id_);
   Add(high_id_);
   Add(low_id_);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   ExpectLocalOrderIsByServerId();
 }
 
 TEST_F(SyncerPositionTiebreakingTest, MidLowHigh) {
   Add(mid_id_);
   Add(low_id_);
   Add(high_id_);
-  syncer_->SyncShare();
+  syncer_->SyncShare(this);
   ExpectLocalOrderIsByServerId();
 }
 
 const SyncerTest::CommitOrderingTest
 SyncerTest::CommitOrderingTest::LAST_COMMIT_ITEM = {-1, TestIdFactory::root()};
 
 }  // namespace browser_sync