[SyncFS] Run ConflictResolver only when it is needed.

chrome/browser/sync_file_system/drive_backend/sync_engine.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/sync_file_system/drive_backend/sync_engine.h"
 
 #include "base/bind.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/drive/drive_api_service.h"
@@ skipping 378 matching lines @@
     drive::DriveNotificationManager* notification_manager,
     ExtensionServiceInterface* extension_service)
     : base_dir_(base_dir),
       task_runner_(task_runner),
       drive_service_(drive_service.Pass()),
       drive_uploader_(drive_uploader.Pass()),
       notification_manager_(notification_manager),
       extension_service_(extension_service),
       remote_change_processor_(NULL),
       service_state_(REMOTE_SERVICE_TEMPORARY_UNAVAILABLE),
+      should_check_conflict_(true),
       should_check_remote_change_(true),
       sync_enabled_(false),
       conflict_resolution_policy_(CONFLICT_RESOLUTION_POLICY_LAST_WRITE_WIN),
       network_available_(false),
       weak_ptr_factory_(this) {
 }
 
 void SyncEngine::DoDisableApp(const std::string& app_id,
                               const SyncStatusCallback& callback) {
   metadata_database_->DisableApp(app_id, callback);
@@ skipping 18 matching lines @@
 
   if (syncer->url().is_valid() && syncer->sync_action() != SYNC_ACTION_NONE) {
     FOR_EACH_OBSERVER(FileStatusObserver,
                       file_status_observers_,
                       OnFileStatusChanged(syncer->url(),
                                           SYNC_FILE_STATUS_SYNCED,
                                           syncer->sync_action(),
                                           SYNC_DIRECTION_REMOTE_TO_LOCAL));
   }
 
+  if (status == SYNC_STATUS_OK)
+    should_check_conflict_ = true;
   callback.Run(status, syncer->url());
 }
 
 void SyncEngine::DidApplyLocalChange(LocalToRemoteSyncer* syncer,
                                      const SyncStatusCallback& callback,
                                      SyncStatusCode status) {
   util::Log(logging::LOG_VERBOSE, FROM_HERE,
             "[Local->Remote] ApplyLocalChange finished --> %s",
             SyncStatusCodeToString(status));
 
@@ skipping 15 matching lines @@
 
   if (status != SYNC_STATUS_OK &&
       status != SYNC_STATUS_NO_CHANGE_TO_SYNC) {
     callback.Run(status);
     return;
   }
 
   if (status == SYNC_STATUS_NO_CHANGE_TO_SYNC)
     metadata_database_->PromoteLowerPriorityTrackersToNormal();
 
+  if (status == SYNC_STATUS_OK)
+    should_check_conflict_ = true;
   callback.Run(status);
 }
 
 void SyncEngine::MaybeStartFetchChanges() {
   if (GetCurrentState() == REMOTE_SERVICE_DISABLED)
     return;
 
   if (!metadata_database_)
     return;
 
   base::TimeTicks now = base::TimeTicks::Now();
   if (!should_check_remote_change_ && now < time_to_check_changes_) {
-    if (!metadata_database_->HasDirtyTracker()) {
+    if (!metadata_database_->HasDirtyTracker() && should_check_conflict_) {
       task_manager_->ScheduleSyncTaskIfIdle(
           scoped_ptr<SyncTask>(new ConflictResolver(this)),
-          SyncStatusCallback());
+          base::Bind(&SyncEngine::DidResolveConflict,
+                     weak_ptr_factory_.GetWeakPtr()));
     }
     return;
   }
 
   if (task_manager_->ScheduleSyncTaskIfIdle(
           scoped_ptr<SyncTask>(new ListChangesTask(this)),
-          SyncStatusCallback())) {
+          base::Bind(&SyncEngine::DidFetchChanges,
+                     weak_ptr_factory_.GetWeakPtr()))) {
     should_check_remote_change_ = false;
     time_to_check_changes_ =
         now + base::TimeDelta::FromSeconds(kListChangesRetryDelaySeconds);
   }
 }
 
+void SyncEngine::DidResolveConflict(SyncStatusCode status) {
+  if (status == SYNC_STATUS_NO_CONFLICT)
+    should_check_conflict_ = false;
+}
+
+void SyncEngine::DidFetchChanges(SyncStatusCode status) {
+  if (status == SYNC_STATUS_OK)
+    should_check_conflict_ = true;
+}
+
 void SyncEngine::UpdateServiceStateFromSyncStatusCode(
       SyncStatusCode status,
       bool used_network) {
   switch (status) {
     case SYNC_STATUS_OK:
       if (used_network)
         UpdateServiceState(REMOTE_SERVICE_OK, std::string());
       break;
 
     // Authentication error.
@@ skipping 79 matching lines @@
         tracker.tracker_kind() == TRACKER_KIND_APP_ROOT;
     if (is_app_enabled && !is_app_root_tracker_enabled)
       EnableOrigin(origin, base::Bind(&EmptyStatusCallback));
     else if (!is_app_enabled && is_app_root_tracker_enabled)
       DisableOrigin(origin, base::Bind(&EmptyStatusCallback));
   }
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system