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

chrome/browser/sync/engine/syncapi.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/syncapi.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <iphlpapi.h>
 #endif
 
 #include <iomanip>
 #include <list>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/platform_thread.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/sync/engine/all_status.h"
 #include "chrome/browser/sync/engine/auth_watcher.h"
 #include "chrome/browser/sync/engine/change_reorder_buffer.h"
-#include "chrome/browser/sync/engine/client_command_channel.h"
 #include "chrome/browser/sync/engine/model_safe_worker.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/net/syncapi_server_connection_manager.h"
 #include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/engine/syncer_thread.h"
 #include "chrome/browser/sync/notifier/listener/talk_mediator.h"
 #include "chrome/browser/sync/notifier/listener/talk_mediator_impl.h"
 #include "chrome/browser/sync/protocol/service_constants.h"
+#include "chrome/browser/sync/sessions/sync_session_context.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/syncable.h"
 #include "chrome/browser/sync/util/character_set_converters.h"
 #include "chrome/browser/sync/util/closure.h"
 #include "chrome/browser/sync/util/crypto_helpers.h"
 #include "chrome/browser/sync/util/event_sys.h"
 #include "chrome/browser/sync/util/path_helpers.h"
 #include "chrome/browser/sync/util/user_settings.h"
 
 #if defined(OS_WIN)
 #pragma comment(lib, "iphlpapi.lib")
 #endif
 
 using browser_sync::AllStatus;
 using browser_sync::AllStatusEvent;
 using browser_sync::AuthWatcher;
 using browser_sync::AuthWatcherEvent;
-using browser_sync::ClientCommandChannel;
 using browser_sync::Syncer;
 using browser_sync::SyncerEvent;
-using browser_sync::SyncerStatus;
 using browser_sync::SyncerThread;
-using browser_sync::SyncerThreadFactory;
 using browser_sync::UserSettings;
 using browser_sync::TalkMediator;
 using browser_sync::TalkMediatorImpl;
+using browser_sync::sessions::SyncSessionContext;
 using std::list;
 using std::hex;
 using std::string;
 using std::vector;
 using syncable::Directory;
 using syncable::DirectoryManager;
 
 typedef GoogleServiceAuthError AuthError;
 
 static const int kServerReachablePollingIntervalMsec = 60000 * 60;
