Remove extended attributes. The lame broken codepath in the DBS was causing

chrome/browser/sync/syncable/directory_backing_store.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/directory_backing_store.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_MACOSX)
 #include <CoreFoundation/CoreFoundation.h>
@@ skipping 22 matching lines @@
 using std::string;
 
 namespace syncable {
 
 // This just has to be big enough to hold an UPDATE or INSERT statement that
 // modifies all the columns in the entry table.
 static const string::size_type kUpdateStatementBufferSize = 2048;
 
 // Increment this version whenever updating DB tables.
 extern const int32 kCurrentDBVersion;  // Global visibility for our unittest.
-const int32 kCurrentDBVersion = 71;
+const int32 kCurrentDBVersion = 72;
 
 namespace {
 
 int ExecQuery(sqlite3* dbhandle, const char* query) {
   SQLStatement statement;
   int result = statement.prepare(dbhandle, query);
   if (SQLITE_OK != result)
     return result;
   do {
     result = statement.step();
@@ skipping 154 matching lines @@
       SetFileAttributes(backing_filepath_.value().c_str(),
                         attrs | FILE_ATTRIBUTE_NOT_CONTENT_INDEXED);
 #endif
 
     return true;
   }
   return false;
 }
 
 DirOpenResult DirectoryBackingStore::Load(MetahandlesIndex* entry_bucket,
-    ExtendedAttributes* xattrs_bucket,
     Directory::KernelLoadInfo* kernel_load_info) {
   if (!BeginLoad())
     return FAILED_OPEN_DATABASE;
 
   DirOpenResult result = InitializeTables();
   if (OPENED != result)
     return result;
 
   if (!DropDeletedEntries() ||
       !LoadEntries(entry_bucket) ||
-      !LoadExtendedAttributes(xattrs_bucket) ||
       !LoadInfo(kernel_load_info)) {
     return FAILED_DATABASE_CORRUPT;
   }
 
   EndLoad();
   return OPENED;
 }
 
 bool DirectoryBackingStore::BeginLoad() {
   DCHECK(load_dbhandle_ == NULL);
@@ skipping 14 matching lines @@
 
 bool DirectoryBackingStore::SaveChanges(
     const Directory::SaveChangesSnapshot& snapshot) {
   sqlite3* dbhandle = LazyGetSaveHandle();
 
   // SQLTransaction::BeginExclusive causes a disk write to occur. This is not
   // something that should happen every 10 seconds when this function runs, so
   // just stop here if there's nothing to save.
   bool save_info =
     (Directory::KERNEL_SHARE_INFO_DIRTY == snapshot.kernel_info_status);
-  if (snapshot.dirty_metas.size() < 1 && snapshot.dirty_xattrs.size() < 1 &&
-      !save_info)
+  if (snapshot.dirty_metas.size() < 1 && !save_info)
     return true;
 
   SQLTransaction transaction(dbhandle);
   if (SQLITE_OK != transaction.BeginExclusive())
     return false;
 
   for (OriginalEntries::const_iterator i = snapshot.dirty_metas.begin();
        i != snapshot.dirty_metas.end(); ++i) {
     DCHECK(i->is_dirty());
     if (!SaveEntryToDB(*i))
       return false;
   }
 
-  for (ExtendedAttributes::const_iterator i = snapshot.dirty_xattrs.begin();
-       i != snapshot.dirty_xattrs.end(); ++i) {
-    DCHECK(i->second.dirty);
-    if (i->second.is_deleted) {
-      if (!DeleteExtendedAttributeFromDB(i))
-        return false;
-    } else {
-      if (!SaveExtendedAttributeToDB(i))
-        return false;
-    }
-  }
-
   if (save_info) {
     const Directory::PersistedKernelInfo& info = snapshot.kernel_info;
     SQLStatement update;
     update.prepare(dbhandle, "UPDATE share_info "
                    "SET store_birthday = ?, "
                    "next_id = ?");
     update.bind_string(0, info.store_birthday);
     update.bind_int64(1, info.next_id);
 
     if (!(SQLITE_DONE == update.step() &&
@@ skipping 47 matching lines @@
     if (MigrateVersion69To70())
       version_on_disk = 70;
   }
 
   // Version 71 changed the sync progress information to be per-datatype.
   if (version_on_disk == 70) {
     if (MigrateVersion70To71())
       version_on_disk = 71;
   }
 
+  // Version 72 removed extended attributes, a legacy way to do extensible
+  // key/value information, stored in their own table.
+  if (version_on_disk == 71) {
+    if (MigrateVersion71To72())
+      version_on_disk = 72;
+  }
+
   // If one of the migrations requested it, drop columns that aren't current.
   // It's only safe to do this after migrating all the way to the current
   // version.
   if (version_on_disk == kCurrentDBVersion && needs_column_refresh_) {
     if (!RefreshColumns())
       version_on_disk = 0;
   }
 
   // A final, alternative catch-all migration to simply re-sync everything.
   if (version_on_disk != kCurrentDBVersion) {
@@ skipping 75 matching lines @@
   base::hash_set<int64> handles;
   EntryKernel* kernel = NULL;
   int query_result;
   while (SQLITE_ROW == (query_result = UnpackEntry(&statement, &kernel))) {
     DCHECK(handles.insert(kernel->ref(META_HANDLE)).second);  // Only in debug.
     entry_bucket->insert(kernel);
   }
   return SQLITE_DONE == query_result;
 }
 
-bool DirectoryBackingStore::LoadExtendedAttributes(
-    ExtendedAttributes* xattrs_bucket) {
-  SQLStatement statement;
-  statement.prepare(
-      load_dbhandle_,
-      "SELECT metahandle, key, value FROM extended_attributes");
-  int step_result = statement.step();
-  while (SQLITE_ROW == step_result) {
-    int64 metahandle = statement.column_int64(0);
-
-    string path_string_key;
-    statement.column_string(1, &path_string_key);
-
-    ExtendedAttributeValue val;
-    statement.column_blob_as_vector(2, &(val.value));
-    val.is_deleted = false;
-
-    ExtendedAttributeKey key(metahandle, path_string_key);
-    xattrs_bucket->insert(std::make_pair(key, val));
-    step_result = statement.step();
-  }
-
-  return SQLITE_DONE == step_result;
-}
-
 bool DirectoryBackingStore::LoadInfo(Directory::KernelLoadInfo* info) {
   {
     SQLStatement query;
     query.prepare(load_dbhandle_,
                   "SELECT store_birthday, next_id, cache_guid "
                   "FROM share_info");
     if (SQLITE_ROW != query.step())
       return false;
     info->kernel_info.store_birthday = query.column_string(0);
     info->kernel_info.next_id = query.column_int64(1);
@@ skipping 47 matching lines @@
   values.append(" )");
   query.append(values);
   SQLStatement statement;
   statement.prepare(save_dbhandle_, query.c_str());
   BindFields(entry, &statement);
   return (SQLITE_DONE == statement.step() &&
           SQLITE_OK == statement.reset() &&
           1 == statement.changes());
 }
 
-bool DirectoryBackingStore::SaveExtendedAttributeToDB(
-    ExtendedAttributes::const_iterator i) {
-  DCHECK(save_dbhandle_);
-  SQLStatement insert;
-  insert.prepare(save_dbhandle_,
-                 "INSERT INTO extended_attributes "
-                 "(metahandle, key, value) "
-                 "values ( ?, ?, ? )");
-  insert.bind_int64(0, i->first.metahandle);
-  insert.bind_string(1, i->first.key);
-  insert.bind_blob(2, &i->second.value.at(0), i->second.value.size());
-  return (SQLITE_DONE == insert.step() &&
-          SQLITE_OK == insert.reset() &&
-          1 == insert.changes());
-}
-
-bool DirectoryBackingStore::DeleteExtendedAttributeFromDB(
-    ExtendedAttributes::const_iterator i) {
-  DCHECK(save_dbhandle_);
-  SQLStatement delete_attribute;
-  delete_attribute.prepare(save_dbhandle_,
-                           "DELETE FROM extended_attributes "
-                           "WHERE metahandle = ? AND key = ? ");
-  delete_attribute.bind_int64(0, i->first.metahandle);
-  delete_attribute.bind_string(1, i->first.key);
-  if (!(SQLITE_DONE == delete_attribute.step() &&
-        SQLITE_OK == delete_attribute.reset() &&
-        1 == delete_attribute.changes())) {
-    LOG(ERROR) << "DeleteExtendedAttributeFromDB(),StepDone() failed "
-        << "for metahandle: " << i->first.metahandle << " key: "
-        << i->first.key;
-    return false;
-  }
-  // The attribute may have never been saved to the database if it was
-  // created and then immediately deleted.  So don't check that we
-  // deleted exactly 1 row.
-  return true;
-}
-
 bool DirectoryBackingStore::DropDeletedEntries() {
-  static const char delete_extended_attributes[] =
-      "DELETE FROM extended_attributes WHERE metahandle IN "
-      "(SELECT metahandle from death_row)";
   static const char delete_metas[] = "DELETE FROM metas WHERE metahandle IN "
                                      "(SELECT metahandle from death_row)";
   // Put all statements into a transaction for better performance
   SQLTransaction transaction(load_dbhandle_);
   transaction.Begin();
   if (SQLITE_DONE != ExecQuery(
                          load_dbhandle_,
                          "CREATE TEMP TABLE death_row (metahandle BIGINT)")) {
     return false;
   }
   if (SQLITE_DONE != ExecQuery(load_dbhandle_,
                                "INSERT INTO death_row "
                                "SELECT metahandle from metas WHERE is_del > 0 "
                                " AND is_unsynced < 1"
                                " AND is_unapplied_update < 1")) {
     return false;
   }
-  if (SQLITE_DONE != ExecQuery(load_dbhandle_, delete_extended_attributes)) {
-    return false;
-  }
   if (SQLITE_DONE != ExecQuery(load_dbhandle_, delete_metas)) {
     return false;
   }
   if (SQLITE_DONE != ExecQuery(load_dbhandle_, "DROP TABLE death_row")) {
     return false;
   }
   transaction.Commit();
   return true;
 }
 
 int DirectoryBackingStore::SafeDropTable(const char* table_name) {
   string query = "DROP TABLE IF EXISTS ";
   query.append(table_name);
   SQLStatement statement;
   int result = statement.prepare(load_dbhandle_, query.data(),
                                  query.size());
   if (SQLITE_OK == result) {
     result = statement.step();
     if (SQLITE_DONE == result)
       statement.finalize();
   }
 
   return result;
 }
 
-int DirectoryBackingStore::CreateExtendedAttributeTable() {
-  int result = SafeDropTable("extended_attributes");
-  if (result != SQLITE_DONE)
-    return result;
-  LOG(INFO) << "CreateExtendedAttributeTable";
-  return ExecQuery(load_dbhandle_,
-                   "CREATE TABLE extended_attributes("
-                   "metahandle bigint, "
-                   "key varchar(127), "
-                   "value blob, "
-                   "PRIMARY KEY(metahandle, key) ON CONFLICT REPLACE)");
-}
-
 void DirectoryBackingStore::DropAllTables() {
   SafeDropTable("metas");
   SafeDropTable("temp_metas");
   SafeDropTable("share_info");
   SafeDropTable("temp_share_info");
   SafeDropTable("share_version");
   SafeDropTable("extended_attributes");
   SafeDropTable("models");
   needs_column_refresh_ = false;
 }
@@ skipping 226 matching lines @@
     return false;
   SafeDropTable("share_info");
   result = ExecQuery(load_dbhandle_,
       "ALTER TABLE temp_share_info RENAME TO share_info");
   if (result != SQLITE_DONE)
     return false;
   SetVersion(71);
   return true;
 }
 
+bool DirectoryBackingStore::MigrateVersion71To72() {
+  SafeDropTable("extended_attributes");
+  SetVersion(72);
+  return true;
+}
+
 int DirectoryBackingStore::CreateTables() {
   LOG(INFO) << "First run, creating tables";
   // Create two little tables share_version and share_info
   int result = ExecQuery(load_dbhandle_,
                          "CREATE TABLE share_version ("
                          "id VARCHAR(128) primary key, data INT)");
   if (result != SQLITE_DONE)
     return result;
   {
     SQLStatement statement;
@@ skipping 41 matching lines @@
     const int64 now = Now();
     SQLStatement statement;
     statement.prepare(load_dbhandle_,
                       "INSERT INTO metas "
                       "( id, metahandle, is_dir, ctime, mtime) "
                       "VALUES ( \"r\", 1, 1, ?, ?)");
     statement.bind_int64(0, now);
     statement.bind_int64(1, now);
     result = statement.step();
   }
-  if (result != SQLITE_DONE)
-    return result;
-  result = CreateExtendedAttributeTable();
   return result;
 }
 
 sqlite3* DirectoryBackingStore::LazyGetSaveHandle() {
   if (!save_dbhandle_ && !OpenAndConfigureHandleHelper(&save_dbhandle_)) {
     DCHECK(FALSE) << "Unable to open handle for saving";
     return NULL;
   }
   return save_dbhandle_;
 }
@@ skipping 32 matching lines @@
       "name TEXT, "
       "store_birthday TEXT, "
       "db_create_version TEXT, "
       "db_create_time INT, "
       "next_id INT default -2, "
       "cache_guid TEXT)");
   return ExecQuery(load_dbhandle_, query.c_str());
 }
 
 }  // namespace syncable