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

chrome/browser/sync/profile_sync_service_harness.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/profile_sync_service_harness.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/message_loop.h"
@@ skipping 66 matching lines @@
   aborted_ = true;
   caller_ = NULL;
   return !did_timeout_;
 }
 
 ProfileSyncServiceHarness::ProfileSyncServiceHarness(
     Profile* profile,
     const std::string& username,
     const std::string& password,
     int id)
-    : wait_state_(INITIAL_WAIT_STATE),
+    : waiting_for_encryption_type_(syncable::UNSPECIFIED),
+      wait_state_(INITIAL_WAIT_STATE),
       profile_(profile),
       service_(NULL),
       timestamp_match_partner_(NULL),
       username_(username),
       password_(password),
       id_(id) {
   if (IsSyncAlreadySetup()) {
     service_ = profile_->GetProfileSyncService();
     service_->AddObserver(this);
     wait_state_ = FULLY_SYNCED;
@@ skipping 183 matching lines @@
     case FULLY_SYNCED: {
       // The client is online and fully synced. There is nothing to do.
       LogClientInfo("FULLY_SYNCED");
       break;
     }
     case SYNC_DISABLED: {
       // Syncing is disabled for the client. There is nothing to do.
       LogClientInfo("SYNC_DISABLED");
       break;
     }
+    case WAITING_FOR_ENCRYPTION: {
+      // If the type whose encryption we are waiting for is now complete, there
+      // is nothing to do.
+      LogClientInfo("WAITING_FOR_ENCRYPTION");
+      if (IsTypeEncrypted(waiting_for_encryption_type_))
+        SignalStateCompleteWithNextState(FULLY_SYNCED);
+      break;
+    }
     default:
       // Invalid state during observer callback which may be triggered by other
       // classes using the the UI message loop.  Defer to their handling.
       break;
   }
   return original_wait_state != wait_state_;
 }
 
 void ProfileSyncServiceHarness::OnStateChanged() {
   RunStateChangeMachine();
@@ skipping 289 matching lines @@
               << ", service_is_pushing_changes: " << ServiceIsPushingChanges();
     } else {
       VLOG(1) << "Client " << id_ << ": " << message
               << ": Sync session snapshot not available.";
     }
   } else {
     VLOG(1) << "Client " << id_ << ": " << message
             << ": Sync service not available.";
   }
 }
+
+bool ProfileSyncServiceHarness::EnableEncryptionForType(
+    syncable::ModelType type) {
+  syncable::ModelTypeSet encrypted_types;
+  service_->GetEncryptedDataTypes(&encrypted_types);
+  if (encrypted_types.count(type) > 0)
+    return true;
+  encrypted_types.insert(type);
+  service_->EncryptDataTypes(encrypted_types);
+
+  // Wait some time to let the enryption finish.
+  std::string reason = "Waiting for encryption.";
+  DCHECK_EQ(FULLY_SYNCED, wait_state_);
+  wait_state_ = WAITING_FOR_ENCRYPTION;
+  waiting_for_encryption_type_ = type;
+  if (!AwaitStatusChangeWithTimeout(kLiveSyncOperationTimeoutMs, reason)) {
+    LOG(ERROR) << "Did not receive EncryptionComplete notification after"
+               << kLiveSyncOperationTimeoutMs / 1000
+               << " seconds.";
+    return false;
+  }
+
+  return IsTypeEncrypted(type);
+}
+
+bool ProfileSyncServiceHarness::IsTypeEncrypted(syncable::ModelType type) {
+  syncable::ModelTypeSet encrypted_types;
+  service_->GetEncryptedDataTypes(&encrypted_types);
+  if (encrypted_types.count(type) == 0) {
+    return false;
+  }
+  return true;
+}