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

chrome/browser/sync/syncable/syncable.h

 // Copyright (c) 2009 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.
 
 #ifndef CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 #define CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 
 #include <algorithm>
 #include <bitset>
 #include <iosfwd>
@@ skipping 164 matching lines @@
 
 enum {
   BIT_TEMPS_COUNT = BIT_TEMPS_END - BIT_TEMPS_BEGIN
 };
 
 class BaseTransaction;
 class WriteTransaction;
 class ReadTransaction;
 class Directory;
 class ScopedDirLookup;
-class ExtendedAttribute;
 
 // Instead of:
 //   Entry e = transaction.GetById(id);
 // use:
 //   Entry e(transaction, GET_BY_ID, id);
 //
 // Why?  The former would require a copy constructor, and it would be difficult
 // to enforce that an entry never outlived its transaction if there were a copy
 // constructor.
 enum GetById {
@@ skipping 214 matching lines @@
   inline bool ExistsOnClientBecauseNameIsNonEmpty() const {
     DCHECK(kernel_);
     return !kernel_->ref(NON_UNIQUE_NAME).empty();
   }
 
   inline bool IsRoot() const {
     DCHECK(kernel_);
     return kernel_->ref(ID).IsRoot();
   }
 
-  void GetAllExtendedAttributes(BaseTransaction* trans,
-                                std::set<ExtendedAttribute>* result);
-  void GetExtendedAttributesList(BaseTransaction* trans,
-                                 AttributeKeySet* result);
-  // Flags all extended attributes for deletion on the next SaveChanges.
-  void DeleteAllExtendedAttributes(WriteTransaction *trans);
-
   Directory* dir() const;
 
   const EntryKernel GetKernelCopy() const {
     return *kernel_;
   }
 
 
  protected:  // Don't allow creation on heap, except by sync API wrappers.
   friend class sync_api::ReadNode;
   void* operator new(size_t size) { return (::operator new)(size); }
@@ skipping 162 matching lines @@
   // These members are only valid for CALCULATE_CHANGES.
   const OriginalEntries* originals;
   BaseTransaction* trans;
   WriterTag writer;
   typedef DirectoryChangeEvent EventType;
   static inline bool IsChannelShutdownEvent(const EventType& e) {
     return SHUTDOWN == e.todo;
   }
 };
 
-struct ExtendedAttributeKey {
-  int64 metahandle;
-  std::string key;
-  inline bool operator < (const ExtendedAttributeKey& x) const {
-    if (metahandle != x.metahandle)
-      return metahandle < x.metahandle;
-    return key.compare(x.key) < 0;
-  }
-  ExtendedAttributeKey(int64 metahandle, const std::string& key)
-      : metahandle(metahandle), key(key) {  }
-};
-
-struct ExtendedAttributeValue {
-  Blob value;
-  bool is_deleted;
-  bool dirty;
-};
-
-typedef std::map<ExtendedAttributeKey, ExtendedAttributeValue>
-    ExtendedAttributes;
-
 // A list of metahandles whose metadata should not be purged.
 typedef std::multiset<int64> Pegs;
 
 // The name Directory in this case means the entire directory
 // structure within a single user account.
 //
 // Sqlite is a little goofy, in that each thread must access a database
 // via its own handle.  So, a Directory object should only be accessed
 // from a single thread.  Use DirectoryManager's Open() method to
 // always get a directory that has been properly initialized on the
@@ skipping 14 matching lines @@
 // To prevent deadlock, the reader writer transaction lock must always
 // be held before acquiring the kernel lock.
 class ScopedKernelLock;
 class IdFilter;
 class DirectoryManager;
 struct PathMatcher;
 
 class Directory {
   friend class BaseTransaction;
   friend class Entry;
-  friend class ExtendedAttribute;
   friend class MutableEntry;
-  friend class MutableExtendedAttribute;
   friend class ReadTransaction;
   friend class ReadTransactionWithoutDB;
   friend class ScopedKernelLock;
   friend class ScopedKernelUnlock;
   friend class WriteTransaction;
   friend class SyncableDirectoryTest;
   FRIEND_TEST_ALL_PREFIXES(SyncableDirectoryTest,
                            TakeSnapshotGetsAllDirtyHandlesTest);
   FRIEND_TEST_ALL_PREFIXES(SyncableDirectoryTest,
                            TakeSnapshotGetsOnlyDirtyHandlesTest);
@@ skipping 39 matching lines @@
     KERNEL_SHARE_INFO_DIRTY
   };
 
   // When the Directory is told to SaveChanges, a SaveChangesSnapshot is
   // constructed and forms a consistent snapshot of what needs to be sent to
   // the backing store.
   struct SaveChangesSnapshot {
     KernelShareInfoStatus kernel_info_status;
     PersistedKernelInfo kernel_info;
     OriginalEntries dirty_metas;
-    ExtendedAttributes dirty_xattrs;
     SaveChangesSnapshot() : kernel_info_status(KERNEL_SHARE_INFO_INVALID) {
     }
   };
 
   Directory();
   virtual ~Directory();
 
   DirOpenResult Open(const FilePath& file_path, const std::string& name);
 
   void Close();
