New authorization framework for sync. ...

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 "chrome/browser/sync/engine/auth_watcher.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/protocol/service_constants.h"
 #include "chrome/browser/sync/sessions/session_state.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/common/deprecated/event_sys-inl.h"
 #include "jingle/notifier/listener/talk_mediator.h"
 
 namespace browser_sync {
@@ skipping 19 matching lines @@
                          channel_(new Channel(shutdown_event)) {
   status_.initial_sync_ended = true;
   status_.notifications_enabled = false;
 }
 
 AllStatus::~AllStatus() {
   syncer_thread_hookup_.reset();
   delete channel_;
 }
 
-void AllStatus::WatchConnectionManager(ServerConnectionManager* conn_mgr) {
-  conn_mgr_hookup_.reset(NewEventListenerHookup(conn_mgr->channel(), this,
-                         &AllStatus::HandleServerConnectionEvent));
-}
-
 void AllStatus::WatchSyncerThread(SyncerThread* syncer_thread) {
   syncer_thread_hookup_.reset(syncer_thread == NULL ? NULL :
       syncer_thread->relay_channel()->AddObserver(this));
 }
 
 AllStatus::Status AllStatus::CreateBlankStatus() const {
   Status status = status_;
   status.syncing = true;
   status.unsynced_count = 0;
   status.conflicting_count = 0;
@@ skipping 26 matching lines @@
 
   // 100 is an arbitrary limit.
   if (errors.consecutive_transient_error_commits > 100)
     status.server_broken = true;
 
   status.updates_available += snapshot->num_server_changes_remaining;
   status.updates_received += snapshot->max_local_timestamp;
   return status;
 }
 
-AllStatus::Status AllStatus::CalcSyncing() const {
-  return CreateBlankStatus();
-}
-
 int AllStatus::CalcStatusChanges(Status* old_status) {
   int what_changed = 0;
 
   // Calculate what changed and what the new icon should be.
   if (status_.syncing != old_status->syncing)
     what_changed |= AllStatusEvent::SYNCING;
   if (status_.unsynced_count != old_status->unsynced_count)
     what_changed |= AllStatusEvent::UNSYNCED_COUNT;
   if (status_.server_up != old_status->server_up)
     what_changed |= AllStatusEvent::SERVER_UP;
@@ skipping 30 matching lines @@
 
   if (status_.icon != old_status->icon)
     what_changed |= AllStatusEvent::ICON;
 
   if (0 == what_changed)
     return 0;
   *old_status = status_;
   return what_changed;
 }
 
-void AllStatus::HandleAuthWatcherEvent(const AuthWatcherEvent& auth_event) {
-  ScopedStatusLockWithNotify lock(this);
-  switch (auth_event.what_happened) {
-    case AuthWatcherEvent::GAIA_AUTH_FAILED:
-    case AuthWatcherEvent::SERVICE_AUTH_FAILED:
-    case AuthWatcherEvent::SERVICE_CONNECTION_FAILED:
-    case AuthWatcherEvent::AUTHENTICATION_ATTEMPT_START:
-      status_.authenticated = false;
-      break;
-    case AuthWatcherEvent::AUTH_SUCCEEDED:
-      // If we've already calculated that the server is reachable, since we've
-      // successfully authenticated, we can be confident that the server is up.
-      if (status_.server_reachable)
-        status_.server_up = true;
-
-      if (!status_.authenticated) {
-        status_.authenticated = true;
-        status_ = CalcSyncing();
-      } else {
-        lock.set_notify_plan(DONT_NOTIFY);
-      }
-      break;
-    default:
-      lock.set_notify_plan(DONT_NOTIFY);
-      break;
-  }
-}
-
 void AllStatus::HandleChannelEvent(const SyncerEvent& event) {
   ScopedStatusLockWithNotify lock(this);
   switch (event.what_happened) {
     case SyncerEvent::COMMITS_SUCCEEDED:
       break;
     case SyncerEvent::SYNC_CYCLE_ENDED:
     case SyncerEvent::STATUS_CHANGED:
       status_ = CalcSyncing(event);
       break;
     case SyncerEvent::SHUTDOWN_USE_WITH_CARE:
@@ skipping 21 matching lines @@
       break;
   }
 }
 
 void AllStatus::HandleServerConnectionEvent(
     const ServerConnectionEvent& event) {
   if (ServerConnectionEvent::STATUS_CHANGED == event.what_happened) {
     ScopedStatusLockWithNotify lock(this);
     status_.server_up = IsGoodReplyFromServer(event.connection_code);
     status_.server_reachable = event.server_reachable;
+
+    if (event.connection_code == HttpResponse::SERVER_CONNECTION_OK) {
+      if (!status_.authenticated) {
+        status_ = CreateBlankStatus();
+      }
+      status_.authenticated = true;
+    } else {
+      status_.authenticated = false;
+    }
   }
 }
 
 AllStatus::Status AllStatus::status() const {
   AutoLock lock(mutex_);
   return status_;
 }
 
 void AllStatus::SetNotificationsEnabled(bool notifications_enabled) {
   ScopedStatusLockWithNotify lock(this);
@@ skipping 26 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