Let sync backup/rollback manager return a dummy encryption handler.

sync/internal_api/sync_rollback_manager_base.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/internal_api/sync_rollback_manager_base.h"
 
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/internal_components_factory.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
-#include "sync/internal_api/public/util/syncer_error.h"
 #include "sync/internal_api/public/write_transaction.h"
 #include "sync/syncable/directory_backing_store.h"
 #include "sync/syncable/mutable_entry.h"
 
 namespace {
 
 // Permanent bookmark folders as defined in bookmark_model_associator.cc.
 const char kBookmarkBarTag[] = "bookmark_bar";
 const char kMobileBookmarksTag[] = "synced_bookmarks";
 const char kOtherBookmarksTag[] = "other_bookmarks";
 
+class DummyEntryptionHandler : public syncer::SyncEncryptionHandler {
+  virtual void AddObserver(Observer* observer) OVERRIDE {}
+  virtual void RemoveObserver(Observer* observer) OVERRIDE {}
+  virtual void Init() OVERRIDE {}
+  virtual void SetEncryptionPassphrase(const std::string& passphrase,
+                                       bool is_explicit) OVERRIDE {}
+  virtual void SetDecryptionPassphrase(const std::string& passphrase)
+      OVERRIDE {}
+  virtual void EnableEncryptEverything() OVERRIDE {}
+  virtual bool EncryptEverythingEnabled() const OVERRIDE {
+    return false;
+  }
+  virtual syncer::PassphraseType GetPassphraseType() const OVERRIDE {
+    return syncer::KEYSTORE_PASSPHRASE;
+  }
+};
+
 }  // anonymous namespace
 
 namespace syncer {
 
 SyncRollbackManagerBase::SyncRollbackManagerBase()
     : report_unrecoverable_error_function_(NULL),
-      weak_ptr_factory_(this) {
+      weak_ptr_factory_(this),
+      dummy_handler_(new DummyEntryptionHandler) {
 }
 
 SyncRollbackManagerBase::~SyncRollbackManagerBase() {
 }
 
 void SyncRollbackManagerBase::Init(
       const base::FilePath& database_location,
       const WeakHandle<JsEventHandler>& event_handler,
       const std::string& sync_server_and_path,
       int sync_server_port,
@@ skipping 38 matching lines @@
   return types;
 }
 
 bool SyncRollbackManagerBase::PurgePartiallySyncedTypes() {
   NOTREACHED();
   return true;
 }
 
 void SyncRollbackManagerBase::UpdateCredentials(
     const SyncCredentials& credentials) {
-  NOTREACHED();
 }
 
 void SyncRollbackManagerBase::StartSyncingNormally(
     const ModelSafeRoutingInfo& routing_info){
 }
 
 void SyncRollbackManagerBase::ConfigureSyncer(
       ConfigureReason reason,
       ModelTypeSet to_download,
       ModelTypeSet to_purge,
       ModelTypeSet to_journal,
       ModelTypeSet to_unapply,
       const ModelSafeRoutingInfo& new_routing_info,
       const base::Closure& ready_task,
       const base::Closure& retry_task) {
-  DCHECK(to_purge.Empty());
-  DCHECK(to_journal.Empty());
-  DCHECK(to_unapply.Empty());
   for (ModelTypeSet::Iterator type = to_download.First();
       type.Good(); type.Inc()) {
     if (InitTypeRootNode(type.Get())) {
       if (type.Get() == BOOKMARKS) {
         InitBookmarkFolder(kBookmarkBarTag);
         InitBookmarkFolder(kMobileBookmarksTag);
         InitBookmarkFolder(kOtherBookmarksTag);
       }
     }
   }
@@ skipping 45 matching lines @@
 }
 
 bool SyncRollbackManagerBase::HasUnsyncedItems() {
   ReadTransaction trans(FROM_HERE, &share_);
   syncable::Directory::Metahandles unsynced;
   share_.directory->GetUnsyncedMetaHandles(trans.GetWrappedTrans(), &unsynced);
   return !unsynced.empty();
 }
 
 SyncEncryptionHandler* SyncRollbackManagerBase::GetEncryptionHandler() {
-  return NULL;
+  return dummy_handler_.get();
 }
 
 void SyncRollbackManagerBase::RefreshTypes(ModelTypeSet types) {
 
 }
 
 void SyncRollbackManagerBase::HandleTransactionCompleteChangeEvent(
     ModelTypeSet models_with_changes) {
 }
 
@@ skipping 130 matching lines @@
   entry.PutNonUniqueName(folder);
   entry.PutIsDel(false);
   entry.PutIsDir(true);
 
   sync_pb::EntitySpecifics specifics;
   AddDefaultFieldValue(BOOKMARKS, &specifics);
   entry.PutSpecifics(specifics);
 }
 
 }  // namespace syncer