[iOS] Add FakeSyncService and factory for testing

Review URL: https://codereview.chromium.org/1158223003

Cr-Commit-Position: refs/heads/master@{#333727}

components/sync_driver.gypi

@@ -105,6 +105,8 @@
         'sync_driver/fake_data_type_controller.h',
         'sync_driver/fake_generic_change_processor.cc',
         'sync_driver/fake_generic_change_processor.h',
+        'sync_driver/fake_sync_service.cc',
+        'sync_driver/fake_sync_service.h',
         'sync_driver/local_device_info_provider_mock.cc',
         'sync_driver/local_device_info_provider_mock.h',
         'sync_driver/model_associator_mock.cc',

components/sync_driver/DEPS

 include_rules = [
   "+components/os_crypt",
   "+components/pref_registry",
+  "+google_apis",
   "+sync",
 ]

components/sync_driver/fake_sync_service.cc

+// Copyright 2015 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_driver/fake_sync_service.h"
+
+namespace sync_driver {
+
+FakeSyncService::FakeSyncService() : error_(GoogleServiceAuthError::NONE) {
+}
+
+FakeSyncService::~FakeSyncService() {
+}
+
+bool FakeSyncService::HasSyncSetupCompleted() const {
+  return false;
+}
+
+bool FakeSyncService::IsSyncActive() const {
+  return false;
+}
+
+syncer::ModelTypeSet FakeSyncService::GetActiveDataTypes() const {
+  return syncer::ModelTypeSet();
+}
+
+void FakeSyncService::AddObserver(sync_driver::SyncServiceObserver* observer) {
+}
+
+void FakeSyncService::RemoveObserver(
+    sync_driver::SyncServiceObserver* observer) {
+}
+
+bool FakeSyncService::HasObserver(
+    const sync_driver::SyncServiceObserver* observer) const {
+  return false;
+}
+
+bool FakeSyncService::IsSyncEnabledAndLoggedIn() {
+  return false;
+}
+
+void FakeSyncService::DisableForUser() {
+}
+
+void FakeSyncService::RequestStop() {
+}
+
+void FakeSyncService::RequestStart() {
+}
+
+syncer::ModelTypeSet FakeSyncService::GetPreferredDataTypes() const {
+  return syncer::ModelTypeSet();
+}
+
+void FakeSyncService::OnUserChoseDatatypes(bool sync_everything,
+                                           syncer::ModelTypeSet chosen_types) {
+}
+
+void FakeSyncService::SetSyncSetupCompleted() {
+}
+
+bool FakeSyncService::FirstSetupInProgress() const {
+  return false;
+}
+
+void FakeSyncService::SetSetupInProgress(bool setup_in_progress) {
+}
+
+bool FakeSyncService::setup_in_progress() const {
+  return false;
+}
+
+bool FakeSyncService::ConfigurationDone() const {
+  return false;
+}
+
+const GoogleServiceAuthError& FakeSyncService::GetAuthError() const {
+  return error_;
+}
+
+bool FakeSyncService::HasUnrecoverableError() const {
+  return false;
+}
+
+bool FakeSyncService::backend_initialized() const {
+  return false;
+}
+
+bool FakeSyncService::IsPassphraseRequiredForDecryption() const {
+  return false;
+}
+
+base::Time FakeSyncService::GetExplicitPassphraseTime() const {
+  return base::Time();
+}
+
+bool FakeSyncService::IsUsingSecondaryPassphrase() const {
+  return false;
+}
+
+void FakeSyncService::EnableEncryptEverything() {
+}
+
+void FakeSyncService::SetEncryptionPassphrase(const std::string& passphrase,
+                                              PassphraseType type) {
+}
+
+bool FakeSyncService::SetDecryptionPassphrase(const std::string& passphrase) {
+  return false;
+}
+
+bool FakeSyncService::IsPassphraseRequired() const {
+  return false;
+}
+
+syncer::ModelTypeSet FakeSyncService::GetEncryptedDataTypes() const {
+  return syncer::ModelTypeSet();
+}
+
+}  // namespace sync_driver

components/sync_driver/fake_sync_service.h

+// Copyright 2015 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.
+
+#ifndef COMPONENTS_SYNC_DRIVER_FAKE_SYNC_SERVICE_H_
+#define COMPONENTS_SYNC_DRIVER_FAKE_SYNC_SERVICE_H_
+
+#include "components/sync_driver/sync_service.h"
+#include "google_apis/gaia/google_service_auth_error.h"
+
+namespace sync_driver {
+
+// Fake implementation of sync_driver::SyncService, used for testing.
+class FakeSyncService : public sync_driver::SyncService {
+ public:
+  FakeSyncService();
+  ~FakeSyncService() override;
+
+ private:
+  // sync_driver::SyncService:
+  bool HasSyncSetupCompleted() const override;
+  bool IsSyncActive() const override;
+  syncer::ModelTypeSet GetActiveDataTypes() const override;
+  void AddObserver(sync_driver::SyncServiceObserver* observer) override;
+  void RemoveObserver(sync_driver::SyncServiceObserver* observer) override;
+  bool HasObserver(
+      const sync_driver::SyncServiceObserver* observer) const override;
+  bool IsSyncEnabledAndLoggedIn() override;
+  void DisableForUser() override;
+  void RequestStop() override;
+  void RequestStart() override;
+  syncer::ModelTypeSet GetPreferredDataTypes() const override;
+  void OnUserChoseDatatypes(bool sync_everything,
+                            syncer::ModelTypeSet chosen_types) override;
+  void SetSyncSetupCompleted() override;
+  bool FirstSetupInProgress() const override;
+  void SetSetupInProgress(bool setup_in_progress) override;
+  bool setup_in_progress() const override;
+  bool ConfigurationDone() const override;
+  const GoogleServiceAuthError& GetAuthError() const override;
+  bool HasUnrecoverableError() const override;
+  bool backend_initialized() const override;
+  bool IsPassphraseRequiredForDecryption() const override;
+  base::Time GetExplicitPassphraseTime() const override;
+  bool IsUsingSecondaryPassphrase() const override;
+  void EnableEncryptEverything() override;
+  void SetEncryptionPassphrase(const std::string& passphrase,
+                               PassphraseType type) override;
+  bool SetDecryptionPassphrase(const std::string& passphrase) override;
+
+  // sync_driver::DataTypeEncryptionHandler:
+  bool IsPassphraseRequired() const override;
+  syncer::ModelTypeSet GetEncryptedDataTypes() const override;
+
+  GoogleServiceAuthError error_;
+};
+
+}  // namespace sync_driver
+
+#endif  // COMPONENTS_SYNC_DRIVER_FAKE_SYNC_SERVICE_H_

ios/ios_tests.gyp

@@ -10,19 +10,28 @@
       'target_name': 'test_support_ios',
       'type': 'static_library',
       'sources': [
+        # TODO(droger): Move most of these files to
+        # //ios/chrome/ios_chrome_tests.gyp, see http://crbug.com/437333
         'public/test/fake_profile_oauth2_token_service_ios_provider.h',
         'public/test/fake_profile_oauth2_token_service_ios_provider.mm',
         'public/test/fake_string_provider.cc',
         'public/test/fake_string_provider.h',
+        'public/test/fake_sync_service_factory.cc',
+        'public/test/fake_sync_service_factory.h',
         'public/test/test_chrome_browser_provider.h',
         'public/test/test_chrome_browser_provider.mm',
         'public/test/test_chrome_provider_initializer.cc',
         'public/test/test_chrome_provider_initializer.h',
+        'public/test/test_keyed_service_provider.cc',
+        'public/test/test_keyed_service_provider.h',
         'public/test/test_updatable_resource_provider.h',
         'public/test/test_updatable_resource_provider.mm',
       ],
       'dependencies': [
         '../base/base.gyp:base',
+        '../components/components.gyp:keyed_service_core',
+        '../components/components.gyp:keyed_service_ios',
+        '../components/components.gyp:sync_driver_test_support',
         '../testing/gtest.gyp:gtest',
         'provider/ios_provider_chrome.gyp:ios_provider_chrome_browser',
       ],

ios/public/test/DEPS

+include_rules = [
+  '+components/keyed_service/core',
+  '+components/keyed_service/ios',
+  '+components/sync_driver',
+]

ios/public/test/fake_sync_service_factory.cc

+// Copyright 2015 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 "ios/public/test/fake_sync_service_factory.h"
+
+#include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
+#include "components/keyed_service/core/keyed_service.h"
+#include "components/keyed_service/ios/browser_state_dependency_manager.h"
+#include "components/sync_driver/fake_sync_service.h"
+
+namespace {
+
+class KeyedFakeSyncService : public KeyedService {
+ public:
+  KeyedFakeSyncService(sync_driver::FakeSyncService* service)
+      : fake_sync_service_(service) {
+    DCHECK(fake_sync_service_);
+  }
+
+  sync_driver::FakeSyncService* fake_sync_service() {
+    return fake_sync_service_.get();
+  }
+
+ private:
+  scoped_ptr<sync_driver::FakeSyncService> fake_sync_service_;
+};
+
+}  // namespace
+
+namespace ios {
+
+// static
+FakeSyncServiceFactory* FakeSyncServiceFactory::GetInstance() {
+  return Singleton<FakeSyncServiceFactory>::get();
+}
+
+// static
+sync_driver::FakeSyncService* FakeSyncServiceFactory::GetForBrowserState(
+    web::BrowserState* browser_state) {
+  return static_cast<KeyedFakeSyncService*>(
+             FakeSyncServiceFactory::GetInstance()->GetServiceForBrowserState(
+                 browser_state, true))->fake_sync_service();
+}
+
+KeyedService* FakeSyncServiceFactory::BuildServiceInstanceFor(
+    web::BrowserState* context) const {
+  return new KeyedFakeSyncService(new sync_driver::FakeSyncService);
+}
+
+FakeSyncServiceFactory::FakeSyncServiceFactory()
+    : BrowserStateKeyedServiceFactory(
+          "FakeSyncService",
+          BrowserStateDependencyManager::GetInstance()) {
+}
+
+FakeSyncServiceFactory::~FakeSyncServiceFactory() {
+}
+
+}  // namespace ios

ios/public/test/fake_sync_service_factory.h

+// Copyright 2015 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.
+
+#ifndef IOS_PUBLIC_TEST_FAKE_SYNC_SERVICE_FACTORY_H_
+#define IOS_PUBLIC_TEST_FAKE_SYNC_SERVICE_FACTORY_H_
+
+#include "base/macros.h"
+#include "base/memory/singleton.h"
+#include "components/keyed_service/ios/browser_state_keyed_service_factory.h"
+
+namespace sync_driver {
+class FakeSyncService;
+}
+
+namespace ios {
+
+class FakeSyncServiceFactory : public BrowserStateKeyedServiceFactory {
+ public:
+  // Returns the singleton FakeSyncServiceFactory instance.
+  static FakeSyncServiceFactory* GetInstance();
+
+  // Returns the FakeSyncService associated to |browser_state|.
+  static sync_driver::FakeSyncService* GetForBrowserState(
+      web::BrowserState* browser_state);
+
+ private:
+  friend struct DefaultSingletonTraits<FakeSyncServiceFactory>;
+
+  // BrowserStateKeyedServiceFactory implementation:
+  KeyedService* BuildServiceInstanceFor(
+      web::BrowserState* context) const override;
+
+  FakeSyncServiceFactory();
+  ~FakeSyncServiceFactory() override;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeSyncServiceFactory);
+};
+
+}  // namespace ios
+
+#endif  // IOS_PUBLIC_TEST_FAKE_SYNC_SERVICE_FACTORY_H_

