sync: Add non-blocking type encryption (retry)

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"
 #include "sync/engine/directory_update_handler.h"
 #include "sync/engine/model_type_sync_proxy.h"
 #include "sync/engine/model_type_sync_proxy_impl.h"
 #include "sync/engine/model_type_sync_worker.h"
 #include "sync/engine/model_type_sync_worker_impl.h"
 #include "sync/internal_api/public/non_blocking_sync_common.h"
 #include "sync/sessions/directory_type_debug_info_emitter.h"
+#include "sync/util/cryptographer.h"
 
 namespace syncer {
 
 namespace {
 
 class ModelTypeSyncProxyWrapper : public ModelTypeSyncProxy {
  public:
   ModelTypeSyncProxyWrapper(
       const base::WeakPtr<ModelTypeSyncProxyImpl>& proxy,
       const scoped_refptr<base::SequencedTaskRunner>& processor_task_runner);
   virtual ~ModelTypeSyncProxyWrapper();
 
   virtual void OnCommitCompleted(
       const DataTypeState& type_state,
       const CommitResponseDataList& response_list) OVERRIDE;
   virtual void OnUpdateReceived(
       const DataTypeState& type_state,
-      const UpdateResponseDataList& response_list) OVERRIDE;
+      const UpdateResponseDataList& response_list,
+      const UpdateResponseDataList& pending_updates) OVERRIDE;
 
  private:
   base::WeakPtr<ModelTypeSyncProxyImpl> processor_;
   scoped_refptr<base::SequencedTaskRunner> processor_task_runner_;
 };
 
 ModelTypeSyncProxyWrapper::ModelTypeSyncProxyWrapper(
     const base::WeakPtr<ModelTypeSyncProxyImpl>& proxy,
     const scoped_refptr<base::SequencedTaskRunner>& processor_task_runner)
     : processor_(proxy), processor_task_runner_(processor_task_runner) {
 }
 
 ModelTypeSyncProxyWrapper::~ModelTypeSyncProxyWrapper() {
 }
 
 void ModelTypeSyncProxyWrapper::OnCommitCompleted(
     const DataTypeState& type_state,
     const CommitResponseDataList& response_list) {
   processor_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ModelTypeSyncProxyImpl::OnCommitCompleted,
                  processor_,
                  type_state,
                  response_list));
 }
 
 void ModelTypeSyncProxyWrapper::OnUpdateReceived(
     const DataTypeState& type_state,
-    const UpdateResponseDataList& response_list) {
+    const UpdateResponseDataList& response_list,
+    const UpdateResponseDataList& pending_updates) {
   processor_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ModelTypeSyncProxyImpl::OnUpdateReceived,
                  processor_,
                  type_state,
-                 response_list));
+                 response_list,
+                 pending_updates));
 }
 
 class ModelTypeSyncWorkerWrapper : public ModelTypeSyncWorker {
  public:
   ModelTypeSyncWorkerWrapper(
       const base::WeakPtr<ModelTypeSyncWorkerImpl>& worker,
       const scoped_refptr<base::SequencedTaskRunner>& sync_thread);
   virtual ~ModelTypeSyncWorkerWrapper();
 
   virtual void EnqueueForCommit(const CommitRequestDataList& list) OVERRIDE;
@@ skipping 19 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() {}
 
@@ skipping 58 matching lines @@
   }
 
   enabled_directory_types_ = GetRoutingInfoTypes(routing_info);
   DCHECK(Intersection(GetEnabledDirectoryTypes(),
                       GetEnabledNonBlockingTypes()).Empty());
 }
 
 void ModelTypeRegistry::ConnectSyncTypeToWorker(
     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<ModelTypeSyncWorkerImpl> worker(new ModelTypeSyncWorkerImpl(
-      type, data_type_state, nudge_handler_, proxy.Pass()));
+  scoped_ptr<ModelTypeSyncWorkerImpl> worker(
+      new ModelTypeSyncWorkerImpl(type,
+                                  data_type_state,
+                                  saved_pending_updates,
+                                  &cryptographer_provider_,
+                                  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,
                                         proxy_impl,
                                         base::Passed(&wrapped_worker)));
@@ skipping 90 matching lines @@
   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