Rest of the autofill work.

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 161 matching lines @@
 void Directory::init_kernel(const std::string& name) {
   DCHECK(kernel_ == NULL);
   kernel_ = new Kernel(FilePath(), name, KernelLoadInfo());
 }
 
 Directory::PersistedKernelInfo::PersistedKernelInfo()
     : next_id(0) {
   for (int i = 0; i < MODEL_TYPE_COUNT; ++i) {
     last_download_timestamp[i] = 0;
   }
+  autofill_migration_state =
+    Directory::PersistedKernelInfo::NOT_DETERMINED;
 }
 
 Directory::PersistedKernelInfo::~PersistedKernelInfo() {}
 
 Directory::SaveChangesSnapshot::SaveChangesSnapshot()
     : kernel_info_status(KERNEL_SHARE_INFO_INVALID) {
 }
 
 Directory::SaveChangesSnapshot::~SaveChangesSnapshot() {}
 
@@ skipping 521 matching lines @@
     int64 timestamp) {
   ScopedKernelLock lock(this);
   set_last_download_timestamp_unsafe(model_type, timestamp);
 }
 
 bool Directory::initial_sync_ended_for_type(ModelType type) const {
   ScopedKernelLock lock(this);
   return kernel_->persisted_info.initial_sync_ended[type];
 }
 
+Directory::PersistedKernelInfo::AutofillMigrationState
+  Directory::get_autofill_migration_state() const {
+  ScopedKernelLock lock(this);
+  return kernel_->persisted_info.autofill_migration_state;
+}
+
+AutofillMigrationDebugInfo
+    Directory::get_autofill_migration_debug_info() const {
+  ScopedKernelLock lock(this);
+  return kernel_->persisted_info.autofill_migration_debug_info;
+}
+
+template <class T> void Directory::TestAndSet(
+    T* kernel_data, const T* data_to_set) {
+  if (*kernel_data != *data_to_set) {
+    *kernel_data = *data_to_set;
+    kernel_->info_status = KERNEL_SHARE_INFO_DIRTY;
+  }
+}
+
+void Directory::set_autofill_migration_state_debug_info(
+    AutofillMigrationDebugInfo::PropertyToSet property_to_set,
+    const AutofillMigrationDebugInfo& info) {
+
+  ScopedKernelLock lock(this);
+  switch (property_to_set) {
+    case AutofillMigrationDebugInfo::MIGRATION_TIME: {
+      TestAndSet<int64>(
+          &kernel_->persisted_info.autofill_migration_debug_info.autofill_migration_time,
+          &info.autofill_migration_time);
+      break;
+    }
+    case AutofillMigrationDebugInfo::BOOKMARK_ADDED: {
+      AutofillMigrationDebugInfo& debug_info =
+        kernel_->persisted_info.autofill_migration_debug_info;
+      TestAndSet<int>(
+          &debug_info.bookmarks_added_during_migration,
+          &info.bookmarks_added_during_migration);
+      break;
+    }
+    case AutofillMigrationDebugInfo::ENTRIES_ADDED: {
+      AutofillMigrationDebugInfo& debug_info =
+        kernel_->persisted_info.autofill_migration_debug_info;
+      TestAndSet<int>(
+          &debug_info.autofill_entries_added_during_migration,
+          &info.autofill_entries_added_during_migration);
+      break;
+    }
+    case AutofillMigrationDebugInfo::PROFILES_ADDED: {
+      AutofillMigrationDebugInfo& debug_info =
+        kernel_->persisted_info.autofill_migration_debug_info;
+      TestAndSet<int>(
+          &debug_info.autofill_profile_added_during_migration,
+          &info.autofill_profile_added_during_migration);
+      break;
+    }
+    default:
+      NOTREACHED();
+  }
+}
+
+void Directory::set_autofill_migration_state(
+  Directory::PersistedKernelInfo::AutofillMigrationState state) {
+  ScopedKernelLock lock(this);
+  if (state == kernel_->persisted_info.autofill_migration_state) {
+    return;
+  }
+  kernel_->persisted_info.autofill_migration_state = state;
+  if (state == Directory::PersistedKernelInfo::MIGRATED) {
+    base::Time time = base::Time::Now();
+    int64 k = 0;//time.ToTimeT();
+    kernel_->persisted_info.autofill_migration_debug_info.autofill_migration_time =
+      k;
+  }
+  kernel_->info_status = KERNEL_SHARE_INFO_DIRTY;
+}
+
 void Directory::set_initial_sync_ended_for_type(ModelType type, bool x) {
   ScopedKernelLock lock(this);
   set_initial_sync_ended_for_type_unsafe(type, x);
 }
 
 void Directory::set_initial_sync_ended_for_type_unsafe(ModelType type,
                                                        bool x) {
   if (kernel_->persisted_info.initial_sync_ended[type] == x)
     return;
   kernel_->persisted_info.initial_sync_ended.set(type, x);
@@ skipping 919 matching lines @@
 
 FastDump& operator<<(FastDump& dump, const Blob& blob) {
   if (blob.empty())
     return dump;
   string buffer(base::HexEncode(&blob[0], blob.size()));
   dump.out_->sputn(buffer.c_str(), buffer.size());
   return dump;
 }
 
 }  // namespace syncable