sync: beginnings of MessageLoop based SyncerThread

chrome/browser/sync/sessions/sync_session.h

 // Copyright (c) 2010 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.
 
 // A class representing an attempt to synchronize the local syncable data
 // store with a sync server. A SyncSession instance is passed as a stateful
 // bundle to and from various SyncerCommands with the goal of converging the
 // client view of data with that of the server. The commands twiddle with
 // session status in response to events and hiccups along the way, set and
 // query session progress with regards to conflict resolution and applying
@@ skipping 17 matching lines @@
 #include "chrome/browser/sync/util/extensions_activity_monitor.h"
 
 namespace syncable {
 class WriteTransaction;
 }
 
 namespace browser_sync {
 class ModelSafeWorker;
 
 namespace sessions {
-typedef std::pair<sync_pb::GetUpdatesCallerInfo::GetUpdatesSource,
-    syncable::ModelTypeBitSet> SyncSourceInfo;
 
 class SyncSession {
  public:
   // The Delegate services events that occur during the session requiring an
   // explicit (and session-global) action, as opposed to events that are simply
   // recorded in per-session state.
   class Delegate {
    public:
     // The client was throttled and should cease-and-desist syncing activity
     // until the specified time.
@@ skipping 35 matching lines @@
               const std::vector<ModelSafeWorker*>& workers);
   ~SyncSession();
 
   // Builds a thread-safe and read-only copy of the current session state.
   SyncSessionSnapshot TakeSnapshot() const;
 
   // Returns true if this session contains data that should go through the sync
   // engine again.
   bool HasMoreToSync() const;
 
-  SyncSessionContext* context() { return context_; }
-  Delegate* delegate() { return delegate_; }
+  // Collects all state pertaining to how and why |s| originated and unions it
+  // with corresponding state in |this|, leaving |s| unchanged.  Allows |this|
+  // to take on the responsibilities |s| had (e.g. certain data types) in the
+  // next SyncShare operation using |this|, rather than needed two separate
+  // sessions.
+  void Coalesce(const SyncSession& session);
+
+  // Should be called any time |this| is being re-used in a new call to
+  // SyncShare (e.g., HasMoreToSync returned true).
+  void ResetTransientState();
+
+  SyncSessionContext* context() const { return context_; }
+  Delegate* delegate() const { return delegate_; }
   syncable::WriteTransaction* write_transaction() { return write_transaction_; }
   StatusController* status_controller() { return status_controller_.get(); }
 
   const ExtensionsActivityMonitor::Records& extensions_activity() const {
     return extensions_activity_;
   }
   ExtensionsActivityMonitor::Records* mutable_extensions_activity() {
     return &extensions_activity_;
   }
 
@@ skipping 24 matching lines @@
   // Used to allow various steps to share a transaction. Can be NULL.
   syncable::WriteTransaction* write_transaction_;
 
   // The delegate for this session, must never be NULL.
   Delegate* delegate_;
 
   // Our controller for various status and error counters.
   scoped_ptr<StatusController> status_controller_;
 
   // The set of active ModelSafeWorkers for the duration of this session.
-  const std::vector<ModelSafeWorker*> workers_;
+  // This can change if this session is Coalesce()'d with another.
+  std::vector<ModelSafeWorker*> workers_;
 
   // The routing info for the duration of this session, dictating which
   // datatypes should be synced and which workers should be used when working
   // on those datatypes.
-  const ModelSafeRoutingInfo routing_info_;
+  ModelSafeRoutingInfo routing_info_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncSession);
 };
 
 // Installs a WriteTransaction to a given session and later clears it when the
 // utility falls out of scope. Transactions are not nestable, so it is an error
 // to try and use one of these if the session already has a transaction.
 class ScopedSetSessionWriteTransaction {
  public:
   ScopedSetSessionWriteTransaction(SyncSession* session,
                                    syncable::WriteTransaction* trans)
       : session_(session) {
     DCHECK(!session_->write_transaction_);
     session_->write_transaction_ = trans;
   }
   ~ScopedSetSessionWriteTransaction() { session_->write_transaction_ = NULL; }
 
  private:
   SyncSession* session_;
   DISALLOW_COPY_AND_ASSIGN(ScopedSetSessionWriteTransaction);
 };
 
 }  // namespace sessions
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_SESSIONS_SYNC_SESSION_H_