Sync: fix for the code that checks whether the initial download has completed

sync/engine/directory_update_handler.cc

 // Copyright 2014 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/directory_update_handler.h"
 
 #include "sync/engine/conflict_resolver.h"
 #include "sync/engine/process_updates_util.h"
 #include "sync/engine/update_applicator.h"
 #include "sync/sessions/directory_type_debug_info_emitter.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/model_neutral_mutable_entry.h"
+#include "sync/syncable/syncable_changes_version.h"
 #include "sync/syncable/syncable_model_neutral_write_transaction.h"
 #include "sync/syncable/syncable_write_transaction.h"
 #include "sync/util/data_type_histogram.h"
 
 namespace syncer {
 
 using syncable::SYNCER;
 
 DirectoryUpdateHandler::DirectoryUpdateHandler(
     syncable::Directory* dir,
@@ skipping 79 matching lines @@
     DVLOG(1) << "Type root folder " << ModelTypeToRootTag(type_)
              << " already exists.";
     return;
   }
 
   entry.PutServerIsDir(true);
   entry.PutUniqueServerTag(ModelTypeToRootTag(type_));
 }
 
 void DirectoryUpdateHandler::ApplyUpdates(sessions::StatusController* status) {
-  if (!IsApplyUpdatesRequired()) {
-    return;
+  if (IsApplyUpdatesRequired()) {
+    // This will invoke handlers that belong to the model and its thread, so we
+    // switch to the appropriate thread before we start this work.
+    WorkCallback c =
+        base::Bind(&DirectoryUpdateHandler::ApplyUpdatesImpl,
+                   // We wait until the callback is executed.  We can safely use
+                   // Unretained.
+                   base::Unretained(this), base::Unretained(status));
+    worker_->DoWorkAndWaitUntilDone(c);
+
+    debug_info_emitter_->EmitUpdateCountersUpdate();
+    debug_info_emitter_->EmitStatusCountersUpdate();
   }
 
-  // This will invoke handlers that belong to the model and its thread, so we
-  // switch to the appropriate thread before we start this work.
-  WorkCallback c = base::Bind(
-      &DirectoryUpdateHandler::ApplyUpdatesImpl,
-      // We wait until the callback is executed.  We can safely use Unretained.
-      base::Unretained(this),
-      base::Unretained(status));
-  worker_->DoWorkAndWaitUntilDone(c);
-
-  debug_info_emitter_->EmitUpdateCountersUpdate();
-  debug_info_emitter_->EmitStatusCountersUpdate();
+  PostApplyUpdates();
 }
 
 void DirectoryUpdateHandler::PassiveApplyUpdates(
     sessions::StatusController* status) {
-  if (!IsApplyUpdatesRequired()) {
-    return;
+  if (IsApplyUpdatesRequired()) {
+    // Just do the work here instead of deferring to another thread.
+    ApplyUpdatesImpl(status);
+
+    debug_info_emitter_->EmitUpdateCountersUpdate();
+    debug_info_emitter_->EmitStatusCountersUpdate();
   }
 
-  // Just do the work here instead of deferring to another thread.
-  ApplyUpdatesImpl(status);
-
-  debug_info_emitter_->EmitUpdateCountersUpdate();
-  debug_info_emitter_->EmitStatusCountersUpdate();
+  PostApplyUpdates();
 }
 
 SyncerError DirectoryUpdateHandler::ApplyUpdatesImpl(
     sessions::StatusController* status) {
   syncable::WriteTransaction trans(FROM_HERE, syncable::SYNCER, dir_);
 
   std::vector<int64> handles;
   dir_->GetUnappliedUpdateMetaHandles(
       &trans,
       FullModelTypeSet(type_),
@@ skipping 61 matching lines @@
     // There should be no simple conflicts remaining.  We know this because the
     // resolver should have resolved all the conflicts we detected last time
     // and, by the two previous assertions, that no conflicts have been
     // downgraded from encryption or hierarchy down to simple.
     DCHECK(conflict_applicator.simple_conflict_ids().empty());
   }
 
   return SYNCER_OK;
 }
 
+void DirectoryUpdateHandler::PostApplyUpdates() {
+  // If this is a type with client generated root, the root node has been
+  // created locally and didn't go through ApplyUpdatesImpl.
+  // Mark it as having the initial download completed so that the type
+  // reports as properly initialized (which is done by changing the root's
+  // base version to a value other than CHANGES_VERSION).
+  // This does nothing if the root's base version is already other than
+  // CHANGES_VERSION.
+  if (IsTypeWithClientGeneratedRoot(type_)) {
+    syncable::ModelNeutralWriteTransaction trans(FROM_HERE, SYNCER, dir_);
+    dir_->MarkInitialSyncEndedForType(&trans, type_);
+  }
+}
+
 bool DirectoryUpdateHandler::IsApplyUpdatesRequired() {
   if (IsControlType(type_)) {
     return false;  // We don't process control types here.
   }
 
   return dir_->TypeHasUnappliedUpdates(type_);
 }
 
 void DirectoryUpdateHandler::UpdateSyncEntities(
     syncable::ModelNeutralWriteTransaction* trans,
@@ skipping 57 matching lines @@
               new_gc_directive.version_watermark())) {
     ExpireEntriesByVersion(dir_, trans, type_,
                            new_gc_directive.version_watermark());
   }
 
   cached_gc_directive_.reset(
       new sync_pb::GarbageCollectionDirective(new_gc_directive));
 }
 
 }  // namespace syncer