[Sync] Initial support for encrypting any datatype (no UI hookup yet).

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 20 matching lines @@
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/perftimer.h"
 #include "base/scoped_ptr.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stl_util-inl.h"
 #include "base/time.h"
 #include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/engine/syncer_util.h"
-#include "chrome/browser/sync/protocol/autofill_specifics.pb.h"
-#include "chrome/browser/sync/protocol/bookmark_specifics.pb.h"
-#include "chrome/browser/sync/protocol/password_specifics.pb.h"
-#include "chrome/browser/sync/protocol/preference_specifics.pb.h"
 #include "chrome/browser/sync/protocol/service_constants.h"
 #include "chrome/browser/sync/protocol/theme_specifics.pb.h"
 #include "chrome/browser/sync/protocol/typed_url_specifics.pb.h"
 #include "chrome/browser/sync/syncable/directory_backing_store.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/syncable-inl.h"
 #include "chrome/browser/sync/syncable/syncable_changes_version.h"
 #include "chrome/browser/sync/syncable/syncable_columns.h"
 #include "chrome/browser/sync/util/crypto_helpers.h"
 #include "chrome/common/deprecated/event_sys-inl.h"
@@ skipping 165 matching lines @@
 void Directory::Kernel::AddRef() {
   base::subtle::NoBarrier_AtomicIncrement(&refcount, 1);
 }
 
 void Directory::Kernel::Release() {
   if (!base::subtle::NoBarrier_AtomicIncrement(&refcount, -1))
     delete this;
 }
 
 Directory::Kernel::~Kernel() {
-  CHECK(0 == refcount);
+  CHECK_EQ(0, refcount);
   delete channel;
   changes_channel.Notify(kShutdownChangesEvent);
   delete unsynced_metahandles;
   delete unapplied_update_metahandles;
   delete dirty_metahandles;
   delete metahandles_to_purge;
   delete parent_id_child_index;
   delete client_tag_index;
   delete ids_index;
   STLDeleteElements(metahandles_index);
@@ skipping 242 matching lines @@
   entry->put(IS_DEL, false);
   entry->mark_dirty(kernel_->dirty_metahandles);
   CHECK(kernel_->parent_id_child_index->insert(entry).second);
 }
 
 void Directory::Delete(EntryKernel* const entry) {
   DCHECK(!entry->ref(IS_DEL));
   entry->put(IS_DEL, true);
   entry->mark_dirty(kernel_->dirty_metahandles);
   ScopedKernelLock lock(this);
-  CHECK(1 == kernel_->parent_id_child_index->erase(entry));
+  CHECK_EQ(1U, 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));
+  CHECK_EQ(1U, kernel_->ids_index->erase(entry));
   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->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));
