[Retry][SyncFS] Implement LargestKnownChangeID handling

chrome/browser/sync_file_system/drive_backend/metadata_database.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/metadata_database.h"
 
 #include <algorithm>
 #include <stack>
 
 #include "base/bind.h"
@@ skipping 482 matching lines @@
 
 int64 MetadataDatabase::GetLargestFetchedChangeID() const {
   return service_metadata_->largest_change_id();
 }
 
 int64 MetadataDatabase::GetSyncRootTrackerID() const {
   return service_metadata_->sync_root_tracker_id();
 }
 
 int64 MetadataDatabase::GetLargestKnownChangeID() const {
-  // TODO(tzik): Implement:
-  //  - Add |largest_known_file_id| member to hold the value, that should
-  //    initially have the same value to |largest_change_id|.
-  //  - Change UpdateByFileResource and UpdateByChangeList not to overwrite
-  //    FileMetadata if the newer one.
-  //  - Change ListChangesTask to set UpdateLargestKnownChangeID.
-  return GetLargestFetchedChangeID();
+  DCHECK_LE(GetLargestFetchedChangeID(), largest_known_change_id_);
+  return largest_known_change_id_;
 }
 
 void MetadataDatabase::UpdateLargestKnownChangeID(int64 change_id) {
-  NOTIMPLEMENTED();
+  if (largest_known_change_id_ < change_id)
+    largest_known_change_id_ = change_id;
 }
 
 bool MetadataDatabase::HasSyncRoot() const {
   return service_metadata_->has_sync_root_tracker_id() &&
       !!service_metadata_->sync_root_tracker_id();
 }
 
 void MetadataDatabase::PopulateInitialData(
     int64 largest_change_id,
     const google_apis::FileResource& sync_root_folder,
     const ScopedVector<google_apis::FileResource>& app_root_folders,
     const SyncStatusCallback& callback) {
   DCHECK(tracker_by_id_.empty());
   DCHECK(file_by_id_.empty());
 
   scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
   service_metadata_->set_largest_change_id(largest_change_id);
+  UpdateLargestKnownChangeID(largest_change_id);
 
   FileTracker* sync_root_tracker = NULL;
   int64 sync_root_tracker_id = 0;
   {
     scoped_ptr<FileMetadata> folder;
     scoped_ptr<FileTracker> tracker;
     CreateInitialSyncRootTracker(GetNextTrackerID(batch.get()),
                                  sync_root_folder,
                                  &folder,
                                  &tracker);
@@ skipping 213 matching lines @@
     const SyncStatusCallback& callback) {
   DCHECK_LE(service_metadata_->largest_change_id(), largest_change_id);
 
   scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
 
   for (ScopedVector<google_apis::ChangeResource>::const_iterator itr =
            changes.begin();
        itr != changes.end();
        ++itr) {
     const google_apis::ChangeResource& change = **itr;
+    if (HasNewerFileMetadata(change.file_id(), change.change_id()))
+      continue;
+
     scoped_ptr<FileMetadata> file(
         CreateFileMetadataFromChangeResource(change));
     std::string file_id = file->file_id();
 
     MarkTrackersDirtyByFileID(file_id, batch.get());
     if (!file->details().deleted())
       MaybeAddTrackersForNewFile(*file, batch.get());
 
     if (FindTrackersByFileID(file_id, NULL)) {
       PutFileToBatch(*file, batch.get());
 
       // Set |file| to |file_by_id_[file_id]| and delete old value.
       FileMetadata* file_ptr = file.release();
       std::swap(file_ptr, file_by_id_[file_id]);
       delete file_ptr;
     }
   }
 
+  UpdateLargestKnownChangeID(largest_change_id);
   service_metadata_->set_largest_change_id(largest_change_id);
   PutServiceMetadataToBatch(*service_metadata_, batch.get());
   WriteToDatabase(batch.Pass(), callback);
 }
 
 void MetadataDatabase::UpdateByFileResource(
     int64 change_id,
     const google_apis::FileResource& resource,
     const SyncStatusCallback& callback) {
   scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
 
   scoped_ptr<FileMetadata> file(
       CreateFileMetadataFromFileResource(change_id, resource));
   std::string file_id = file->file_id();
+  if (HasNewerFileMetadata(file_id, change_id))
+    return;
 
   // TODO(tzik): Consolidate with UpdateByChangeList.
   MarkTrackersDirtyByFileID(file_id, batch.get());
   if (!file->details().deleted()) {
     MaybeAddTrackersForNewFile(*file, batch.get());
 
     if (FindTrackersByFileID(file_id, NULL)) {
       PutFileToBatch(*file, batch.get());
 
       // Set |file| to |file_by_id_[file_id]| and delete old value.
@@ skipping 141 matching lines @@
   NOTIMPLEMENTED();
   return false;
 }
 
 bool MetadataDatabase::GetLowPriorityDirtyTracker(FileTracker* tracker) {
   NOTIMPLEMENTED();
   return false;
 }
 
 MetadataDatabase::MetadataDatabase(base::SequencedTaskRunner* task_runner)
-    : task_runner_(task_runner), weak_ptr_factory_(this) {
+    : task_runner_(task_runner),
+      largest_known_change_id_(0),
+      weak_ptr_factory_(this) {
   DCHECK(task_runner);
 }
 
 // static
 void MetadataDatabase::CreateOnTaskRunner(
     base::SingleThreadTaskRunner* callback_runner,
     base::SequencedTaskRunner* task_runner,
     const base::FilePath& database_path,
     const CreateCallback& callback) {
   scoped_ptr<MetadataDatabase> metadata_database(
@@ skipping 73 matching lines @@
       db_->Write(leveldb::WriteOptions(), &batch));
   if (status != SYNC_STATUS_OK)
     return status;
 
   BuildIndexes(&contents);
   return status;
 }
 
 void MetadataDatabase::BuildIndexes(DatabaseContents* contents) {
   service_metadata_ = contents->service_metadata.Pass();
+  UpdateLargestKnownChangeID(service_metadata_->largest_change_id());
 
   for (ScopedVector<FileMetadata>::const_iterator itr =
            contents->file_metadata.begin();
        itr != contents->file_metadata.end();
        ++itr) {
     file_by_id_[(*itr)->file_id()] = *itr;
   }
   contents->file_metadata.weak_clear();
 
   for (ScopedVector<FileTracker>::const_iterator itr =
@@ skipping 487 matching lines @@
     details->SetString("dirty", tracker->dirty() ? "true" : "false");
 
     file->Set("details", details);
 
     files->Append(file);
   }
 
   return files.Pass();
 }
 
+bool MetadataDatabase::HasNewerFileMetadata(const std::string& file_id,
+                                            int64 change_id) {
+  FileByID::const_iterator found = file_by_id_.find(file_id);
+  if (found == file_by_id_.end())
+    return false;
+  DCHECK(found->second->has_details());
+  return found->second->details().change_id() >= change_id;
+}
+
 }  // namespace drive_backend
 }  // namespace sync_file_system