Relieve SyncerSession,SyncCycleState, SyncProcessState, SyncerSession, Syncer...

chrome/browser/sync/engine/all_status.cc

 // Copyright (c) 2006-2009 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/engine/all_status.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/port.h"
 #include "base/rand_util.h"
 #include "chrome/browser/sync/engine/auth_watcher.h"
 #include "chrome/browser/sync/engine/net/gaia_authenticator.h"
 #include "chrome/browser/sync/engine/net/server_connection_manager.h"
 #include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/engine/syncer_thread.h"
 #include "chrome/browser/sync/engine/syncproto.h"
 #include "chrome/browser/sync/notifier/listener/talk_mediator.h"
 #include "chrome/browser/sync/protocol/service_constants.h"
+#include "chrome/browser/sync/sessions/session_state.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/util/event_sys-inl.h"
 
 namespace browser_sync {
 
 static const time_t kMinSyncObserveInterval = 10;  // seconds
 
 // Backoff interval randomization factor.
 static const int kBackoffRandomizationFactor = 2;
 
@@ skipping 35 matching lines @@
 }
 
 void AllStatus::WatchAuthWatcher(AuthWatcher* auth_watcher) {
   authwatcher_hookup_.reset(
       NewEventListenerHookup(auth_watcher->channel(), this,
                              &AllStatus::HandleAuthWatcherEvent));
 }
 
 void AllStatus::WatchSyncerThread(SyncerThread* syncer_thread) {
   syncer_thread_hookup_.reset(
-      NewEventListenerHookup(syncer_thread->channel(), this,
+      NewEventListenerHookup(syncer_thread->relay_channel(), this,
                              &AllStatus::HandleSyncerEvent));
 }
 
 AllStatus::Status AllStatus::CreateBlankStatus() const {
   Status status = status_;
   status.syncing = true;
   status.unsynced_count = 0;
   status.conflicting_count = 0;
   status.initial_sync_ended = false;
   status.syncer_stuck = false;
   status.max_consecutive_errors = 0;
   status.server_broken = false;
   status.updates_available = 0;
   status.updates_received = 0;
   return status;
 }
 
 AllStatus::Status AllStatus::CalcSyncing(const SyncerEvent &event) const {
   Status status = CreateBlankStatus();
-  SyncerStatus syncerStatus(event.last_session);
-  status.unsynced_count += static_cast<int>(syncerStatus.unsynced_count());
-  status.conflicting_count += syncerStatus.conflicting_commits();
+  const sessions::SyncSessionSnapshot* snapshot = event.snapshot;
+  status.unsynced_count += static_cast<int>(snapshot->unsynced_count);
+  status.conflicting_count += snapshot->errors.num_conflicting_commits;
   // The syncer may not be done yet, which could cause conflicting updates.
   // But this is only used for status, so it is better to have visibility.
-  status.conflicting_count += syncerStatus.conflicting_updates();
+  status.conflicting_count += snapshot->num_conflicting_updates;
 
-  status.syncing |= syncerStatus.syncing();
-  // Show a syncer as syncing if it's got stalled updates.
-  status.syncing = event.last_session->HasMoreToSync() &&
-      event.last_session->silenced_until().is_null();
-  status.initial_sync_ended |= syncerStatus.IsShareUsable();
-  status.syncer_stuck |= syncerStatus.syncer_stuck();
-  if (syncerStatus.consecutive_errors() > status.max_consecutive_errors)
-    status.max_consecutive_errors = syncerStatus.consecutive_errors();
+  status.syncing |= snapshot->syncer_status.syncing;
+  status.syncing = snapshot->has_more_to_sync && snapshot->is_silenced;
+  status.initial_sync_ended |= snapshot->is_share_usable;
+  status.syncer_stuck |= snapshot->syncer_status.syncer_stuck;
+
+  const sessions::ErrorCounters& errors(snapshot->errors);
+  if (errors.consecutive_errors > status.max_consecutive_errors)
+    status.max_consecutive_errors = errors.consecutive_errors;
 
   // 100 is an arbitrary limit.
-  if (syncerStatus.consecutive_transient_error_commits() > 100)
+  if (errors.consecutive_transient_error_commits > 100)
     status.server_broken = true;
 
-  status.updates_available += syncerStatus.num_server_changes_remaining();
-  status.updates_received += syncerStatus.current_sync_timestamp();
+  const sessions::ChangelogProgress& progress(snapshot->changelog_progress);
+  status.updates_available += progress.num_server_changes_remaining;
+  status.updates_received += progress.current_sync_timestamp;
   return status;
 }
 
 AllStatus::Status AllStatus::CalcSyncing() const {
   return CreateBlankStatus();
 }
 
 int AllStatus::CalcStatusChanges(Status* old_status) {
   int what_changed = 0;
 
@@ skipping 202 matching lines @@
   allstatus_->mutex_.Release();
   if (event_.what_changed)
     allstatus_->channel()->NotifyListeners(event_);
 }
 
 void ScopedStatusLockWithNotify::NotifyOverQuota() {
   event_.what_changed |= AllStatusEvent::OVER_QUOTA;
 }
 
 }  // namespace browser_sync