+  CHECK_EQ(1U, kernel_->parent_id_child_index->erase(entry));
   entry->put(PARENT_ID, new_parent_id);
   CHECK(kernel_->parent_id_child_index->insert(entry).second);
 }
 
 void Directory::ClearDirtyMetahandles() {
   kernel_->transaction_mutex.AssertAcquired();
   kernel_->dirty_metahandles->clear();
 }
 
 bool Directory::SafeToPurgeFromMemory(const EntryKernel* const entry) const {
   bool safe = entry->ref(IS_DEL) && !entry->is_dirty() &&
       !entry->ref(SYNCING) && !entry->ref(IS_UNAPPLIED_UPDATE) &&
       !entry->ref(IS_UNSYNCED);
 
   if (safe) {
     int64 handle = entry->ref(META_HANDLE);
-    CHECK(kernel_->dirty_metahandles->count(handle) == 0);
+    CHECK_EQ(kernel_->dirty_metahandles->count(handle), 0U);
     // TODO(tim): Bug 49278.
     CHECK(!kernel_->unsynced_metahandles->count(handle));
     CHECK(!kernel_->unapplied_update_metahandles->count(handle));
   }
 
   return safe;
 }
 
 void Directory::TakeSnapshotForSaveChanges(SaveChangesSnapshot* snapshot) {
   ReadTransaction trans(this, __FILE__, __LINE__);
@@ skipping 447 matching lines @@
       while (!parentid.IsRoot()) {
         if (!idfilter.ShouldConsider(parentid))
           break;
         Entry parent(trans, GET_BY_ID, parentid);
         CHECK(parent.good()) << e;
         CHECK(parent.Get(IS_DIR)) << parent << e;
         CHECK(!parent.Get(IS_DEL)) << parent << e;
         CHECK(handles.end() != handles.find(parent.Get(META_HANDLE)))
             << e << parent;
         parentid = parent.Get(PARENT_ID);
-        CHECK(--safety_count >= 0) << e << parent;
+        CHECK_GE(--safety_count, 0) << e << parent;
       }
     }
     int64 base_version = e.Get(BASE_VERSION);
     int64 server_version = e.Get(SERVER_VERSION);
     bool using_unique_client_tag = !e.Get(UNIQUE_CLIENT_TAG).empty();
     if (CHANGES_VERSION == base_version || 0 == base_version) {
       if (e.Get(IS_UNAPPLIED_UPDATE)) {
         // Must be a new item, or a de-duplicated unique client tag
         // that was created both locally and remotely.
         if (!using_unique_client_tag) {
           CHECK(e.Get(IS_DEL)) << e;
         }
         // It came from the server, so it must have a server ID.
         CHECK(id.ServerKnows()) << e;
       } else {
         if (e.Get(IS_DIR)) {
           // TODO(chron): Implement this mode if clients ever need it.
           // For now, you can't combine a client tag and a directory.
           CHECK(!using_unique_client_tag) << e;
         }
         // Should be an uncomitted item, or a successfully deleted one.
         if (!e.Get(IS_DEL)) {
           CHECK(e.Get(IS_UNSYNCED)) << e;
         }
         // If the next check failed, it would imply that an item exists
         // on the server, isn't waiting for application locally, but either
         // is an unsynced create or a sucessful delete in the local copy.
         // Either way, that's a mismatch.
-        CHECK(0 == server_version) << e;
+        CHECK_EQ(0, server_version) << e;
         // Items that aren't using the unique client tag should have a zero
         // base version only if they have a local ID.  Items with unique client
         // tags are allowed to use the zero base version for undeletion and
         // de-duplication; the unique client tag trumps the server ID.
         if (!using_unique_client_tag) {
           CHECK(!id.ServerKnows()) << e;
         }
       }
     } else {
       CHECK(id.ServerKnows());
@@ skipping 219 matching lines @@
   // 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;
 
   // Otherwise, we don't have a server type yet.  That should only happen
   // if the item is an uncommitted locally created item.
   // It's possible we'll need to relax these checks in the future; they're
   // just here for now as a safety measure.
   DCHECK(Get(IS_UNSYNCED));
-  DCHECK(Get(SERVER_VERSION) == 0);
+  DCHECK_EQ(Get(SERVER_VERSION), 0);
   DCHECK(Get(SERVER_IS_DEL));
   // Note: can't enforce !Get(ID).ServerKnows() here because that could
   // actually happen if we hit AttemptReuniteLostCommitResponses.
   return UNSPECIFIED;
 }
 
 syncable::ModelType Entry::GetModelType() const {
   ModelType specifics_type = GetModelTypeFromSpecifics(Get(SPECIFICS));
   if (specifics_type != UNSPECIFIED)
     return specifics_type;
@@ skipping 210 matching lines @@
     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)));
+      CHECK_EQ(1U, index->erase(kernel_->ref(META_HANDLE)));
     kernel_->put(field, value);
     kernel_->mark_dirty(dir()->kernel_->dirty_metahandles);
   }
   return true;
 }
 
 void MutableEntry::UnlinkFromOrder() {
   ScopedKernelLock lock(dir());
   dir()->UnlinkEntryFromOrder(kernel_, write_transaction(), &lock);
 }
@@ skipping 192 matching lines @@
 }
 
 std::ostream& operator<<(std::ostream& s, const Blob& blob) {
   for (Blob::const_iterator i = blob.begin(); i != blob.end(); ++i)
     s << std::hex << std::setw(2)
       << std::setfill('0') << static_cast<unsigned int>(*i);
   return s << std::dec;
 }
 
 }  // namespace syncable