Sync: Refactoring DataTypeController to make the design shareable with USS datatypes.

chrome/browser/sync/profile_sync_service_autofill_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 <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 130 matching lines @@
                bool(const std::string&));  // NOLINT
 };
 
 MATCHER_P(MatchProfiles, profile, "") {
   return (profile.Compare(arg) == 0);
 }
 
 class TestSyncClient : public sync_driver::FakeSyncClient {
  public:
   TestSyncClient(PersonalDataManager* pdm,
+

[stanisc, 2015/09/02 17:27:05]

Will remove this empty line before landing the patch.

[Nicolas Zea, 2015/09/02 22:52:45]

Acknowledged.

[stanisc, 2015/09/03 01:17:42]

Done.

                  const scoped_refptr<AutofillWebDataService>& web_data_service)
       : pdm_(pdm),
+        sync_service_(nullptr),
         web_data_service_(web_data_service) {}
   ~TestSyncClient() override {}
 
   // FakeSyncClient overrides.
   autofill::PersonalDataManager* GetPersonalDataManager() override {
     return pdm_;
   }
+  sync_driver::SyncService* GetSyncService() override {
+    DCHECK(sync_service_);
+    return sync_service_;
+  }
   scoped_refptr<autofill::AutofillWebDataService> GetWebDataService() override {
     return web_data_service_;
   }
   base::WeakPtr<syncer::SyncableService> GetSyncableServiceForType(
       syncer::ModelType type) override {
     DCHECK(type == AUTOFILL || type == AUTOFILL_PROFILE);
     if (type == AUTOFILL) {
       return AutocompleteSyncableService::FromWebDataService(
           web_data_service_.get())->AsWeakPtr();
     } else {
       return AutofillProfileSyncableService::FromWebDataService(
           web_data_service_.get())->AsWeakPtr();
     }
   }
 
+  void SetSyncService(sync_driver::SyncService* sync_service) {
+    sync_service_ = sync_service;
+  }
+
  private:
   PersonalDataManager* pdm_;
+  sync_driver::SyncService* sync_service_;
   scoped_refptr<AutofillWebDataService> web_data_service_;
 };
 
 class WebDatabaseFake : public WebDatabase {
  public:
   explicit WebDatabaseFake(AutofillTable* autofill_table) {
     AddTable(autofill_table);
   }
 };
 
@@ skipping 305 matching lines @@
     return node.GetTotalNodeCount() - 1;
   }
 
   void StartSyncService(const base::Closure& callback,
                         bool will_fail_association,
                         syncer::ModelType type) {
     SigninManagerBase* signin = SigninManagerFactory::GetForProfile(profile_);
     signin->SetAuthenticatedAccountInfo("12345", "test_user@gmail.com");
     sync_service_ = TestProfileSyncService::BuildAutoStartAsyncInit(profile_,
                                                                     callback);
+    sync_client_->SetSyncService(sync_service_);
 
     ProfileSyncComponentsFactoryMock* components =
         sync_service_->components_factory_mock();
 
     EXPECT_CALL(*components, CreateDataTypeManager(_, _, _, _, _)).
         WillOnce(ReturnNewDataTypeManagerWithDebugListener(
                      syncer::MakeWeakHandle(debug_ptr_factory_.GetWeakPtr())));
 
     EXPECT_CALL(*personal_data_manager_, IsDataLoaded()).
         WillRepeatedly(Return(true));
@@ skipping 779 matching lines @@
   std::vector<AutofillEntry> sync_entries;
   std::vector<AutofillProfile> sync_profiles;
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&sync_entries, &sync_profiles));
   EXPECT_EQ(3U, sync_entries.size());
   EXPECT_EQ(0U, sync_profiles.size());
   for (size_t i = 0; i < sync_entries.size(); i++) {
     DVLOG(1) << "Entry " << i << ": " << sync_entries[i].key().name()
              << ", " << sync_entries[i].key().value();
   }
 }