[Sync] Add history delete directive type

sync/internal_api/sync_encryption_handler_impl.cc

 // Copyright (c) 2012 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 "sync/internal_api/sync_encryption_handler_impl.h"
 
 #include <queue>
 #include <string>
 
 #include "base/base64.h"
@@ skipping 79 matching lines @@
     case IMPLICIT_PASSPHRASE:
       return sync_pb::NigoriSpecifics::IMPLICIT_PASSPHRASE;
     case KEYSTORE_PASSPHRASE:
       return sync_pb::NigoriSpecifics::KEYSTORE_PASSPHRASE;
     case CUSTOM_PASSPHRASE:
       return sync_pb::NigoriSpecifics::CUSTOM_PASSPHRASE;
     case FROZEN_IMPLICIT_PASSPHRASE:
       return sync_pb::NigoriSpecifics::FROZEN_IMPLICIT_PASSPHRASE;
     default:
       NOTREACHED();
-      return sync_pb::NigoriSpecifics::IMPLICIT_PASSPHRASE;;
+      return sync_pb::NigoriSpecifics::IMPLICIT_PASSPHRASE;
   };
 }
 
 bool IsExplicitPassphrase(PassphraseType type) {
   return type == CUSTOM_PASSPHRASE || type == FROZEN_IMPLICIT_PASSPHRASE;
 }
 
 }  // namespace
 
 SyncEncryptionHandlerImpl::Vault::Vault(
@@ skipping 776 matching lines @@
   }
 }
 
 bool SyncEncryptionHandlerImpl::UpdateEncryptedTypesFromNigori(
     const sync_pb::NigoriSpecifics& nigori,
     syncable::BaseTransaction* const trans) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ModelTypeSet* encrypted_types = &UnlockVaultMutable(trans)->encrypted_types;
   if (nigori.encrypt_everything()) {
     EnableEncryptEverythingImpl(trans);
-    DCHECK(encrypted_types->Equals(UserTypes()));
+    DCHECK(encrypted_types->Equals(EncryptableUserTypes()));
     return true;
   } else if (encrypt_everything_) {
-    DCHECK(encrypted_types->Equals(UserTypes()));
+    DCHECK(encrypted_types->Equals(EncryptableUserTypes()));
     return false;
   }
 
   ModelTypeSet nigori_encrypted_types;
   nigori_encrypted_types = syncable::GetEncryptedTypesFromNigori(nigori);
   nigori_encrypted_types.PutAll(SensitiveTypes());
 
   // If anything more than the sensitive types were encrypted, and
   // encrypt_everything is not explicitly set to false, we assume it means
   // a client intended to enable encrypt everything.
   if (!nigori.has_encrypt_everything() &&
       !Difference(nigori_encrypted_types, SensitiveTypes()).Empty()) {
     if (!encrypt_everything_) {
       encrypt_everything_ = true;
-      *encrypted_types = UserTypes();
+      *encrypted_types = EncryptableUserTypes();
       FOR_EACH_OBSERVER(
           Observer, observers_,
           OnEncryptedTypesChanged(*encrypted_types, encrypt_everything_));
     }
-    DCHECK(encrypted_types->Equals(UserTypes()));
+    DCHECK(encrypted_types->Equals(EncryptableUserTypes()));
     return false;
   }
 
   MergeEncryptedTypes(nigori_encrypted_types, trans);
   return encrypted_types->Equals(nigori_encrypted_types);
 }
 
 void SyncEncryptionHandlerImpl::SetCustomPassphrase(
     const std::string& passphrase,
     WriteTransaction* trans,
@@ skipping 156 matching lines @@
   // redundant. Figure out a way to not do this unnecessarily.
   ReEncryptEverything(trans);
 }
 
 void SyncEncryptionHandlerImpl::MergeEncryptedTypes(
     ModelTypeSet new_encrypted_types,
     syncable::BaseTransaction* const trans) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Only UserTypes may be encrypted.
-  DCHECK(UserTypes().HasAll(new_encrypted_types));
+  DCHECK(EncryptableUserTypes().HasAll(new_encrypted_types));
 
   ModelTypeSet* encrypted_types = &UnlockVaultMutable(trans)->encrypted_types;
   if (!encrypted_types->HasAll(new_encrypted_types)) {
     *encrypted_types = new_encrypted_types;
     FOR_EACH_OBSERVER(
         Observer, observers_,
         OnEncryptedTypesChanged(*encrypted_types, encrypt_everything_));
   }
 }
 
@@ skipping 174 matching lines @@
   cryptographer->InstallKeys(keybag);
   if (update_default)
     cryptographer->SetDefaultKey(keybag.key_name());
   return true;
 }
 
 void SyncEncryptionHandlerImpl::EnableEncryptEverythingImpl(
     syncable::BaseTransaction* const trans) {
   ModelTypeSet* encrypted_types = &UnlockVaultMutable(trans)->encrypted_types;
   if (encrypt_everything_) {
-    DCHECK(encrypted_types->Equals(UserTypes()));
+    DCHECK(encrypted_types->Equals(EncryptableUserTypes()));
     return;
   }
   encrypt_everything_ = true;
-  *encrypted_types = UserTypes();
+  *encrypted_types = EncryptableUserTypes();
   FOR_EACH_OBSERVER(
       Observer, observers_,
       OnEncryptedTypesChanged(*encrypted_types, encrypt_everything_));
 }
 
 bool SyncEncryptionHandlerImpl::DecryptPendingKeysWithKeystoreKey(
     const std::string& keystore_key,
     const sync_pb::EncryptedData& keystore_decryptor_token,
     Cryptographer* cryptographer) {
   DCHECK(cryptographer->has_pending_keys());
@@ skipping 41 matching lines @@
 
 base::Time SyncEncryptionHandlerImpl::GetExplicitPassphraseTime() const {
   if (passphrase_type_ == FROZEN_IMPLICIT_PASSPHRASE)
     return migration_time();
   else if (passphrase_type_ == CUSTOM_PASSPHRASE)
     return custom_passphrase_time();
   return base::Time();
 }
 
 }  // namespace browser_sync