ios/public/test/test_chrome_browser_provider.h

@@ -24,9 +24,11 @@ class TestChromeBrowserProvider : public ChromeBrowserProvider {
   // ChromeBrowserProvider:
   StringProvider* GetStringProvider() override;
   const char* GetChromeUIScheme() override;
+  KeyedServiceProvider* GetKeyedServiceProvider() override;
 
  private:
   scoped_ptr<FakeStringProvider> string_provider_;
+  scoped_ptr<KeyedServiceProvider> test_keyed_service_provider_;
 
   DISALLOW_COPY_AND_ASSIGN(TestChromeBrowserProvider);
 };

ios/public/test/test_chrome_browser_provider.mm

@@ -6,6 +6,7 @@
 
 #include "base/logging.h"
 #include "ios/public/test/fake_string_provider.h"
+#import "ios/public/test/test_keyed_service_provider.h"
 
 namespace {
 const char kUIScheme[] = "uischeme";
@@ -14,7 +15,8 @@ const char kUIScheme[] = "uischeme";
 namespace ios {
 
 TestChromeBrowserProvider::TestChromeBrowserProvider()
-    : string_provider_(new FakeStringProvider) {
+    : string_provider_(new FakeStringProvider),
+      test_keyed_service_provider_(new TestKeyedServiceProvider) {
 }
 
 TestChromeBrowserProvider::~TestChromeBrowserProvider() {
@@ -31,6 +33,10 @@ StringProvider* TestChromeBrowserProvider::GetStringProvider() {
   return string_provider_.get();
 }
 
+KeyedServiceProvider* TestChromeBrowserProvider::GetKeyedServiceProvider() {
+  return test_keyed_service_provider_.get();
+}
+
 const char* TestChromeBrowserProvider::GetChromeUIScheme() {
   return kUIScheme;
 }

ios/public/test/test_keyed_service_provider.cc

+// Copyright 2015 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 "ios/public/test/test_keyed_service_provider.h"
+
+#include "components/sync_driver/fake_sync_service.h"
+#include "ios/public/provider/chrome/browser/browser_state/chrome_browser_state.h"
+#include "ios/public/test/fake_sync_service_factory.h"
+
+namespace ios {
+
+TestKeyedServiceProvider::TestKeyedServiceProvider() {
+}
+
+TestKeyedServiceProvider::~TestKeyedServiceProvider() {
+}
+
+KeyedServiceBaseFactory* TestKeyedServiceProvider::GetSyncServiceFactory() {
+  return FakeSyncServiceFactory::GetInstance();
+}
+
+sync_driver::SyncService*
+TestKeyedServiceProvider::GetSyncServiceForBrowserState(
+    ChromeBrowserState* browser_state) {
+  return FakeSyncServiceFactory::GetForBrowserState(browser_state);
+}
+
+}  // namespace ios

ios/public/test/test_keyed_service_provider.h

+// Copyright 2015 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.
+
+#ifndef IOS_PUBLIC_TEST_TEST_KEYED_SERVICE_PROVIDER_H_
+#define IOS_PUBLIC_TEST_TEST_KEYED_SERVICE_PROVIDER_H_
+
+#include "base/macros.h"
+#include "ios/public/provider/chrome/browser/keyed_service_provider.h"
+
+namespace ios {
+
+class TestKeyedServiceProvider : public KeyedServiceProvider {
+ public:
+  TestKeyedServiceProvider();
+  ~TestKeyedServiceProvider() override;
+
+  // KeyedServiceProvider implementation:
+  KeyedServiceBaseFactory* GetSyncServiceFactory() override;
+  sync_driver::SyncService* GetSyncServiceForBrowserState(
+      ChromeBrowserState* browser_state) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestKeyedServiceProvider);
+};
+
+}  // namespace ios
+
+#endif  // IOS_PUBLIC_TEST_TEST_KEYED_SERVICE_PROVIDER_H_