@@ skipping 566 matching lines @@
   scoped_ptr<HttpPostProviderFactory> post_factory_;
   DISALLOW_COPY_AND_ASSIGN(BridgedGaiaAuthenticator);
 };
 
 //////////////////////////////////////////////////////////////////////////
 // SyncManager's implementation: SyncManager::SyncInternal
 class SyncManager::SyncInternal {
  public:
   explicit SyncInternal(SyncManager* sync_manager)
       : observer_(NULL),
-        command_channel_(0),
         auth_problem_(AuthError::NONE),
         sync_manager_(sync_manager),
         address_watch_thread_("SyncEngine_AddressWatcher"),
         notification_pending_(false),
         initialized_(false) {
   }
 
   ~SyncInternal() { }
 
   bool Init(const FilePath& database_location,
@@ skipping 150 matching lines @@
   UserShare share_;
 
   // A wrapper around a sqlite store used for caching authentication data,
   // last user information, current sync-related URLs, and more.
   scoped_ptr<UserSettings> user_settings_;
 
   // Observer registered via SetObserver/RemoveObserver.
   // WARNING: This can be NULL!
   Observer* observer_;
 
-  // A sink for client commands from the syncer needed to create a SyncerThread.
-  ClientCommandChannel command_channel_;
-
   // The ServerConnectionManager used to abstract communication between the
   // client (the Syncer) and the sync server.
   scoped_ptr<SyncAPIServerConnectionManager> connection_manager_;
 
   // The thread that runs the Syncer. Needs to be explicitly Start()ed.
   scoped_refptr<SyncerThread> syncer_thread_;
 
   // Notification (xmpp) handler.
   scoped_ptr<TalkMediator> talk_mediator_;
 
@@ skipping 155 matching lines @@
                                   gaia_url,
                                   user_settings_.get(),
                                   gaia_auth,
                                   talk_mediator());
 
   talk_mediator()->WatchAuthWatcher(auth_watcher());
   allstatus()->WatchAuthWatcher(auth_watcher());
   authwatcher_hookup_.reset(NewEventListenerHookup(auth_watcher_->channel(),
       this, &SyncInternal::HandleAuthWatcherEvent));
 
-  // Tell the SyncerThread to use the ModelSafeWorker for bookmark model work.
+  // Build a SyncSessionContext and store the worker in it.
   // We set up both sides of the "bridge" here, with the ModelSafeWorkerBridge
   // on the Syncer side, and |model_safe_worker| on the API client side.
   ModelSafeWorkerBridge* worker = new ModelSafeWorkerBridge(model_safe_worker);
+  SyncSessionContext* context = new SyncSessionContext(
+      connection_manager_.get(), dir_manager(), worker);
 
-  syncer_thread_ = SyncerThreadFactory::Create(&command_channel_,
-                                               dir_manager(),
-                                               connection_manager(),
-                                               &allstatus_,
-                                               worker);
+  // The SyncerThread takes ownership of |context|.
+  syncer_thread_ = new SyncerThread(context, &allstatus_);
   syncer_thread()->WatchTalkMediator(talk_mediator());
   allstatus()->WatchSyncerThread(syncer_thread());
 
   syncer_thread()->Start();  // Start the syncer thread. This won't actually
                              // result in any syncing until at least the
                              // DirectoryManager broadcasts the OPENED event,
                              // and a valid server connection is detected.
 
   if (attempt_last_user_authentication)
     AuthenticateForLastKnownUser();
@@ skipping 288 matching lines @@
         allstatus()->status().max_consecutive_errors};
   return return_status;
 }
 
 void SyncManager::SyncInternal::HandleSyncerEvent(const SyncerEvent& event) {
   if (!initialized()) {
     // We get here if A) We have successfully authenticated at least once
     // (because we attach HandleSyncerEvent only once we receive notification
     // of successful authentication [locally or otherwise]), but B) the initial
     // sync had not completed at that time.
-    if (SyncerStatus(event.last_session).IsShareUsable())
+    if (event.snapshot->is_share_usable)
       MarkAndNotifyInitializationComplete();
     return;
   }
 
   if (!observer_)
     return;
 
   // Only send an event if this is due to a cycle ending and this cycle
   // concludes a canonical "sync" process; that is, based on what is known
   // locally we are "all happy" and up-to-date.  There may be new changes on
   // the server, but we'll get them on a subsequent sync.
   //
   // Notifications are sent at the end of every sync cycle, regardless of
   // whether we should sync again.
   if (event.what_happened == SyncerEvent::SYNC_CYCLE_ENDED) {
-    if (!event.last_session->HasMoreToSync()) {
+    if (!event.snapshot->has_more_to_sync) {
       observer_->OnSyncCycleCompleted();
     }
 
-    // TODO(chron): Consider changing this back to track HasMoreToSync
-    // Only notify peers if a successful commit has occurred.
-    if (event.last_session && event.last_session->HadSuccessfulCommits()) {
+    // TODO(chron): Consider changing this back to track has_more_to_sync
+    // only notify peers if a successful commit has occurred.
+    if (event.snapshot->syncer_status.num_successful_commits > 0) {
       // We use a member variable here because talk may not have connected yet.
       // The notification must be stored until it can be sent.
       notification_pending_ = true;
     }
 
     // SyncCycles are started by the following events: creation of the syncer,
     // (re)connection to buzz, local changes, peer notifications of updates.
     // Peers will be notified of changes made while there is no buzz connection
     // immediately after a connection has been re-established.
     // the next sync cycle.
     // TODO(brg): Move this to TalkMediatorImpl as a SyncerThread event hook.
     if (notification_pending_ && talk_mediator()) {
         LOG(INFO) << "Sending XMPP notification...";
         bool success = talk_mediator()->SendNotification();
         if (success) {
           notification_pending_ = false;
         }
     } else {
       LOG(INFO) << "Didn't send XMPP notification!"
-                   << " event.last_session: " << event.last_session
-                   << " event.last_session->items_committed(): "
-                   << event.last_session->items_committed()
+                   << " event.snapshot.did_commit_items: "
+                   << event.snapshot->did_commit_items
                    << " talk_mediator(): " << talk_mediator();
     }
   }
 }
 
 void SyncManager::SyncInternal::HandleAuthWatcherEvent(
     const AuthWatcherEvent& event) {
   // We don't care about an authentication attempt starting event, and we
   // don't want to reset our state to GoogleServiceAuthError::NONE because the
   // fact that an _attempt_ is starting doesn't change the fact that we have an
@@ skipping 30 matching lines @@
         dir_change_hookup_.reset(NewEventListenerHookup(
             lookup->changes_channel(), this,
             &SyncInternal::HandleChangeEvent));
 
         if (lookup->initial_sync_ended())
           MarkAndNotifyInitializationComplete();
       }
       {
         // Start watching the syncer channel directly here.
         DCHECK(syncer_thread() != NULL);
-        syncer_event_.reset(NewEventListenerHookup(syncer_thread()->channel(),
-            this, &SyncInternal::HandleSyncerEvent));
+        syncer_event_.reset(
+            NewEventListenerHookup(syncer_thread()->relay_channel(), this,
+                &SyncInternal::HandleSyncerEvent));
       }
       return;
     // Authentication failures translate to GoogleServiceAuthError events.
     case AuthWatcherEvent::GAIA_AUTH_FAILED:     // Invalid GAIA credentials.
       if (event.auth_results->auth_error == browser_sync::CaptchaRequired) {
         auth_problem_ = AuthError::CAPTCHA_REQUIRED;
         std::string url_string("http://www.google.com/accounts/");
         url_string += event.auth_results->captcha_url;
         GURL captcha(url_string);
         observer_->OnAuthError(AuthError::FromCaptchaChallenge(
@@ skipping 83 matching lines @@
 BaseTransaction::~BaseTransaction() {
   delete lookup_;
 }
 
 UserShare* SyncManager::GetUserShare() const {
   DCHECK(data_->initialized()) << "GetUserShare requires initialization!";
   return data_->GetUserShare();
 }
 
 }  // namespace sync_api