sync: Merge apply updates and resolve conflicts

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/debug/trace_event.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "build/build_config.h"
 #include "sync/engine/apply_control_data_updates.h"
-#include "sync/engine/apply_updates_command.h"
+#include "sync/engine/apply_updates_and_resolve_conflicts_command.h"
 #include "sync/engine/build_commit_command.h"
 #include "sync/engine/commit.h"
 #include "sync/engine/conflict_resolver.h"
 #include "sync/engine/download_updates_command.h"
 #include "sync/engine/net/server_connection_manager.h"
 #include "sync/engine/process_commit_response_command.h"
 #include "sync/engine/process_updates_command.h"
-#include "sync/engine/resolve_conflicts_command.h"
 #include "sync/engine/store_timestamps_command.h"
 #include "sync/engine/syncer_types.h"
 #include "sync/engine/throttled_data_type_tracker.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/syncable-inl.h"
 
 // TODO(vishwath): Remove this include after node positions have
 // shifted to completely using Ordinals.
 // See http://crbug.com/145412 .
 #include "sync/internal_api/public/base/node_ordinal.h"
@@ skipping 21 matching lines @@
 #define ENUM_CASE(x) case x: return #x
 const char* SyncerStepToString(const SyncerStep step)
 {
   switch (step) {
     ENUM_CASE(SYNCER_BEGIN);
     ENUM_CASE(DOWNLOAD_UPDATES);
     ENUM_CASE(PROCESS_UPDATES);
     ENUM_CASE(STORE_TIMESTAMPS);
     ENUM_CASE(APPLY_UPDATES);
     ENUM_CASE(COMMIT);
-    ENUM_CASE(RESOLVE_CONFLICTS);
-    ENUM_CASE(APPLY_UPDATES_TO_RESOLVE_CONFLICTS);
     ENUM_CASE(SYNCER_END);
   }
   NOTREACHED();
   return "";
 }
 #undef ENUM_CASE
 
 Syncer::Syncer()
     : early_exit_requested_(false) {
 }
@@ skipping 69 matching lines @@
           next_step = DOWNLOAD_UPDATES;
         } else {
           next_step = APPLY_UPDATES;
         }
         break;
       }
       case APPLY_UPDATES: {
         // These include encryption updates that should be applied early.
         ApplyControlDataUpdates(session->context()->directory());
 
-        ApplyUpdatesCommand apply_updates;
+        ApplyUpdatesAndResolveConflictsCommand apply_updates;
         apply_updates.Execute(session);
 
         session->context()->set_hierarchy_conflict_detected(
             session->status_controller().num_hierarchy_conflicts() > 0);
 
         session->SendEventNotification(SyncEngineEvent::STATUS_CHANGED);
         if (last_step == APPLY_UPDATES) {
           // We're in configuration mode, but we still need to run the
           // SYNCER_END step.
           last_step = SYNCER_END;
           next_step = SYNCER_END;
         } else {
           next_step = COMMIT;
         }
         break;
       }
       case COMMIT: {
         session->mutable_status_controller()->set_commit_result(
             BuildAndPostCommits(this, session));
-        next_step = RESOLVE_CONFLICTS;
-        break;
-      }
-      case RESOLVE_CONFLICTS: {
-        StatusController* status = session->mutable_status_controller();
-        status->reset_conflicts_resolved();
-        ResolveConflictsCommand resolve_conflicts_command;
-        resolve_conflicts_command.Execute(session);
-
-        // Has ConflictingUpdates includes both resolvable and unresolvable
-        // conflicts. If we have either, we want to attempt to reapply.
-        if (status->HasConflictingUpdates())
-          next_step = APPLY_UPDATES_TO_RESOLVE_CONFLICTS;
-        else
-          next_step = SYNCER_END;
-        break;
-      }
-      case APPLY_UPDATES_TO_RESOLVE_CONFLICTS: {
-        StatusController* status = session->mutable_status_controller();
-        DVLOG(1) << "Applying updates to resolve conflicts";
-        ApplyUpdatesCommand apply_updates;
-
-        // We only care to resolve conflicts again if we made progress on the
-        // simple conflicts.
-        int before_blocking_conflicting_updates =
-            status->num_simple_conflicts();
-        apply_updates.Execute(session);
-        int after_blocking_conflicting_updates =
-            status->num_simple_conflicts();
-        // If the following call sets the conflicts_resolved value to true,
-        // SyncSession::HasMoreToSync() will send us into another sync cycle
-        // after this one completes.
-        //
-        // TODO(rlarocque, 109072): Make conflict resolution not require
-        // extra sync cycles/GetUpdates.
-        status->update_conflicts_resolved(before_blocking_conflicting_updates >
-                                          after_blocking_conflicting_updates);
         next_step = SYNCER_END;
         break;
       }
       case SYNCER_END: {
         session->SendEventNotification(SyncEngineEvent::SYNC_CYCLE_ENDED);
         next_step = SYNCER_END;
         break;
       }
       default:
         LOG(ERROR) << "Unknown command: " << current_step;
@@ skipping 30 matching lines @@
   entry->Put(SERVER_CTIME, Time());
   entry->Put(SERVER_VERSION, 0);
   entry->Put(SERVER_IS_DIR, false);
   entry->Put(SERVER_IS_DEL, false);
   entry->Put(IS_UNAPPLIED_UPDATE, false);
   entry->Put(SERVER_SPECIFICS, sync_pb::EntitySpecifics::default_instance());
   entry->Put(SERVER_ORDINAL_IN_PARENT, Int64ToNodeOrdinal(0));
 }
 
 }  // namespace syncer