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

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 149 matching lines @@
 Directory::Kernel::Kernel(const FilePath& db_path,
                           const string& name,
                           const KernelLoadInfo& info)
     : db_path(db_path),
       refcount(1),
       name(name),
       metahandles_index(new Directory::MetahandlesIndex),
       ids_index(new Directory::IdsIndex),
       parent_id_child_index(new Directory::ParentIdChildIndex),
       client_tag_index(new Directory::ClientTagIndex),
-      extended_attributes(new ExtendedAttributes),
       unapplied_update_metahandles(new MetahandleSet),
       unsynced_metahandles(new MetahandleSet),
       dirty_metahandles(new MetahandleSet),
       channel(new Directory::Channel(syncable::DIRECTORY_DESTROYED)),
       info_status(Directory::KERNEL_SHARE_INFO_VALID),
       persisted_info(info.kernel_info),
       cache_guid(info.cache_guid),
       next_metahandle(info.max_metahandle + 1) {
 }
 
@@ skipping 10 matching lines @@
     delete this;
 }
 
 Directory::Kernel::~Kernel() {
   CHECK(0 == refcount);
   delete channel;
   changes_channel.Notify(kShutdownChangesEvent);
   delete unsynced_metahandles;
   delete unapplied_update_metahandles;
   delete dirty_metahandles;
-  delete extended_attributes;
   delete parent_id_child_index;
   delete client_tag_index;
   delete ids_index;
   for_each(metahandles_index->begin(), metahandles_index->end(), DeleteEntry);
   delete metahandles_index;
 }
 
 Directory::Directory() : kernel_(NULL), store_(NULL) {
 }
 
@@ skipping 35 matching lines @@
                                   const string& name) {
   DCHECK_EQ(static_cast<DirectoryBackingStore*>(NULL), store_);
   FilePath db_path(file_path);
   file_util::AbsolutePath(&db_path);
   store_ = CreateBackingStore(name, db_path);
 
   KernelLoadInfo info;
   // Temporary indices before kernel_ initialized in case Load fails. We 0(1)
   // swap these later.
   MetahandlesIndex metas_bucket;
-  ExtendedAttributes xattrs_bucket;
-  DirOpenResult result = store_->Load(&metas_bucket, &xattrs_bucket, &info);
+  DirOpenResult result = store_->Load(&metas_bucket, &info);
   if (OPENED != result)
     return result;
 
   kernel_ = new Kernel(db_path, name, info);
   kernel_->metahandles_index->swap(metas_bucket);
-  kernel_->extended_attributes->swap(xattrs_bucket);
   InitializeIndices();
   return OPENED;
 }
 
 void Directory::Close() {
   if (store_)
     delete store_;
   store_ = NULL;
   if (kernel_) {
     bool del = !base::subtle::NoBarrier_AtomicIncrement(&kernel_->refcount, -1);
@@ skipping 244 matching lines @@
     if (!entry->is_dirty())
       continue;
     snapshot->dirty_metas.insert(snapshot->dirty_metas.end(), *entry);
     DCHECK_EQ(1U, kernel_->dirty_metahandles->count(*i));
     // We don't bother removing from the index here as we blow the entire thing
     // in a moment, and it unnecessarily complicates iteration.
     entry->clear_dirty(NULL);
   }
   ClearDirtyMetahandles();
 
-  // Do the same for extended attributes.
-  for (ExtendedAttributes::iterator i = kernel_->extended_attributes->begin();
-       i != kernel_->extended_attributes->end(); ++i) {
-    if (!i->second.dirty)
-      continue;
-    snapshot->dirty_xattrs[i->first] = i->second;
-    i->second.dirty = false;
-  }
-
   // Fill kernel_info_status and kernel_info.
   snapshot->kernel_info = kernel_->persisted_info;
   // To avoid duplicates when the process crashes, we record the next_id to be
   // greater magnitude than could possibly be reached before the next save
   // changes.  In other words, it's effectively impossible for the user to
   // generate 65536 new bookmarks in 3 seconds.
   snapshot->kernel_info.next_id -= 65536;
   snapshot->kernel_info_status = kernel_->info_status;
   // This one we reset on failure.
   kernel_->info_status = KERNEL_SHARE_INFO_VALID;
@@ skipping 40 matching lines @@
       DCHECK_EQ(1u, num_erased);
       num_erased = kernel_->metahandles_index->erase(entry);
       DCHECK_EQ(1u, num_erased);
 
       // Might not be in it
       num_erased = kernel_->client_tag_index->erase(entry);
       DCHECK_EQ(entry->ref(UNIQUE_CLIENT_TAG).empty(), !num_erased);
       delete entry;
     }
   }
