Fix handling of undeletion within the syncer.

chrome/browser/sync/syncable/syncable.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/syncable/syncable.h"
 
 #include "build/build_config.h"
 
 #include <sys/stat.h>
 #if defined(OS_POSIX)
@@ skipping 845 matching lines @@
         CHECK(parent.Get(IS_DIR)) << parent << e;
         CHECK(!parent.Get(IS_DEL)) << parent << e;
         CHECK(handles.end() != handles.find(parent.Get(META_HANDLE)))
             << e << parent;
         parentid = parent.Get(PARENT_ID);
         CHECK(--safety_count >= 0) << e << parent;
       }
     }
     int64 base_version = e.Get(BASE_VERSION);
     int64 server_version = e.Get(SERVER_VERSION);
+    bool using_unique_client_tag = !e.Get(UNIQUE_CLIENT_TAG).empty();
     if (CHANGES_VERSION == base_version || 0 == base_version) {
       if (e.Get(IS_UNAPPLIED_UPDATE)) {
-        // Unapplied new item.
-        CHECK(e.Get(IS_DEL)) << e;
+        // Must be a new item, or a de-duplicated unique client tag
+        // that was created both locally and remotely.
+        if (!using_unique_client_tag) {
+          CHECK(e.Get(IS_DEL)) << e;
+        }
+        // It came from the server, so it must have a server ID.
         CHECK(id.ServerKnows()) << e;
       } else {
         if (e.Get(IS_DIR)) {
           // TODO(chron): Implement this mode if clients ever need it.
           // For now, you can't combine a client tag and a directory.
-          CHECK(e.Get(UNIQUE_CLIENT_TAG).empty()) << e;
+          CHECK(!using_unique_client_tag) << e;
         }
-        // Uncommitted item.
+        // Should be an uncomitted item, or a successfully deleted one.
         if (!e.Get(IS_DEL)) {
           CHECK(e.Get(IS_UNSYNCED)) << e;
         }
+        // If the next check failed, it would imply that an item exists
+        // on the server, isn't waiting for application locally, but either
+        // is an unsynced create or a sucessful delete in the local copy.
+        // Either way, that's a mismatch.
         CHECK(0 == server_version) << e;
-        CHECK(!id.ServerKnows()) << e;
+        // Items that aren't using the unique client tag should have a zero
+        // base version only if they have a local ID.  Items with unique client
+        // tags are allowed to use the zero base version for undeletion and
+        // de-duplication; the unique client tag trumps the server ID.
+        if (!using_unique_client_tag) {
+          CHECK(!id.ServerKnows()) << e;
+        }
       }
     } else {
       CHECK(id.ServerKnows());
     }
     ++entries_done;
     int64 elapsed_ms = check_timer.Elapsed().InMilliseconds();
     if (elapsed_ms > max_ms) {
       LOG(INFO) << "Cutting Invariant check short after " << elapsed_ms << "ms."
         " Processed " << entries_done << "/" << handles.size() << " entries";
       return;
     }
   }
-  // I did intend to add a check here to ensure no entries had been pulled into
-  // memory by this function, but we can't guard against another ReadTransaction
-  // pulling entries into RAM
 }
 
 browser_sync::ChannelHookup<DirectoryChangeEvent>* Directory::AddChangeObserver(
     browser_sync::ChannelEventHandler<DirectoryChangeEvent>* observer) {
   return kernel_->changes_channel.AddObserver(observer);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ScopedKernelLocks
 
@@ skipping 638 matching lines @@
   return s << std::dec;
 }
 
 FastDump& operator<<(FastDump& dump, const syncable::Blob& blob) {
   if (blob.empty())
     return dump;
   string buffer(HexEncode(&blob[0], blob.size()));
   dump.out_->sputn(buffer.c_str(), buffer.size());
   return dump;
 }