EntryKernel: change from assignable refs to puts.

chrome/browser/sync/syncable/syncable.cc

 // 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.
 
 #include "chrome/browser/sync/syncable/syncable.h"
 
 #include "build/build_config.h"
 
 #include <sys/stat.h>
 #if defined(OS_POSIX)
@@ skipping 259 matching lines @@
 
 EntryKernel* Directory::GetEntryById(const Id& id) {
   ScopedKernelLock lock(this);
   return GetEntryById(id, &lock);
 }
 
 EntryKernel* Directory::GetEntryById(const Id& id,
                                      ScopedKernelLock* const lock) {
   DCHECK(kernel_);
   // First look up in memory
-  kernel_->needle.ref(ID) = id;
+  kernel_->needle.put(ID, id);
   IdsIndex::iterator id_found = kernel_->ids_index->find(&kernel_->needle);
   if (id_found != kernel_->ids_index->end()) {
     // Found it in memory.  Easy.
     return *id_found;
   }
   return NULL;
 }
 
 EntryKernel* Directory::GetEntryByTag(const string& tag) {
   ScopedKernelLock lock(this);
@@ skipping 13 matching lines @@
 }
 
 EntryKernel* Directory::GetEntryByHandle(const int64 metahandle) {
   ScopedKernelLock lock(this);
   return GetEntryByHandle(metahandle, &lock);
 }
 
 EntryKernel* Directory::GetEntryByHandle(const int64 metahandle,
                                          ScopedKernelLock* lock) {
   // Look up in memory
-  kernel_->needle.ref(META_HANDLE) = metahandle;
+  kernel_->needle.put(META_HANDLE, metahandle);
   MetahandlesIndex::iterator found =
     kernel_->metahandles_index->find(&kernel_->needle);
   if (found != kernel_->metahandles_index->end()) {
     // Found it in memory.  Easy.
     return *found;
   }
   return NULL;
 }
 
 // An interface to specify the details of which children
@@ skipping 10 matching lines @@
   EntryKernel needle_;
 };
 
 // Matches all children.
 // TODO(chron): Unit test this by itself
 struct AllPathsMatcher : public PathMatcher {
   explicit AllPathsMatcher(const Id& parent_id) : PathMatcher(parent_id) {
   }
 
   virtual Index::iterator lower_bound(Index* index) {
-    needle_.ref(PARENT_ID) = parent_id_;
-    needle_.ref(META_HANDLE) = std::numeric_limits<int64>::min();
+    needle_.put(PARENT_ID, parent_id_);
+    needle_.put(META_HANDLE, std::numeric_limits<int64>::min());
     return index->lower_bound(&needle_);
   }
 
   virtual Index::iterator upper_bound(Index* index) {
-    needle_.ref(PARENT_ID) = parent_id_;
-    needle_.ref(META_HANDLE) = std::numeric_limits<int64>::max();
+    needle_.put(PARENT_ID, parent_id_);
+    needle_.put(META_HANDLE, std::numeric_limits<int64>::max());
     return index->upper_bound(&needle_);
   }
 };
 
 void Directory::GetChildHandles(BaseTransaction* trans, const Id& parent_id,
                                 Directory::ChildHandles* result) {
   AllPathsMatcher matcher(parent_id);
   return GetChildHandlesImpl(trans, parent_id, &matcher, result);
 }
 
