Revert of Sync commit errors should temporarily re-enable trigger pre-commit getupdates

sync/engine/syncer.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "sync/engine/syncer.h"
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/time/time.h"
@@ skipping 37 matching lines @@
     : cancelation_signal_(cancelation_signal) {
 }
 
 Syncer::~Syncer() {}
 
 bool Syncer::ExitRequested() {
   return cancelation_signal_->IsSignalled();
 }
 
 bool Syncer::NormalSyncShare(ModelTypeSet request_types,
-                             NudgeTracker* nudge_tracker,
+                             const NudgeTracker& nudge_tracker,
                              SyncSession* session) {
   HandleCycleBegin(session);
-  if (nudge_tracker->IsGetUpdatesRequired() ||
+  if (nudge_tracker.IsGetUpdatesRequired() ||
       session->context()->ShouldFetchUpdatesBeforeCommit()) {
     VLOG(1) << "Downloading types " << ModelTypeSetToString(request_types);
-    NormalGetUpdatesDelegate normal_delegate(*nudge_tracker);
+    NormalGetUpdatesDelegate normal_delegate(nudge_tracker);
     GetUpdatesProcessor get_updates_processor(
         session->context()->model_type_registry()->update_handler_map(),
         normal_delegate);
     if (!DownloadAndApplyUpdates(
             request_types,
             session,
             &get_updates_processor,
             kCreateMobileBookmarksFolder)) {
-      return HandleCycleEnd(session, nudge_tracker->GetLegacySource());
+      return HandleCycleEnd(session, nudge_tracker.GetLegacySource());
     }
   }
 
   VLOG(1) << "Committing from types " << ModelTypeSetToString(request_types);
   CommitProcessor commit_processor(
       session->context()->model_type_registry()->commit_contributor_map());
-  SyncerError commit_result = BuildAndPostCommits(request_types, nudge_tracker,
-                                                  session, &commit_processor);
+  SyncerError commit_result =
+      BuildAndPostCommits(request_types, session, &commit_processor);
   session->mutable_status_controller()->set_commit_result(commit_result);
 
-  return HandleCycleEnd(session, nudge_tracker->GetLegacySource());
+  return HandleCycleEnd(session, nudge_tracker.GetLegacySource());
 }
 
 bool Syncer::ConfigureSyncShare(
     ModelTypeSet request_types,
     sync_pb::GetUpdatesCallerInfo::GetUpdatesSource source,
     SyncSession* session) {
   VLOG(1) << "Configuring types " << ModelTypeSetToString(request_types);
   HandleCycleBegin(session);
   ConfigureGetUpdatesDelegate configure_delegate(source);
   GetUpdatesProcessor get_updates_processor(
@@ skipping 58 matching lines @@
         session->status_controller().num_hierarchy_conflicts() > 0);
     session->SendEventNotification(SyncCycleEvent::STATUS_CHANGED);
   }
 
   if (ExitRequested())
     return false;
   return true;
 }
 
 SyncerError Syncer::BuildAndPostCommits(ModelTypeSet requested_types,
-                                        sessions::NudgeTracker* nudge_tracker,
                                         sessions::SyncSession* session,
                                         CommitProcessor* commit_processor) {
   // The ExitRequested() check is unnecessary, since we should start getting
   // errors from the ServerConnectionManager if an exist has been requested.
   // However, it doesn't hurt to check it anyway.
   while (!ExitRequested()) {
     scoped_ptr<Commit> commit(
         Commit::Init(
             requested_types,
             session->context()->GetEnabledTypes(),
             session->context()->max_commit_batch_size(),
             session->context()->account_name(),
             session->context()->directory()->cache_guid(),
             commit_processor,
             session->context()->extensions_activity()));
     if (!commit) {
       break;
     }
 
     SyncerError error = commit->PostAndProcessResponse(
-        nudge_tracker, session, session->mutable_status_controller(),
+        session,
+        session->mutable_status_controller(),
         session->context()->extensions_activity());
     commit->CleanUp();
     if (error != SYNCER_OK) {
       return error;
     }
   }
 
   return SYNCER_OK;
 }
 
 void Syncer::HandleCycleBegin(SyncSession* session) {
   session->mutable_status_controller()->UpdateStartTime();
   session->SendEventNotification(SyncCycleEvent::SYNC_CYCLE_BEGIN);
 }
 
 bool Syncer::HandleCycleEnd(
     SyncSession* session,
     sync_pb::GetUpdatesCallerInfo::GetUpdatesSource source) {
   if (!ExitRequested()) {
     session->SendSyncCycleEndEventNotification(source);
     return true;
   } else {
     return false;
   }
 }
 
 }  // namespace syncer