Split up SyncEngineEventListener callbacks

sync/engine/sync_scheduler_impl.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 "sync/engine/sync_scheduler_impl.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/auto_reset.h"
@@ skipping 236 matching lines @@
 
 ModelTypeSet SyncSchedulerImpl::GetEnabledAndUnthrottledTypes() {
   ModelTypeSet enabled_types = session_context_->enabled_types();
   ModelTypeSet throttled_types = nudge_tracker_.GetThrottledTypes();
   return Difference(enabled_types, throttled_types);
 }
 
 void SyncSchedulerImpl::SendInitialSnapshot() {
   DCHECK(CalledOnValidThread());
   scoped_ptr<SyncSession> dummy(SyncSession::Build(session_context_, this));
-  SyncEngineEvent event(SyncEngineEvent::STATUS_CHANGED);
+  SyncCycleEvent event(SyncCycleEvent::STATUS_CHANGED);
   event.snapshot = dummy->TakeSnapshot();
-  session_context_->NotifyListeners(event);
+  FOR_EACH_OBSERVER(SyncEngineEventListener,
+                    *session_context_->listeners(),
+                    OnSyncCycleEvent(event));
 }
 
 namespace {
 
 // Helper to extract the routing info corresponding to types in
 // |types_to_download| from |current_routes|.
 void BuildModelSafeParams(
     ModelTypeSet types_to_download,
     const ModelSafeRoutingInfo& current_routes,
     ModelSafeRoutingInfo* result_routes) {
@@ skipping 533 matching lines @@
   // first put us into a state that prevents successful sync cycles (eg. global
   // throttling, type throttling, network errors, transient errors) will also
   // setup the appropriate retry logic (eg. retry after timeout, exponential
   // backoff, retry when the network changes).
 }
 
 void SyncSchedulerImpl::ExponentialBackoffRetry() {
   TryCanaryJob();
 }
 
-void SyncSchedulerImpl::Notify(SyncEngineEvent::EventCause cause) {
-  DCHECK(CalledOnValidThread());
-  session_context_->NotifyListeners(SyncEngineEvent(cause));
-}
-
 void SyncSchedulerImpl::NotifyRetryTime(base::Time retry_time) {
-  SyncEngineEvent event(SyncEngineEvent::RETRY_TIME_CHANGED);
-  event.retry_time = retry_time;
-  session_context_->NotifyListeners(event);
+  FOR_EACH_OBSERVER(SyncEngineEventListener,
+                    *session_context_->listeners(),
+                    OnRetryTimeChanged(retry_time));
 }
 
 void SyncSchedulerImpl::NotifyThrottledTypesChanged(ModelTypeSet types) {
-  SyncEngineEvent event(SyncEngineEvent::THROTTLED_TYPES_CHANGED);
-  event.throttled_types = types;
-  session_context_->NotifyListeners(event);
+  FOR_EACH_OBSERVER(SyncEngineEventListener,
+                    *session_context_->listeners(),
+                    OnThrottledTypesChanged(types));
 }
 
 bool SyncSchedulerImpl::IsBackingOff() const {
   DCHECK(CalledOnValidThread());
   return wait_interval_.get() && wait_interval_->mode ==
       WaitInterval::EXPONENTIAL_BACKOFF;
 }
 
 void SyncSchedulerImpl::OnThrottled(const base::TimeDelta& throttle_duration) {
   DCHECK(CalledOnValidThread());
@@ skipping 43 matching lines @@
   sessions_commit_delay_ = new_delay;
 }
 
 void SyncSchedulerImpl::OnReceivedClientInvalidationHintBufferSize(int size) {
   if (size > 0)
     nudge_tracker_.SetHintBufferSize(size);
   else
     NOTREACHED() << "Hint buffer size should be > 0.";
 }
 
-void SyncSchedulerImpl::OnActionableError(
-    const sessions::SyncSessionSnapshot& snap) {
+void SyncSchedulerImpl::OnSyncProtocolError(
+    const SyncProtocolError& sync_protocol_error) {
   DCHECK(CalledOnValidThread());
-  SDVLOG(2) << "OnActionableError";
-  SyncEngineEvent event(SyncEngineEvent::ACTIONABLE_ERROR);
-  event.snapshot = snap;
-  session_context_->NotifyListeners(event);
-}
-
-void SyncSchedulerImpl::OnSyncProtocolError(
-    const sessions::SyncSessionSnapshot& snapshot) {
-  DCHECK(CalledOnValidThread());
-  if (ShouldRequestEarlyExit(
-          snapshot.model_neutral_state().sync_protocol_error)) {
+  if (ShouldRequestEarlyExit(sync_protocol_error)) {
     SDVLOG(2) << "Sync Scheduler requesting early exit.";
     Stop();
   }
-  if (IsActionableError(snapshot.model_neutral_state().sync_protocol_error))
-    OnActionableError(snapshot);
+  if (IsActionableError(sync_protocol_error)) {
+    SDVLOG(2) << "OnActionableError";
+    FOR_EACH_OBSERVER(SyncEngineEventListener,
+                      *session_context_->listeners(),
+                      OnActionableError(sync_protocol_error));
+  }
 }
 
 void SyncSchedulerImpl::OnReceivedGuRetryDelay(const base::TimeDelta& delay) {
   nudge_tracker_.SetNextRetryTime(TimeTicks::Now() + delay);
   retry_timer_.Start(FROM_HERE, delay, this,
                      &SyncSchedulerImpl::RetryTimerCallback);
 }
 
 void SyncSchedulerImpl::SetNotificationsEnabled(bool notifications_enabled) {
   DCHECK(CalledOnValidThread());
@@ skipping 11 matching lines @@
 
 #undef SDVLOG_LOC
 
 #undef SDVLOG
 
 #undef SLOG
 
 #undef ENUM_CASE
 
 }  // namespace syncer