[Sync] Allow sync start without sign-in if the local sync backend is on.

components/sync/engine_impl/sync_manager_impl_unittest.cc

 // Copyright 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 "components/sync/engine_impl/sync_manager_impl.h"
 
 #include <cstddef>
 #include <memory>
 #include <utility>
 
@@ skipping 978 matching lines @@
   enum NigoriStatus { DONT_WRITE_NIGORI, WRITE_TO_NIGORI };
 
   enum EncryptionStatus { UNINITIALIZED, DEFAULT_ENCRYPTION, FULL_ENCRYPTION };
 
   SyncManagerTest() : sync_manager_("Test sync manager") {
     switches_.encryption_method = EngineComponentsFactory::ENCRYPTION_KEYSTORE;
   }
 
   virtual ~SyncManagerTest() {}
 
-  // Test implementation.
-  void SetUp() {
+  virtual void DoSetUp(bool enable_local_sync_backend) {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
     extensions_activity_ = new ExtensionsActivity();
 
     SyncCredentials credentials;
     credentials.account_id = "foo@bar.com";
     credentials.email = "foo@bar.com";
     credentials.sync_token = "sometoken";
     OAuth2TokenService::ScopeSet scope_set;
     scope_set.insert(GaiaConstants::kChromeSyncOAuth2Scope);
@@ skipping 17 matching lines @@
     workers.push_back(worker);
 
     SyncManager::InitArgs args;
     args.database_location = temp_dir_.GetPath();
     args.service_url = GURL("https://example.com/");
     args.post_factory = std::unique_ptr<HttpPostProviderFactory>(
         new TestHttpPostProviderFactory());
     args.workers = workers;
     args.extensions_activity = extensions_activity_.get(),
     args.change_delegate = this;
-    args.credentials = credentials;
+    if (!enable_local_sync_backend)
+      args.credentials = credentials;
     args.invalidator_client_id = "fake_invalidator_client_id";
+    args.enable_local_sync_backend = enable_local_sync_backend;
+    args.local_sync_backend_folder = temp_dir_.GetPath();
     args.engine_components_factory.reset(GetFactory());
     args.encryptor = &encryptor_;
     args.unrecoverable_error_handler =
         MakeWeakHandle(mock_unrecoverable_error_handler_.GetWeakPtr());
     args.cancelation_signal = &cancelation_signal_;
     sync_manager_.Init(&args);
 
     sync_manager_.GetEncryptionHandler()->AddObserver(&encryption_observer_);
 
     EXPECT_TRUE(js_backend_.IsInitialized());
     EXPECT_EQ(EngineComponentsFactory::STORAGE_ON_DISK, storage_used_);
 
     if (initialization_succeeded_) {
       for (ModelSafeRoutingInfo::iterator i = routing_info.begin();
            i != routing_info.end(); ++i) {
         type_roots_[i->first] =
             MakeTypeRoot(sync_manager_.GetUserShare(), i->first);
       }
     }
 
     PumpLoop();
   }
 
+  // Test implementation.
+  void SetUp() { DoSetUp(false); }
+
   void TearDown() {
     sync_manager_.RemoveObserver(&manager_observer_);
     sync_manager_.ShutdownOnSyncThread(STOP_SYNC);
     PumpLoop();
   }
 
   void GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) {
     (*out)[NIGORI] = GROUP_PASSIVE;
     (*out)[DEVICE_INFO] = GROUP_PASSIVE;
     (*out)[EXPERIMENTS] = GROUP_PASSIVE;
@@ skipping 1612 matching lines @@
     ReadTransaction read_trans(FROM_HERE, sync_manager_.GetUserShare());
     for (ModelSafeRoutingInfo::iterator i = routing_info.begin();
          i != routing_info.end(); ++i) {
       EXPECT_EQ(i->first == BOOKMARKS ? 2 : 1,
                 sync_manager_.GetUserShare()->directory->GetTransactionVersion(
                     i->first));
     }
   }
 }
 
+class SyncManagerWithLocalBackendTest : public SyncManagerTest {
+ protected:
+  void SetUp() override { DoSetUp(true); }
+};
+
+// This test checks that we can successfully initialize without credentials in
+// the local backend case.
+TEST_F(SyncManagerWithLocalBackendTest, StartSyncInLocalMode) {
+  EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
+  EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
+  EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
+  EXPECT_CALL(encryption_observer_, OnEncryptedTypesChanged(_, false));
+
+  sync_manager_.GetEncryptionHandler()->Init();
+  PumpLoop();
+
+  const ModelTypeSet encrypted_types = GetEncryptedTypes();
+  EXPECT_TRUE(encrypted_types.Has(PASSWORDS));
+  EXPECT_FALSE(IsEncryptEverythingEnabledForTest());
+
+  {
+    ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
+    ReadNode node(&trans);
+    EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(GetIdForDataType(NIGORI)));
+    sync_pb::NigoriSpecifics nigori = node.GetNigoriSpecifics();
+    EXPECT_TRUE(nigori.has_encryption_keybag());
+    Cryptographer* cryptographer = trans.GetCryptographer();
+    EXPECT_TRUE(cryptographer->is_ready());
+    EXPECT_TRUE(cryptographer->CanDecrypt(nigori.encryption_keybag()));
+  }
+}
+
 class MockSyncScheduler : public FakeSyncScheduler {
  public:
   MockSyncScheduler() : FakeSyncScheduler() {}
   virtual ~MockSyncScheduler() {}
 
   MOCK_METHOD2(Start, void(SyncScheduler::Mode, base::Time));
   MOCK_METHOD1(ScheduleConfiguration, void(const ConfigurationParams&));
 };
 
 class ComponentsFactory : public TestEngineComponentsFactory {
  public:
   ComponentsFactory(const Switches& switches,
                     SyncScheduler* scheduler_to_use,
                     SyncCycleContext** cycle_context,
                     EngineComponentsFactory::StorageOption* storage_used)
       : TestEngineComponentsFactory(switches,
                                     EngineComponentsFactory::STORAGE_IN_MEMORY,
                                     storage_used),
         scheduler_to_use_(scheduler_to_use),
         cycle_context_(cycle_context) {}
   ~ComponentsFactory() override {}
 
   std::unique_ptr<SyncScheduler> BuildScheduler(
       const std::string& name,
       SyncCycleContext* context,
-      CancelationSignal* stop_handle) override {
+      CancelationSignal* stop_handle,
+      bool local_sync_backend_enabled) override {
     *cycle_context_ = context;
     return std::move(scheduler_to_use_);
   }
 
  private:
   std::unique_ptr<SyncScheduler> scheduler_to_use_;
   SyncCycleContext** cycle_context_;
 };
 
 class SyncManagerTestWithMockScheduler : public SyncManagerTest {
@@ skipping 783 matching lines @@
 // SyncManagerInitInvalidStorageTest::GetFactory will return
 // DirectoryBackingStore that ensures that SyncManagerImpl::OpenDirectory fails.
 // SyncManagerImpl initialization is done in SyncManagerTest::SetUp. This test's
 // task is to ensure that SyncManagerImpl reported initialization failure in
 // OnInitializationComplete callback.
 TEST_F(SyncManagerInitInvalidStorageTest, FailToOpenDatabase) {
   EXPECT_FALSE(initialization_succeeded_);
 }
 
 }  // namespace syncer