Merge 208347 "Revert 208315 "Make use of InvalidationService""

chrome/browser/sync/test_profile_sync_service.cc

 // Copyright (c) 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 "chrome/browser/sync/test_profile_sync_service.h"
 
 #include "chrome/browser/signin/signin_manager.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/sync/glue/data_type_controller.h"
 #include "chrome/browser/sync/glue/sync_backend_host.h"
@@ skipping 18 matching lines @@
 using syncer::DEVICE_INFO;
 using syncer::EXPERIMENTS;
 using syncer::NIGORI;
 using syncer::PRIORITY_PREFERENCES;
 
 namespace browser_sync {
 
 SyncBackendHostForProfileSyncTest::SyncBackendHostForProfileSyncTest(
     Profile* profile,
     const base::WeakPtr<SyncPrefs>& sync_prefs,
+    const base::WeakPtr<invalidation::InvalidatorStorage>& invalidator_storage,
     syncer::TestIdFactory& id_factory,
     base::Closure& callback,
     bool set_initial_sync_ended_on_init,
     bool synchronous_init,
     bool fail_initial_download,
     syncer::StorageOption storage_option)
     : browser_sync::SyncBackendHost(
-        profile->GetDebugName(), profile, sync_prefs),
+        profile->GetDebugName(), profile, sync_prefs, invalidator_storage),
       weak_ptr_factory_(this),
       id_factory_(id_factory),
       callback_(callback),
       fail_initial_download_(fail_initial_download),
       set_initial_sync_ended_on_init_(set_initial_sync_ended_on_init),
       synchronous_init_(synchronous_init),
       storage_option_(storage_option) {}
 
 SyncBackendHostForProfileSyncTest::~SyncBackendHostForProfileSyncTest() {}
 
@@ skipping 51 matching lines @@
     syncer::ModelTypeSet to_unapply,
     syncer::ModelTypeSet to_ignore,
     const syncer::ModelSafeRoutingInfo& routing_info,
     const base::Callback<void(syncer::ModelTypeSet,
                               syncer::ModelTypeSet)>& ready_task,
     const base::Closure& retry_callback) {
   syncer::ModelTypeSet failed_configuration_types;
   if (fail_initial_download_)
     failed_configuration_types = to_download;
 
-  // The first parameter there should be the set of enabled types.  That's not
-  // something we have access to from this strange test harness.  We'll just
-  // send back the list of newly configured types instead and hope it doesn't
-  // break anything.
   FinishConfigureDataTypesOnFrontendLoop(
       syncer::Difference(to_download, failed_configuration_types),
-      syncer::Difference(to_download, failed_configuration_types),
       failed_configuration_types,
       ready_task);
 }
 
 void SyncBackendHostForProfileSyncTest
     ::HandleSyncManagerInitializationOnFrontendLoop(
     const syncer::WeakHandle<syncer::JsBackend>& js_backend,
     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
         debug_info_listener,
     syncer::ModelTypeSet restored_types) {
@@ skipping 41 matching lines @@
   if (fail_initial_download_) {
     frontend()->OnSyncConfigureRetry();
     if (synchronous_init_)
       base::MessageLoop::current()->Quit();
   } else {
     initial_download_closure_.Run();
     initial_download_closure_.Reset();
   }
 }
 
+void SyncBackendHostForProfileSyncTest::EmitOnInvalidatorStateChange(
+    syncer::InvalidatorState state) {
+  frontend()->OnInvalidatorStateChange(state);
+}
+
+void SyncBackendHostForProfileSyncTest::EmitOnIncomingInvalidation(
+    const syncer::ObjectIdInvalidationMap& invalidation_map) {
+  frontend()->OnIncomingInvalidation(invalidation_map);
+}
+
 void SyncBackendHostForProfileSyncTest::ContinueInitialization(
     const syncer::WeakHandle<syncer::JsBackend>& js_backend,
     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
         debug_info_listener,
     syncer::ModelTypeSet restored_types) {
   SyncBackendHost::HandleSyncManagerInitializationOnFrontendLoop(
       js_backend, debug_info_listener, restored_types);
 }
 
 }  // namespace browser_sync
@@ skipping 102 matching lines @@
 }
 void TestProfileSyncService::set_storage_option(
     syncer::StorageOption storage_option) {
   storage_option_ = storage_option;
 }
 
 void TestProfileSyncService::CreateBackend() {
   backend_.reset(new browser_sync::SyncBackendHostForProfileSyncTest(
       profile(),
       sync_prefs_.AsWeakPtr(),
+      invalidator_storage_.AsWeakPtr(),
       id_factory_,
       callback_,
       set_initial_sync_ended_on_init_,
       synchronous_backend_initialization_,
       fail_initial_download_,
       storage_option_));
 }
 
 scoped_ptr<OAuth2TokenService::Request> FakeOAuth2TokenService::StartRequest(
     const OAuth2TokenService::ScopeSet& scopes,
     OAuth2TokenService::Consumer* consumer) {
   // Ensure token in question is cached and never expires. Request will succeed
   // without network IO.
   RegisterCacheEntry(GetRefreshToken(), scopes, "access_token",
       base::Time::Max());
   return ProfileOAuth2TokenService::StartRequest(scopes, consumer);
 }
 
 BrowserContextKeyedService* FakeOAuth2TokenService::BuildTokenService(
     content::BrowserContext* context) {
   Profile* profile = static_cast<Profile*>(context);
 
   FakeOAuth2TokenService* service =
       new FakeOAuth2TokenService(context->GetRequestContext());
   service->Initialize(profile);
   return service;
 }