@@ skipping 122 matching lines @@
   // syncer should call it from its PerformSyncQueries member.
   typedef std::vector<int64> UnsyncedMetaHandles;
   void GetUnsyncedMetaHandles(BaseTransaction* trans,
                               UnsyncedMetaHandles* result);
 
   // Get all the metahandles for unapplied updates
   typedef std::vector<int64> UnappliedUpdateMetaHandles;
   void GetUnappliedUpdateMetaHandles(BaseTransaction* trans,
                                      UnappliedUpdateMetaHandles* result);
 
-  void GetAllExtendedAttributes(BaseTransaction* trans, int64 metahandle,
-                                std::set<ExtendedAttribute>* result);
-  // Get all extended attribute keys associated with a metahandle
-  void GetExtendedAttributesList(BaseTransaction* trans, int64 metahandle,
-                                 AttributeKeySet* result);
-  // Flags all extended attributes for deletion on the next SaveChanges.
-  void DeleteAllExtendedAttributes(WriteTransaction* trans, int64 metahandle);
-
   // Get the channel for post save notification, used by the syncer.
   inline Channel* channel() const {
     return kernel_->channel;
   }
 
   // Checks tree metadata consistency.
   // If full_scan is false, the function will avoid pulling any entries from the
   // db and scan entries currently in ram.
   // If full_scan is true, all entries will be pulled from the database.
   // No return value, CHECKs will be triggered if we're given bad
@@ skipping 108 matching lines @@
     // Never hold the mutex and do anything with the database or any
     // other buffered IO.  Violating this rule will result in deadlock.
     Lock mutex;
     MetahandlesIndex* metahandles_index;  // Entries indexed by metahandle
     IdsIndex* ids_index;  // Entries indexed by id
     ParentIdChildIndex* parent_id_child_index;
     ClientTagIndex* client_tag_index;
     // So we don't have to create an EntryKernel every time we want to
     // look something up in an index.  Needle in haystack metaphor.
     EntryKernel needle;
-    ExtendedAttributes* const extended_attributes;
 
     // 3 in-memory indices on bits used extremely frequently by the syncer.
     MetahandleSet* const unapplied_update_metahandles;
     MetahandleSet* const unsynced_metahandles;
     // Contains metahandles that are most likely dirty (though not
     // necessarily).  Dirtyness is confirmed in TakeSnapshotForSaveChanges().
     MetahandleSet* const dirty_metahandles;
 
     // TODO(ncarter): Figure out what the hell this is, and comment it.
     Channel* const channel;
@@ skipping 112 matching lines @@
 
 bool IsLegalNewParent(BaseTransaction* trans, const Id& id, const Id& parentid);
 int ComparePathNames(const std::string& a, const std::string& b);
 
 // Exposed in header as this is used as a sqlite3 callback.
 int ComparePathNames16(void*, int a_bytes, const void* a, int b_bytes,
                        const void* b);
 
 int64 Now();
 
-class ExtendedAttribute {
- public:
-  ExtendedAttribute(BaseTransaction* trans, GetByHandle,
-                    const ExtendedAttributeKey& key);
-  int64 metahandle() const { return i_->first.metahandle; }
-  const std::string& key() const { return i_->first.key; }
-  const Blob& value() const { return i_->second.value; }
-  bool is_deleted() const { return i_->second.is_deleted; }
-  bool good() const { return good_; }
-  bool operator < (const ExtendedAttribute& x) const {
-    return i_->first < x.i_->first;
-  }
- protected:
-  bool Init(BaseTransaction* trans,
-            Directory::Kernel* const kernel,
-            ScopedKernelLock* lock,
-            const ExtendedAttributeKey& key);
-  ExtendedAttribute() { }
-  ExtendedAttributes::iterator i_;
-  bool good_;
-};
-
-class MutableExtendedAttribute : public ExtendedAttribute {
- public:
-  MutableExtendedAttribute(WriteTransaction* trans, GetByHandle,
-                           const ExtendedAttributeKey& key);
-  MutableExtendedAttribute(WriteTransaction* trans, Create,
-                           const ExtendedAttributeKey& key);
-
-  Blob* mutable_value() {
-    i_->second.dirty = true;
-    i_->second.is_deleted = false;
-    return &(i_->second.value);
-  }
-
-  void delete_attribute() {
-    i_->second.dirty = true;
-    i_->second.is_deleted = true;
-  }
-};
-
-// Get an extended attribute from an Entry by name. Returns a pointer
-// to a const Blob containing the attribute data, or NULL if there is
-// no attribute with the given name. The pointer is valid for the
-// duration of the Entry's transaction.
-const Blob* GetExtendedAttributeValue(const Entry& e,
-                                      const std::string& attribute_name);
-
 // This function sets only the flags needed to get this entry to sync.
 void MarkForSyncing(syncable::MutableEntry* e);
 
 // This is not a reset.  It just sets the numeric fields which are not
 // initialized by the constructor to zero.
 void ZeroFields(EntryKernel* entry, int first_field);
 
 }  // namespace syncable
 
 std::ostream& operator <<(std::ostream&, const syncable::Blob&);
 
 browser_sync::FastDump& operator <<
   (browser_sync::FastDump&, const syncable::Blob&);
 
 #endif  // CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_