Use chrome/base synchronization primitives and threads instead of...

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>
@@ skipping 35 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 169 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