-
-  ExtendedAttributes::const_iterator i = snapshot.dirty_xattrs.begin();
-  while (i != snapshot.dirty_xattrs.end()) {
-    ExtendedAttributeKey key(i->first.metahandle, i->first.key);
-    ExtendedAttributes::iterator found =
-        kernel_->extended_attributes->find(key);
-    if (found == kernel_->extended_attributes->end() ||
-        found->second.dirty || !i->second.is_deleted) {
-      ++i;
-    } else {
-      kernel_->extended_attributes->erase(found);
-    }
-  }
 }
 
 void Directory::PurgeEntriesWithTypeIn(const std::set<ModelType>& types) {
   if (types.count(UNSPECIFIED) != 0U || types.count(TOP_LEVEL_FOLDER) != 0U) {
     NOTREACHED() << "Don't support purging unspecified or top level entries.";
     return;
   }
 
   if (types.empty())
     return;
@@ skipping 38 matching lines @@
   // that SaveChanges will at least try again later.
   for (OriginalEntries::const_iterator i = snapshot.dirty_metas.begin();
        i != snapshot.dirty_metas.end(); ++i) {
     kernel_->needle.put(META_HANDLE, i->ref(META_HANDLE));
     MetahandlesIndex::iterator found =
         kernel_->metahandles_index->find(&kernel_->needle);
     if (found != kernel_->metahandles_index->end()) {
       (*found)->mark_dirty(kernel_->dirty_metahandles);
     }
   }
-
-  for (ExtendedAttributes::const_iterator i = snapshot.dirty_xattrs.begin();
-       i != snapshot.dirty_xattrs.end(); ++i) {
-    ExtendedAttributeKey key(i->first.metahandle, i->first.key);
-    ExtendedAttributes::iterator found =
-        kernel_->extended_attributes->find(key);
-    if (found != kernel_->extended_attributes->end())
-      found->second.dirty = true;
-  }
 }
 
 int64 Directory::last_download_timestamp(ModelType model_type) const {
   ScopedKernelLock lock(this);
   return kernel_->persisted_info.last_download_timestamp[model_type];
 }
 
 void Directory::set_last_download_timestamp(ModelType model_type,
     int64 timestamp) {
   ScopedKernelLock lock(this);
@@ skipping 57 matching lines @@
 }
 
 void Directory::GetUnsyncedMetaHandles(BaseTransaction* trans,
                                        UnsyncedMetaHandles* result) {
   result->clear();
   ScopedKernelLock lock(this);
   copy(kernel_->unsynced_metahandles->begin(),
        kernel_->unsynced_metahandles->end(), back_inserter(*result));
 }
 
