Second attempt at the new syncer thread impl, now with less crashes!...

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/at_exit.h"
 #include "base/basictypes.h"
+#include "base/command_line.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.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"
@@ skipping 15 matching lines @@
 
 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 std::list;
 using std::hex;
 using std::string;
 using std::vector;
 using syncable::Directory;
 using syncable::DirectoryManager;
 
@@ skipping 800 matching lines @@
   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_ptr<SyncerThread> syncer_thread_;
+  scoped_refptr<SyncerThread> syncer_thread_;
 
   // Notification (xmpp) handler.
   scoped_ptr<TalkMediator> talk_mediator_;
 
   // A multi-purpose status watch object that aggregates stats from various
   // sync components.
   AllStatus allstatus_;
 
   // AuthWatcher kicks off the authentication process and follows it through
   // phase 1 (GAIA) to phase 2 (sync engine). As part of this work it determines
@@ skipping 101 matching lines @@
     HttpPostProviderFactory* auth_post_factory,
     ModelSafeWorkerInterface* model_safe_worker,
     bool attempt_last_user_authentication,
     const char* user_agent) {
 
   if (!g_log_files_initialized) {
     // TODO(timsteele): Call InitLogFiles() or equivalent.
     g_log_files_initialized = true;
   }
 
+  // TODO(timsteele): We need to do this for syncapi.dll, but should remove
+  // once we link statically.  On windows this will set up the correct command
+  // line, on posix it will be create an empty command line.
+  CommandLine::Init(0, NULL);
+
   // Set up UserSettings, creating the db if necessary. We need this to
   // instantiate a URLFactory to give to the Syncer.
   PathString settings_db_file = AppendSlash(database_location) +
                                 kBookmarkSyncUserSettingsDatabase;
   user_settings_.reset(new UserSettings());
   if (!user_settings_->Init(settings_db_file))
     return false;
 
   share_.dir_manager.reset(new DirectoryManager(database_location));
 
@@ skipping 48 matching lines @@
   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.
   // 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);
 
-  syncer_thread_.reset(new SyncerThread(&command_channel_,
-                                        dir_manager(),
-                                        connection_manager(),
-                                        &allstatus_,
-                                        worker));
+  syncer_thread_ = SyncerThreadFactory::Create(&command_channel_,
+                                               dir_manager(),
+                                               connection_manager(),
+                                               &allstatus_,
+                                               worker);
   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 479 matching lines @@
 BaseTransaction::~BaseTransaction() {
   delete lookup_;
 }
 
 UserShare* SyncManager::GetUserShare() const {
   DCHECK(data_->initialized()) << "GetUserShare requires initialization!";
   return data_->GetUserShare();
 }
 
 }  // namespace sync_api