sync: use progress markers instead of timestamps during GetUpdates

chrome/browser/sync/profile_sync_service_harness.cc

 // Copyright (c) 2010 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/profile_sync_service_harness.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/message_loop.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/net/gaia/token_service.h"
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 #include "chrome/browser/sync/sessions/session_state.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/net/gaia/google_service_auth_error.h"
 #include "chrome/common/notification_source.h"
 #include "chrome/common/pref_names.h"
 
 // The default value for min_timestamp_needed_ when we're not in the
 // WAITING_FOR_UPDATES state.
 static const int kMinTimestampNeededNone = -1;

[Raghu Simha, 2011/01/11 18:53:04]

I believe you can now get rid of this constant.

[ncarter (slow), 2011/01/13 00:06:13]

Done.

 
 // The amount of time for which we wait for a live sync operation to complete.
 static const int kLiveSyncOperationTimeoutMs = 30000;
 
 // Simple class to implement a timeout using PostDelayedTask.  If it is not
 // aborted before picked up by a message queue, then it asserts with the message
 // provided.  This class is not thread safe.
 class StateChangeTimeoutEvent
     : public base::RefCountedThreadSafe<StateChangeTimeoutEvent> {
  public:
@@ skipping 218 matching lines @@
       LogClientInfo("WAITING_FOR_SYNC_TO_FINISH");
       if (!IsSynced()) {
         // The client is not yet fully synced. Continue waiting.
         if (!GetStatus().server_reachable) {
           // The client cannot reach the sync server because the network is
           // disabled. There is no need to wait anymore.
           SignalStateCompleteWithNextState(SERVER_UNREACHABLE);
         }
         break;
       }
-      GetUpdatedTimestamp();
       SignalStateCompleteWithNextState(FULLY_SYNCED);
       break;
     }
     case WAITING_FOR_UPDATES: {
       LogClientInfo("WAITING_FOR_UPDATES");
       DCHECK(timestamp_match_partner_);
       if (!MatchesOtherClient(timestamp_match_partner_)) {
         // The client is not yet fully synced; keep waiting until we converge.
         break;
       }
@@ skipping 68 matching lines @@
       } else if (wait_state_ == SERVER_UNREACHABLE) {
         // Client is offline; sync was unsuccessful.
         return false;
       } else {
         LOG(ERROR) << "Invalid wait state:" << wait_state_;
         return false;
       }
     }
   } else {
     // Client is already synced; don't wait.
-    GetUpdatedTimestamp();
     return true;
   }
 }
 
 bool ProfileSyncServiceHarness::AwaitMutualSyncCycleCompletion(
     ProfileSyncServiceHarness* partner) {
   LogClientInfo("AwaitMutualSyncCycleCompletion");
   if (!AwaitSyncCycleCompletion("Sync cycle completion on active client."))
     return false;
   return partner->WaitUntilTimestampMatches(this,
@@ skipping 105 matching lines @@
 
   // Only look for a match if we have at least one enabled datatype in
   // common with the partner client.
   syncable::ModelTypeSet types, other_types, intersection_types;
   service()->GetPreferredDataTypes(&types);
   partner->service()->GetPreferredDataTypes(&other_types);
   std::set_intersection(types.begin(), types.end(), other_types.begin(),
                         other_types.end(),
                         inserter(intersection_types,
                                  intersection_types.begin()));
-  if (intersection_types.empty()) {
-    return true;
+  for (syncable::ModelTypeSet::iterator i = intersection_types.begin();
+       i != intersection_types.end();
+       ++i) {
+    if (!partner->IsSynced() ||
+        partner->GetUpdatedTimestamp(*i) != GetUpdatedTimestamp(*i)) {
+      return false;
+    }
   }
-  return partner->IsSynced() &&
-      partner->GetUpdatedTimestamp() == GetUpdatedTimestamp();
+  return true;
 }
 
 const SyncSessionSnapshot*
     ProfileSyncServiceHarness::GetLastSessionSnapshot() const {
   DCHECK(service_ != NULL) << "Sync service has not yet been set up.";
   if (service_->backend()) {
     return service_->backend()->GetLastSessionSnapshot();
   }
   return NULL;
 }
@@ skipping 69 matching lines @@
 void ProfileSyncServiceHarness::DisableSyncForAllDatatypes() {
   LogClientInfo("DisableSyncForAllDatatypes");
   DCHECK(service() != NULL) << "EnableSyncForAllDatatypes(): service() is "
                                "null.";
   service()->DisableForUser();
   wait_state_ = SYNC_DISABLED;
   VLOG(1) << "DisableSyncForAllDatatypes(): Disabled sync for all datatypes on "
              "Client " << id_;
 }
 
-int64 ProfileSyncServiceHarness::GetUpdatedTimestamp() {
+std::string ProfileSyncServiceHarness::GetUpdatedTimestamp(
+    syncable::ModelType model_type) {
   const SyncSessionSnapshot* snap = GetLastSessionSnapshot();
   DCHECK(snap != NULL) << "GetUpdatedTimestamp(): Sync snapshot is NULL.";
-  return snap->max_local_timestamp;
+  return snap->download_progress_markers[model_type];
 }
 
 void ProfileSyncServiceHarness::LogClientInfo(std::string message) {
   if (service()) {
     const SyncSessionSnapshot* snap = GetLastSessionSnapshot();
     if (snap) {
       VLOG(1) << "Client " << id_ << ": " << message
-              << ": max_local_timestamp: " << snap->max_local_timestamp
+              << ": num_updates_downloaded : "
+              << snap->syncer_status.num_updates_downloaded
               << ", has_more_to_sync: " << snap->has_more_to_sync
               << ", unsynced_count: " << snap->unsynced_count
               << ", num_conflicting_updates: " << snap->num_conflicting_updates
               << ", has_unsynced_items: "
               << service()->backend()->HasUnsyncedItems()
               << ", observed_passphrase_required: "
               << service()->observed_passphrase_required()
               << ", notifications_enabled: "
               << GetStatus().notifications_enabled
               << ", service_is_pushing_changes: " << ServiceIsPushingChanges();
     } else {
       VLOG(1) << "Client " << id_ << ": " << message
               << ": Sync session snapshot not available.";
     }
   } else {
     VLOG(1) << "Client " << id_ << ": " << message
             << ": Sync service not available.";
   }
 }