-void Directory::GetAllExtendedAttributes(BaseTransaction* trans,
-                                         int64 metahandle,
-                                         std::set<ExtendedAttribute>* result) {
-  AttributeKeySet keys;
-  GetExtendedAttributesList(trans, metahandle, &keys);
-  AttributeKeySet::iterator iter;
-  for (iter = keys.begin(); iter != keys.end(); ++iter) {
-      ExtendedAttributeKey key(metahandle, *iter);
-      ExtendedAttribute extended_attribute(trans, GET_BY_HANDLE, key);
-      CHECK(extended_attribute.good());
-      result->insert(extended_attribute);
-  }
-}
-
-void Directory::GetExtendedAttributesList(BaseTransaction* trans,
-    int64 metahandle, AttributeKeySet* result) {
-  ExtendedAttributes::iterator iter;
-  for (iter = kernel_->extended_attributes->begin();
-       iter != kernel_->extended_attributes->end(); ++iter) {
-    if (iter->first.metahandle == metahandle) {
-      if (!iter->second.is_deleted)
-        result->insert(iter->first.key);
-    }
-  }
-}
-
-void Directory::DeleteAllExtendedAttributes(WriteTransaction* trans,
-                                            int64 metahandle) {
-  AttributeKeySet keys;
-  GetExtendedAttributesList(trans, metahandle, &keys);
-  AttributeKeySet::iterator iter;
-  for (iter = keys.begin(); iter != keys.end(); ++iter) {
-    ExtendedAttributeKey key(metahandle, *iter);
-    MutableExtendedAttribute attribute(trans, GET_BY_HANDLE, key);
-    // This flags the attribute for deletion during SaveChanges.  At that time
-    // any deleted attributes are purged from disk and memory.
-    attribute.delete_attribute();
-  }
-}
-
 int64 Directory::unsynced_entity_count() const {
   ScopedKernelLock lock(this);
   return kernel_->unsynced_metahandles->size();
 }
 
 void Directory::GetUnappliedUpdateMetaHandles(BaseTransaction* trans,
     UnappliedUpdateMetaHandles* result) {
   result->clear();
   ScopedKernelLock lock(this);
   copy(kernel_->unapplied_update_metahandles->begin(),
@@ skipping 284 matching lines @@
 
 Directory* Entry::dir() const {
   return basetrans_->directory();
 }
 
 const string& Entry::Get(StringField field) const {
   DCHECK(kernel_);
   return kernel_->ref(field);
 }
 
-void Entry::GetAllExtendedAttributes(BaseTransaction* trans,
-    std::set<ExtendedAttribute> *result) {
-  dir()->GetAllExtendedAttributes(trans, kernel_->ref(META_HANDLE), result);
-}
-
-void Entry::GetExtendedAttributesList(BaseTransaction* trans,
-    AttributeKeySet* result) {
-  dir()->GetExtendedAttributesList(trans, kernel_->ref(META_HANDLE), result);
-}
-
-void Entry::DeleteAllExtendedAttributes(WriteTransaction *trans) {
-  dir()->DeleteAllExtendedAttributes(trans, kernel_->ref(META_HANDLE));
-}
-
 syncable::ModelType Entry::GetServerModelType() const {
   ModelType specifics_type = GetModelTypeFromSpecifics(Get(SERVER_SPECIFICS));
   if (specifics_type != UNSPECIFIED)
     return specifics_type;
   if (IsRoot())
     return TOP_LEVEL_FOLDER;
   // Loose check for server-created top-level folders that aren't
   // bound to a particular model type.
   if (!Get(UNIQUE_SERVER_TAG).empty() && Get(SERVER_IS_DIR))
     return TOP_LEVEL_FOLDER;
@@ skipping 362 matching lines @@
 Id Directory::GetFirstChildId(BaseTransaction* trans,
                               const Id& parent_id) {
   return GetChildWithNullIdField(PREV_ID, trans, parent_id);
 }
 
 Id Directory::GetLastChildId(BaseTransaction* trans,
                              const Id& parent_id) {
   return GetChildWithNullIdField(NEXT_ID, trans, parent_id);
 }
 
-ExtendedAttribute::ExtendedAttribute(BaseTransaction* trans, GetByHandle,
-                                     const ExtendedAttributeKey& key) {
-  Directory::Kernel* const kernel = trans->directory()->kernel_;
-  ScopedKernelLock lock(trans->directory());
-  Init(trans, kernel, &lock, key);
-}
-
-bool ExtendedAttribute::Init(BaseTransaction* trans,
-                             Directory::Kernel* const kernel,
-                             ScopedKernelLock* lock,
-                             const ExtendedAttributeKey& key) {
-  i_ = kernel->extended_attributes->find(key);
-  good_ = kernel->extended_attributes->end() != i_;
-  return good_;
-}
-
-MutableExtendedAttribute::MutableExtendedAttribute(
-    WriteTransaction* trans, GetByHandle,
-    const ExtendedAttributeKey& key) :
-        ExtendedAttribute(trans, GET_BY_HANDLE, key) {
-}
-
-MutableExtendedAttribute::MutableExtendedAttribute(
-    WriteTransaction* trans, Create, const ExtendedAttributeKey& key) {
-  Directory::Kernel* const kernel = trans->directory()->kernel_;
-  ScopedKernelLock lock(trans->directory());
-  if (!Init(trans, kernel, &lock, key)) {
-    ExtendedAttributeValue val;
-    val.is_deleted = false;
-    val.dirty = true;
-    i_ = kernel->extended_attributes->insert(std::make_pair(key, val)).first;
-    good_ = true;
-  }
-}
-
 bool IsLegalNewParent(BaseTransaction* trans, const Id& entry_id,
                       const Id& new_parent_id) {
   if (entry_id.IsRoot())
     return false;
   // we have to ensure that the entry is not an ancestor of the new parent.
   Id ancestor_id = new_parent_id;
   while (!ancestor_id.IsRoot()) {
     if (entry_id == ancestor_id)
       return false;
     Entry new_parent(trans, GET_BY_ID, ancestor_id);
     CHECK(new_parent.good());
     ancestor_id = new_parent.Get(PARENT_ID);
   }
   return true;
 }
 
-const Blob* GetExtendedAttributeValue(const Entry& e,
-                                      const string& attribute_name) {
-  ExtendedAttributeKey key(e.Get(META_HANDLE), attribute_name);
-  ExtendedAttribute extended_attribute(e.trans(), GET_BY_HANDLE, key);
-  if (extended_attribute.good() && !extended_attribute.is_deleted())
-    return &extended_attribute.value();
-  return NULL;
-}
-
 // This function sets only the flags needed to get this entry to sync.
 void MarkForSyncing(syncable::MutableEntry* e) {
   DCHECK_NE(static_cast<MutableEntry*>(NULL), e);
   DCHECK(!e->IsRoot()) << "We shouldn't mark a permanent object for syncing.";
   e->Put(IS_UNSYNCED, true);
   e->Put(SYNCING, false);
 }
 
 }  // namespace syncable
 
@@ skipping 75 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;
 }