sync: Finish non-blocking type encryption support

sync/sessions/model_type_registry.cc

 // Copyright 2014 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/sessions/model_type_registry.h"
 
 #include "base/bind.h"
 #include "base/observer_list.h"
 #include "base/thread_task_runner_handle.h"
 #include "sync/engine/directory_commit_contributor.h"
@@ skipping 93 matching lines @@
       base::Bind(&ModelTypeSyncWorkerImpl::EnqueueForCommit, worker_, list));
 }
 
 }  // namespace
 
 ModelTypeRegistry::ModelTypeRegistry(
     const std::vector<scoped_refptr<ModelSafeWorker> >& workers,
     syncable::Directory* directory,
     NudgeHandler* nudge_handler)
     : directory_(directory),
-      cryptographer_provider_(directory_),
       nudge_handler_(nudge_handler),
       weak_ptr_factory_(this) {
   for (size_t i = 0u; i < workers.size(); ++i) {
     workers_map_.insert(
         std::make_pair(workers[i]->GetModelSafeGroup(), workers[i]));
   }
 }
 
-ModelTypeRegistry::~ModelTypeRegistry() {}
+ModelTypeRegistry::~ModelTypeRegistry() {
+}
 
 void ModelTypeRegistry::SetEnabledDirectoryTypes(
     const ModelSafeRoutingInfo& routing_info) {
   // Remove all existing directory processors and delete them.  The
   // DebugInfoEmitters are not deleted here, since we want to preserve their
   // counters.
   for (ModelTypeSet::Iterator it = enabled_directory_types_.First();
        it.Good(); it.Inc()) {
     size_t result1 = update_handler_map_.erase(it.Get());
     size_t result2 = commit_contributor_map_.erase(it.Get());
@@ skipping 57 matching lines @@
     ModelType type,
     const DataTypeState& data_type_state,
     const UpdateResponseDataList& saved_pending_updates,
     const scoped_refptr<base::SequencedTaskRunner>& type_task_runner,
     const base::WeakPtr<ModelTypeSyncProxyImpl>& proxy_impl) {
   DVLOG(1) << "Enabling an off-thread sync type: " << ModelTypeToString(type);
 
   // Initialize Worker -> Proxy communication channel.
   scoped_ptr<ModelTypeSyncProxy> proxy(
       new ModelTypeSyncProxyWrapper(proxy_impl, type_task_runner));
+  scoped_ptr<Cryptographer> cryptographer_copy;
+  if (encrypted_types_.Has(type))
+    cryptographer_copy.reset(new Cryptographer(*cryptographer_));
+
   scoped_ptr<ModelTypeSyncWorkerImpl> worker(
       new ModelTypeSyncWorkerImpl(type,
                                   data_type_state,
                                   saved_pending_updates,
-                                  &cryptographer_provider_,
+                                  cryptographer_copy.Pass(),
                                   nudge_handler_,
                                   proxy.Pass()));
 
   // Initialize Proxy -> Worker communication channel.
   scoped_ptr<ModelTypeSyncWorker> wrapped_worker(
       new ModelTypeSyncWorkerWrapper(worker->AsWeakPtr(),
                                      scoped_refptr<base::SequencedTaskRunner>(
                                          base::ThreadTaskRunnerHandle::Get())));
   type_task_runner->PostTask(FROM_HERE,
                              base::Bind(&ModelTypeSyncProxyImpl::OnConnect,
@@ skipping 76 matching lines @@
     it->second->EmitCommitCountersUpdate();
     it->second->EmitUpdateCountersUpdate();
     it->second->EmitStatusCountersUpdate();
   }
 }
 
 base::WeakPtr<SyncContext> ModelTypeRegistry::AsWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
+void ModelTypeRegistry::OnPassphraseRequired(
+    PassphraseRequiredReason reason,
+    const sync_pb::EncryptedData& pending_keys) {
+}
+
+void ModelTypeRegistry::OnPassphraseAccepted() {
+}
+
+void ModelTypeRegistry::OnBootstrapTokenUpdated(
+    const std::string& bootstrap_token,
+    BootstrapTokenType type) {
+}
+
+void ModelTypeRegistry::OnEncryptedTypesChanged(ModelTypeSet encrypted_types,
+                                                bool encrypt_everything) {
+  encrypted_types_ = encrypted_types;
+  OnEncryptionStateChanged();
+}
+
+void ModelTypeRegistry::OnEncryptionComplete() {
+}
+
+void ModelTypeRegistry::OnCryptographerStateChanged(
+    Cryptographer* cryptographer) {
+  cryptographer_.reset(new Cryptographer(*cryptographer));
+  OnEncryptionStateChanged();
+}
+
+void ModelTypeRegistry::OnPassphraseTypeChanged(PassphraseType type,
+                                                base::Time passphrase_time) {
+}
+
 ModelTypeSet ModelTypeRegistry::GetEnabledDirectoryTypes() const {
   return enabled_directory_types_;
 }
 
+void ModelTypeRegistry::OnEncryptionStateChanged() {
+  for (ScopedVector<ModelTypeSyncWorkerImpl>::iterator it =
+           model_type_sync_workers_.begin();
+       it != model_type_sync_workers_.end();
+       ++it) {
+    if (encrypted_types_.Has((*it)->GetModelType())) {
+      (*it)->UpdateCryptographer(
+          make_scoped_ptr(new Cryptographer(*cryptographer_)));
+    }
+  }
+}
+
 ModelTypeSet ModelTypeRegistry::GetEnabledNonBlockingTypes() const {
   ModelTypeSet enabled_off_thread_types;
   for (ScopedVector<ModelTypeSyncWorkerImpl>::const_iterator it =
            model_type_sync_workers_.begin();
        it != model_type_sync_workers_.end();
        ++it) {
     enabled_off_thread_types.Put((*it)->GetModelType());
   }
   return enabled_off_thread_types;
 }
 
 }  // namespace syncer