sync: Remove the remaining conflict sets code

chrome/browser/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 "chrome/browser/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 "chrome/browser/sync/engine/apply_updates_command.h"
-#include "chrome/browser/sync/engine/build_and_process_conflict_sets_command.h"
 #include "chrome/browser/sync/engine/build_commit_command.h"
 #include "chrome/browser/sync/engine/cleanup_disabled_types_command.h"
 #include "chrome/browser/sync/engine/clear_data_command.h"
 #include "chrome/browser/sync/engine/conflict_resolver.h"
 #include "chrome/browser/sync/engine/download_updates_command.h"
 #include "chrome/browser/sync/engine/get_commit_ids_command.h"
 #include "chrome/browser/sync/engine/net/server_connection_manager.h"
 #include "chrome/browser/sync/engine/post_commit_message_command.h"
 #include "chrome/browser/sync/engine/process_commit_response_command.h"
 #include "chrome/browser/sync/engine/process_updates_command.h"
@@ skipping 39 matching lines @@
     ENUM_CASE(CLEANUP_DISABLED_TYPES);
     ENUM_CASE(DOWNLOAD_UPDATES);
     ENUM_CASE(PROCESS_CLIENT_COMMAND);
     ENUM_CASE(VERIFY_UPDATES);
     ENUM_CASE(PROCESS_UPDATES);
     ENUM_CASE(STORE_TIMESTAMPS);
     ENUM_CASE(APPLY_UPDATES);
     ENUM_CASE(BUILD_COMMIT_REQUEST);
     ENUM_CASE(POST_COMMIT_MESSAGE);
     ENUM_CASE(PROCESS_COMMIT_RESPONSE);
-    ENUM_CASE(BUILD_AND_PROCESS_CONFLICT_SETS);
     ENUM_CASE(RESOLVE_CONFLICTS);
     ENUM_CASE(APPLY_UPDATES_TO_RESOLVE_CONFLICTS);
     ENUM_CASE(CLEAR_PRIVATE_DATA);
     ENUM_CASE(SYNCER_END);
   }
   NOTREACHED();
   return "";
 }
 #undef ENUM_CASE
 
@@ skipping 125 matching lines @@
             session->context()->max_commit_batch_size());
         get_commit_ids_command.Execute(session);
 
         if (!session->status_controller().commit_ids().empty()) {
           DVLOG(1) << "Building a commit message";
           BuildCommitCommand build_commit_command;
           build_commit_command.Execute(session);
 
           next_step = POST_COMMIT_MESSAGE;
         } else {
-          next_step = BUILD_AND_PROCESS_CONFLICT_SETS;
+          next_step = RESOLVE_CONFLICTS;
         }
 
         break;
       }
       case POST_COMMIT_MESSAGE: {
         PostCommitMessageCommand post_commit_command;
         session->mutable_status_controller()->set_last_post_commit_result(
             post_commit_command.Execute(session));
         next_step = PROCESS_COMMIT_RESPONSE;
         break;
       }
       case PROCESS_COMMIT_RESPONSE: {
         session->mutable_status_controller()->reset_num_conflicting_commits();
         ProcessCommitResponseCommand process_response_command;
         session->mutable_status_controller()->
             set_last_process_commit_response_result(
                 process_response_command.Execute(session));
-        next_step = BUILD_AND_PROCESS_CONFLICT_SETS;
-        break;
-      }
-      case BUILD_AND_PROCESS_CONFLICT_SETS: {
-        BuildAndProcessConflictSetsCommand build_process_conflict_sets;
-        build_process_conflict_sets.Execute(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 blocking and non-blocking
+        // 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
-        // blocking conflicts. Whether or not we made progress on the
-        // non-blocking doesn't matter.
+        // simple conflicts.
         int before_blocking_conflicting_updates =
-            status->TotalNumBlockingConflictingItems();
+            status->TotalNumSimpleConflictingItems();
         apply_updates.Execute(session);
         int after_blocking_conflicting_updates =
-            status->TotalNumBlockingConflictingItems();
+            status->TotalNumSimpleConflictingItems();
         // 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;
@@ skipping 69 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_POSITION_IN_PARENT, 0);
 }
 
 }  // namespace browser_sync