[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));
     }
   }
 }
 
+#if defined(OS_WIN)

[Nicolas Zea, 2016/12/15 00:37:28]

May as well remove the OS requirement here right? The test should pass no matter
the platform.

[pastarmovj, 2016/12/16 17:04:48]

Actually I added it after I tried compiling on the linux bots.

[Nicolas Zea, 2016/12/16 18:50:35]

That implies to me a layering violation. Everything in the engine should ideally
be abstracted from platform specific conditions. What was the error?

[pastarmovj, 2016/12/19 11:12:00]

it is because of this ifdef here:
https://cs.chromium.org/chromium/src/components/sync/engine_impl/sync_manager...
the reason for it is that all the local backend code is conditionally compiled
only in the Windows version for now to avoid bloating the executable on other
platforms as discussed here https://codereview.chromium.org/2360703002/#msg14 . 

I think it will be hard to get this done in any other way but to always compile
the code in on all platforms that run this test.

+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()));
+  }
+}
+#endif  // defined(OS_WIN)
+
 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 779 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