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

chrome/browser/sync/syncable/syncable.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 #define CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 #pragma once
 
 #include <algorithm>
 #include <bitset>
@@ skipping 773 matching lines @@
   void Delete(EntryKernel* const entry);
   void UnlinkEntryFromOrder(EntryKernel* entry,
                             WriteTransaction* trans,
                             ScopedKernelLock* lock);
 
   // Overridden by tests.
   virtual DirectoryBackingStore* CreateBackingStore(
       const std::string& dir_name,
       const FilePath& backing_filepath);
 
+  // Update this directory's set of encrypted datatypes.
+  // Note: |types| should be a complete set of all datatypes that require
+  // encryption, not just a subset. This does not actually perform any
+  // encryption or modify the Nigori node.
+  void SetEncryptedDataTypes(const ModelTypeSet& encrypted_types);
+
  private:
   // These private versions expect the kernel lock to already be held
   // before calling.
   EntryKernel* GetEntryById(const Id& id, ScopedKernelLock* const lock);
 
   DirOpenResult OpenImpl(const FilePath& file_path, const std::string& name);
 
   template <class T> void TestAndSet(T* kernel_data, const T* data_to_set);
 
   struct DirectoryEventTraits {
@@ skipping 210 matching lines @@
     // unique server IDs. No need to lock, only written at init time.
     std::string cache_guid;
 
     // It doesn't make sense for two threads to run SaveChanges at the same
     // time; this mutex protects that activity.
     base::Lock save_changes_mutex;
 
     // The next metahandle is protected by kernel mutex.
     int64 next_metahandle;
 
+    // The set of all datatypes that currently require encryption. This is
+    // set when we load the nigori node and modified anytime we either receive
+    // a change to the nigori node or through the local user changing the
+    // encryption status.
+    ModelTypeSet encrypted_datatypes;

[tim (not reviewing), 2011/02/11 06:52:31]

Why do we store this in 3 places again?  The fact that we have to keep 3
replicas in sync freaks me out :(  Can we eliminate at least one of them?
Reading the nigori node is pretty quick...

[Nicolas Zea, 2011/02/14 21:18:41]

Done.

+
     // Keep a history of recently flushed metahandles for debugging
     // purposes.  Protected by the save_changes_mutex.
     DebugQueue<int64, 1000> flushed_metahandles;
   };
 
   Kernel* kernel_;
 
   DirectoryBackingStore* store_;
 };
 
 class ScopedKernelLock {
  public:
   explicit ScopedKernelLock(const Directory*);
   ~ScopedKernelLock() {}
 
   base::AutoLock scoped_lock_;
   Directory* const dir_;
   DISALLOW_COPY_AND_ASSIGN(ScopedKernelLock);
 };
 
 // Transactions are now processed FIFO with a straight lock
 class BaseTransaction {
   friend class Entry;
  public:
   inline Directory* directory() const { return directory_; }
   inline Id root_id() const { return Id(); }
 
+  inline const ModelTypeSet& GetEncryptedDatatypes() {
+    return dirkernel_->encrypted_datatypes;
+  }
+
   virtual ~BaseTransaction();
 
+  // Update this transaction's directory's set of encrypted datatypes.
+  // Note: |encrypted_types| should be a complete set of all datatypes that
+  // require encryption, not just a subset. This does not actually perform any
+  // encryption or modify the Nigori node.
+  void SetEncryptedDataTypes(const ModelTypeSet& encrypted_types);

[tim (not reviewing), 2011/02/11 06:52:31]

Why have get/set operations on the transaction when you can get the directory,
which is where these forward to?

[Nicolas Zea, 2011/02/14 21:18:41]

Done.

+
  protected:
   BaseTransaction(Directory* directory, const char* name,
                   const char* source_file, int line, WriterTag writer);
 
   // For unit testing. Everything will be mocked out no point initializing.
   explicit BaseTransaction(Directory* directory);
 
   void UnlockAndLog(OriginalEntries* entries);
   bool NotifyTransactionChangingAndEnding(OriginalEntries* entries);
   virtual void NotifyTransactionComplete();
@@ skipping 67 matching lines @@
 
 // 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&);
 
 #endif  // CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_