Invalidation trickles mega-patch

chrome/browser/invalidation/ticl_invalidation_service.cc

 // Copyright (c) 2013 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/invalidation/ticl_invalidation_service.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/invalidation/invalidation_service_util.h"
@@ skipping 122 matching lines @@
   DCHECK(CalledOnValidThread());
   DVLOG(2) << "Unregistering";
   invalidator_registrar_->UnregisterHandler(handler);
   if (invalidator_) {
     invalidator_->UpdateRegisteredIds(
         this,
         invalidator_registrar_->GetAllRegisteredIds());
   }
 }
 
-void TiclInvalidationService::AcknowledgeInvalidation(
-    const invalidation::ObjectId& id,
-    const syncer::AckHandle& ack_handle) {
-  DCHECK(CalledOnValidThread());
-  if (invalidator_) {
-    invalidator_->Acknowledge(id, ack_handle);
-  }
-}
-
 syncer::InvalidatorState TiclInvalidationService::GetInvalidatorState() const {
   DCHECK(CalledOnValidThread());
   if (invalidator_) {
     DVLOG(2) << "GetInvalidatorState returning "
         << invalidator_->GetInvalidatorState();
     return invalidator_->GetInvalidatorState();
   } else {
     DVLOG(2) << "Invalidator currently stopped";
     return syncer::TRANSIENT_INVALIDATION_ERROR;
   }
@@ skipping 128 matching lines @@
     // state.
     invalidator_registrar_->UpdateInvalidatorState(
         syncer::TRANSIENT_INVALIDATION_ERROR);
     RequestAccessToken();
   } else {
     invalidator_registrar_->UpdateInvalidatorState(state);
   }
 }
 
 void TiclInvalidationService::OnIncomingInvalidation(
-    const syncer::ObjectIdInvalidationMap& invalidation_map) {
-  invalidator_registrar_->DispatchInvalidationsToHandlers(invalidation_map);
+    const syncer::ObjectIdInvalidationMap& invalidations) {
+  invalidator_registrar_->DispatchInvalidationsToHandlers(invalidations);
 }
 
 void TiclInvalidationService::Shutdown() {
   DCHECK(CalledOnValidThread());
   if (IsStarted()) {
     StopInvalidator();
   }
   invalidator_storage_.reset();
   invalidator_registrar_.reset();
 }
@@ skipping 42 matching lines @@
     return;
   }
 
   notifier::NotifierOptions options =
       ParseNotifierOptions(*CommandLine::ForCurrentProcess());
   options.request_context_getter = profile_->GetRequestContext();
   options.auth_mechanism = "X-OAUTH2";
   invalidator_.reset(new syncer::NonBlockingInvalidator(
           options,
           invalidator_storage_->GetInvalidatorClientId(),
-          invalidator_storage_->GetAllInvalidationStates(),
+          invalidator_storage_->GetSavedInvalidations(),
           invalidator_storage_->GetBootstrapData(),
           syncer::WeakHandle<syncer::InvalidationStateTracker>(
               invalidator_storage_->AsWeakPtr()),
           content::GetUserAgent(GURL())));
 
   UpdateInvalidatorCredentials();
 
   invalidator_->RegisterHandler(this);
   invalidator_->UpdateRegisteredIds(
       this,
@@ skipping 24 matching lines @@
   }
 
   // This service always expects to have a valid invalidator storage.
   // So we must not only clear the old one, but also start a new one.
   invalidator_storage_->Clear();
   invalidator_storage_.reset(new InvalidatorStorage(profile_->GetPrefs()));
   invalidator_storage_->SetInvalidatorClientId(GenerateInvalidatorClientId());
 }
 
 }  // namespace invalidation