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

chrome/browser/sync/engine/syncer_proto_util.cc

 // Copyright (c) 2006-2008 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/syncer_proto_util.h"
 
 #include "chrome/browser/sync/engine/net/server_connection_manager.h"
 #include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/engine/syncer_util.h"
 #include "chrome/browser/sync/protocol/service_constants.h"
+#include "chrome/browser/sync/sessions/sync_session.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/syncable-inl.h"
 #include "chrome/browser/sync/syncable/syncable.h"
 
 using std::string;
 using std::stringstream;
 using syncable::BASE_VERSION;
 using syncable::CTIME;
 using syncable::ID;
 using syncable::IS_DEL;
 using syncable::IS_DIR;
 using syncable::IS_UNSYNCED;
 using syncable::MTIME;
 using syncable::PARENT_ID;
 using syncable::ScopedDirLookup;
 using syncable::SyncName;
 
 namespace browser_sync {
+using sessions::SyncSession;
 
 namespace {
 
 // Time to backoff syncing after receiving a throttled response.
 static const int kSyncDelayAfterThrottled = 2 * 60 * 60;  // 2 hours
 
 // Verifies the store birthday, alerting/resetting as appropriate if there's a
 // mismatch.
 bool VerifyResponseBirthday(const ScopedDirLookup& dir,
                             const ClientToServerResponse* response) {
@@ skipping 47 matching lines @@
           response.profiling_data().total_request_time() << "ms";
     }
     LOG(INFO) << response_trace.str();
   }
 }
 
 }  // namespace
 
 // static
 bool SyncerProtoUtil::PostClientToServerMessage(ClientToServerMessage* msg,
-    ClientToServerResponse* response, SyncerSession* session) {
+    ClientToServerResponse* response, SyncSession* session) {
   bool rv = false;
   string tx, rx;
   CHECK(response);
 
-  ScopedDirLookup dir(session->dirman(), session->account_name());
+  ScopedDirLookup dir(session->context()->directory_manager(),
+      session->context()->account_name());
   if (!dir.good())
     return false;
   string birthday = dir->store_birthday();
   if (!birthday.empty()) {
     msg->set_store_birthday(birthday);
   } else {
     LOG(INFO) << "no birthday set";
   }
 
   msg->SerializeToString(&tx);
   HttpResponse http_response;
   ServerConnectionManager::PostBufferParams params = {
     tx, &rx, &http_response
   };
 
-  if (!session->connection_manager()->PostBufferWithCachedAuth(&params)) {
+  ServerConnectionManager* scm = session->context()->connection_manager();
+  if (!scm->PostBufferWithCachedAuth(&params)) {
     LOG(WARNING) << "Error posting from syncer:" << http_response;
   } else {
     rv = response->ParseFromString(rx);
   }
-  SyncerStatus status(session);
   if (rv) {
     if (!VerifyResponseBirthday(dir, response)) {
       // TODO(ncarter): Add a unit test for the case where the syncer becomes
       // stuck due to a bad birthday.
-      status.set_syncer_stuck(true);
+      session->status_controller()->set_syncer_stuck(true);
       return false;
     }
 
     switch (response->error_code()) {
       case ClientToServerResponse::SUCCESS:
         if (!response->has_store_birthday() && birthday.empty()) {
           LOG(ERROR) <<
             "Server didn't provide birthday in proto buffer response.";
           rv = false;
         }
         LogResponseProfilingData(*response);
         break;
       case ClientToServerResponse::USER_NOT_ACTIVATED:
       case ClientToServerResponse::AUTH_INVALID:
       case ClientToServerResponse::ACCESS_DENIED:
         LOG(INFO) << "Authentication expired, re-requesting";
         LOG(INFO) << "Not implemented in syncer yet!!!";
-        status.AuthFailed();
+        session->set_auth_failure_occurred();
         rv = false;
         break;
       case ClientToServerResponse::NOT_MY_BIRTHDAY:
         LOG(WARNING) << "Not my birthday return.";
         rv = false;
         break;
       case ClientToServerResponse::THROTTLED:
         LOG(WARNING) << "Client silenced by server.";
-        session->set_silenced_until(base::TimeTicks::Now() +
+        session->delegate()->OnSilencedUntil(base::TimeTicks::Now() +
             base::TimeDelta::FromSeconds(kSyncDelayAfterThrottled));
         rv = false;
         break;
       default:
         NOTREACHED();
         break;
     }
 
   }
   return rv;
@@ skipping 85 matching lines @@
     const CommitResponse_EntryResponse& entry) {
 
   if (entry.has_non_unique_name()) {
       return entry.non_unique_name();
   }
 
   return entry.name();
 }
 
 }  // namespace browser_sync