@@ skipping 21 matching lines @@
 
 EntryKernel* Directory::GetRootEntry() {
   return GetEntryById(Id());
 }
 
 void ZeroFields(EntryKernel* entry, int first_field) {
   int i = first_field;
   // Note that bitset<> constructor sets all bits to zero, and strings
   // initialize to empty.
   for ( ; i < INT64_FIELDS_END; ++i)
-    entry->ref(static_cast<Int64Field>(i)) = 0;
+    entry->put(static_cast<Int64Field>(i), 0);
   for ( ; i < ID_FIELDS_END; ++i)
-    entry->ref(static_cast<IdField>(i)).Clear();
+    entry->mutable_ref(static_cast<IdField>(i)).Clear();
   for ( ; i < BIT_FIELDS_END; ++i)
-    entry->ref(static_cast<BitField>(i)) = false;
+    entry->put(static_cast<BitField>(i), false);
   if (i < BLOB_FIELDS_END)
     i = BLOB_FIELDS_END;
 }
 
 void Directory::InsertEntry(EntryKernel* entry) {
   ScopedKernelLock lock(this);
   InsertEntry(entry, &lock);
 }
 
 void Directory::InsertEntry(EntryKernel* entry, ScopedKernelLock* lock) {
   DCHECK(NULL != lock);
   CHECK(NULL != entry);
   static const char error[] = "Entry already in memory index.";
   CHECK(kernel_->metahandles_index->insert(entry).second) << error;
 
   if (!entry->ref(IS_DEL)) {
     CHECK(kernel_->parent_id_child_index->insert(entry).second) << error;
   }
   CHECK(kernel_->ids_index->insert(entry).second) << error;
 }
 
 void Directory::Undelete(EntryKernel* const entry) {
   DCHECK(entry->ref(IS_DEL));
   ScopedKernelLock lock(this);
-  entry->ref(IS_DEL) = false;
+  entry->put(IS_DEL, false);
   entry->mark_dirty();
   CHECK(kernel_->parent_id_child_index->insert(entry).second);
 }
 
 void Directory::Delete(EntryKernel* const entry) {
   DCHECK(!entry->ref(IS_DEL));
-  entry->ref(IS_DEL) = true;
+  entry->put(IS_DEL, true);
   entry->mark_dirty();
   ScopedKernelLock lock(this);
   CHECK(1 == kernel_->parent_id_child_index->erase(entry));
 }
 
 bool Directory::ReindexId(EntryKernel* const entry, const Id& new_id) {
   ScopedKernelLock lock(this);
   if (NULL != GetEntryById(new_id, &lock))
     return false;
   CHECK(1 == kernel_->ids_index->erase(entry));
-  entry->ref(ID) = new_id;
+  entry->put(ID, new_id);
   CHECK(kernel_->ids_index->insert(entry).second);
   return true;
 }
 
 void Directory::ReindexParentId(EntryKernel* const entry,
                                 const Id& new_parent_id) {
 
   ScopedKernelLock lock(this);
   if (entry->ref(IS_DEL)) {
-    entry->ref(PARENT_ID) = new_parent_id;
+    entry->put(PARENT_ID, new_parent_id);
     return;
   }
 
   if (entry->ref(PARENT_ID) == new_parent_id) {
     return;
   }
 
   CHECK(1 == kernel_->parent_id_child_index->erase(entry));
-  entry->ref(PARENT_ID) = new_parent_id;
+  entry->put(PARENT_ID, new_parent_id);
   CHECK(kernel_->parent_id_child_index->insert(entry).second);
 }
 
 // static
 bool Directory::SafeToPurgeFromMemory(const EntryKernel* const entry) {
   return entry->ref(IS_DEL) && !entry->is_dirty() && !entry->ref(SYNCING) &&
          !entry->ref(IS_UNAPPLIED_UPDATE) && !entry->ref(IS_UNSYNCED);
 }
 
 void Directory::TakeSnapshotForSaveChanges(SaveChangesSnapshot* snapshot) {
@@ skipping 54 matching lines @@
 }
 
 void Directory::VacuumAfterSaveChanges(const SaveChangesSnapshot& snapshot) {
   // Need a write transaction as we are about to permanently purge entries.
   WriteTransaction trans(this, VACUUM_AFTER_SAVE, __FILE__, __LINE__);
   ScopedKernelLock lock(this);
   kernel_->flushed_metahandles_.Push(0);  // Begin flush marker
   // Now drop everything we can out of memory.
   for (OriginalEntries::const_iterator i = snapshot.dirty_metas.begin();
        i != snapshot.dirty_metas.end(); ++i) {
-    kernel_->needle.ref(META_HANDLE) = i->ref(META_HANDLE);
+    kernel_->needle.put(META_HANDLE, i->ref(META_HANDLE));
     MetahandlesIndex::iterator found =
         kernel_->metahandles_index->find(&kernel_->needle);
     EntryKernel* entry = (found == kernel_->metahandles_index->end() ?
                           NULL : *found);
     if (entry && SafeToPurgeFromMemory(entry)) {
       // We now drop deleted metahandles that are up to date on both the client
       // and the server.
       size_t num_erased = 0;
       kernel_->flushed_metahandles_.Push(entry->ref(META_HANDLE));
       num_erased = kernel_->ids_index->erase(entry);
@@ skipping 22 matching lines @@
   ScopedKernelLock lock(this);
   kernel_->info_status_ = KERNEL_SHARE_INFO_DIRTY;
 
   // Because we optimistically cleared the dirty bit on the real entries when
   // taking the snapshot, we must restore it on failure.  Not doing this could
   // cause lost data, if no other changes are made to the in-memory entries
   // that would cause the dirty bit to get set again. Setting the bit ensures
   // 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.ref(META_HANDLE) = i->ref(META_HANDLE);
+    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();
     }
   }
 
   for (ExtendedAttributes::const_iterator i = snapshot.dirty_xattrs.begin();
        i != snapshot.dirty_xattrs.end(); ++i) {
     ExtendedAttributeKey key(i->first.metahandle, i->first.key);
@@ skipping 418 matching lines @@
       write_transaction_(trans) {
   Init(trans, parent_id, name);
 }
 
 
 void MutableEntry::Init(WriteTransaction* trans, const Id& parent_id,
                         const string& name) {
   kernel_ = new EntryKernel;
   ZeroFields(kernel_, BEGIN_FIELDS);
   kernel_->mark_dirty();
-  kernel_->ref(ID) = trans->directory_->NextId();
-  kernel_->ref(META_HANDLE) = trans->directory_->NextMetahandle();
-  kernel_->ref(PARENT_ID) = parent_id;
-  kernel_->ref(NON_UNIQUE_NAME) = name;
+  kernel_->put(ID, trans->directory_->NextId());
+  kernel_->put(META_HANDLE, trans->directory_->NextMetahandle());
+  kernel_->put(PARENT_ID, parent_id);
+  kernel_->put(NON_UNIQUE_NAME, name);
   const int64 now = Now();
-  kernel_->ref(CTIME) = now;
-  kernel_->ref(MTIME) = now;
+  kernel_->put(CTIME, now);
+  kernel_->put(MTIME, now);
   // We match the database defaults here
-  kernel_->ref(BASE_VERSION) = CHANGES_VERSION;
+  kernel_->put(BASE_VERSION, CHANGES_VERSION);
   trans->directory()->InsertEntry(kernel_);
   // Because this entry is new, it was originally deleted.
-  kernel_->ref(IS_DEL) = true;
+  kernel_->put(IS_DEL, true);
   trans->SaveOriginal(kernel_);
-  kernel_->ref(IS_DEL) = false;
+  kernel_->put(IS_DEL, false);
 }
 
 MutableEntry::MutableEntry(WriteTransaction* trans, CreateNewUpdateItem,
                            const Id& id)
   : Entry(trans), write_transaction_(trans) {
   Entry same_id(trans, GET_BY_ID, id);
   if (same_id.good()) {
     kernel_ = NULL;  // already have an item with this ID.
     return;
   }
   kernel_ = new EntryKernel;
   ZeroFields(kernel_, BEGIN_FIELDS);
-  kernel_->ref(ID) = id;
+  kernel_->put(ID, id);
   kernel_->mark_dirty();
-  kernel_->ref(META_HANDLE) = trans->directory_->NextMetahandle();
-  kernel_->ref(IS_DEL) = true;
+  kernel_->put(META_HANDLE, trans->directory_->NextMetahandle());
+  kernel_->put(IS_DEL, true);
   // We match the database defaults here
-  kernel_->ref(BASE_VERSION) = CHANGES_VERSION;
+  kernel_->put(BASE_VERSION, CHANGES_VERSION);
   trans->directory()->InsertEntry(kernel_);
   trans->SaveOriginal(kernel_);
 }
 
 MutableEntry::MutableEntry(WriteTransaction* trans, GetById, const Id& id)
   : Entry(trans, GET_BY_ID, id), write_transaction_(trans) {
   trans->SaveOriginal(kernel_);
 }
 
 MutableEntry::MutableEntry(WriteTransaction* trans, GetByHandle,
@@ skipping 14 matching lines @@
   } else {
     dir()->Undelete(kernel_);
     PutPredecessor(Id());  // Restores position to the 0th index.
     return true;
   }
 }
 
 bool MutableEntry::Put(Int64Field field, const int64& value) {
   DCHECK(kernel_);
   if (kernel_->ref(field) != value) {
-    kernel_->ref(field) = value;
+    kernel_->put(field, value);
     kernel_->mark_dirty();
   }
   return true;
 }
 
 bool MutableEntry::Put(IdField field, const Id& value) {
   DCHECK(kernel_);
   if (kernel_->ref(field) != value) {
     if (ID == field) {
       if (!dir()->ReindexId(kernel_, value))
         return false;
     } else if (PARENT_ID == field) {
       dir()->ReindexParentId(kernel_, value);
       PutPredecessor(Id());
     } else {
-      kernel_->ref(field) = value;
+      kernel_->put(field, value);
     }
     kernel_->mark_dirty();
   }
   return true;
 }
 
 bool MutableEntry::Put(BaseVersion field, int64 value) {
   DCHECK(kernel_);
   if (kernel_->ref(field) != value) {
-    kernel_->ref(field) = value;
+    kernel_->put(field, value);
     kernel_->mark_dirty();
   }
   return true;
 }
 
 bool MutableEntry::Put(StringField field, const string& value) {
   return PutImpl(field, value);
 }
 
 bool MutableEntry::PutImpl(StringField field, const string& value) {
   DCHECK(kernel_);
   if (kernel_->ref(field) != value) {
-    kernel_->ref(field) = value;
+    kernel_->put(field, value);
     kernel_->mark_dirty();
   }
   return true;
 }
 
 bool MutableEntry::Put(IndexedBitField field, bool value) {
   DCHECK(kernel_);
   if (kernel_->ref(field) != value) {
     MetahandleSet* index;
     if (IS_UNSYNCED == field)
       index = dir()->kernel_->unsynced_metahandles;
     else
       index = dir()->kernel_->unapplied_update_metahandles;
 
     ScopedKernelLock lock(dir());
     if (value)
       CHECK(index->insert(kernel_->ref(META_HANDLE)).second);
     else
       CHECK(1 == index->erase(kernel_->ref(META_HANDLE)));
-    kernel_->ref(field) = value;
+    kernel_->put(field, value);
     kernel_->mark_dirty();
   }
   return true;
 }
 
 void MutableEntry::UnlinkFromOrder() {
   Id old_previous = Get(PREV_ID);
   Id old_next = Get(NEXT_ID);
 
   // Self-looping signifies that this item is not in the order.  If we were to
@@ skipping 259 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;
 }