New authorization framework for sync. ...

chrome/browser/sync/engine/syncer_thread.cc

 // Copyright (c) 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/syncer_thread.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_MACOSX)
 #include <CoreFoundation/CFNumber.h>
 #include <IOKit/IOTypes.h>
 #include <IOKit/IOKitLib.h>
 #endif
 
 #include <algorithm>
 #include <map>
 #include <queue>
 
 #include "base/rand_util.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
-#include "chrome/browser/sync/engine/auth_watcher.h"
 #include "chrome/browser/sync/engine/model_safe_worker.h"
 #include "chrome/browser/sync/engine/net/server_connection_manager.h"
 #include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/sessions/session_state.h"
-#include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/common/chrome_switches.h"
 #include "jingle/notifier/listener/notification_constants.h"
 
 using std::priority_queue;
 using std::min;
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace browser_sync {
@@ skipping 32 matching lines @@
     : thread_main_started_(false, false),
       thread_("SyncEngine_SyncerThread"),
       vault_field_changed_(&lock_),
       p2p_authenticated_(false),
       p2p_subscribed_(false),
       conn_mgr_hookup_(NULL),
       syncer_short_poll_interval_seconds_(kDefaultShortPollIntervalSeconds),
       syncer_long_poll_interval_seconds_(kDefaultLongPollIntervalSeconds),
       syncer_polling_interval_(kDefaultShortPollIntervalSeconds),
       syncer_max_interval_(kDefaultMaxPollIntervalMs),
-      directory_manager_hookup_(NULL),
       syncer_events_(NULL),
       session_context_(context),
       disable_idle_detection_(false) {
   DCHECK(context);
   syncer_event_relay_channel_.reset(new SyncerEventChannel());
 
-  if (context->directory_manager()) {
-    directory_manager_hookup_.reset(NewEventListenerHookup(
-        context->directory_manager()->channel(), this,
-            &SyncerThread::HandleDirectoryManagerEvent));
-  }
-
   if (context->connection_manager())
     WatchConnectionManager(context->connection_manager());
 
 }
 
 SyncerThread::~SyncerThread() {
   conn_mgr_hookup_.reset();
   syncer_event_relay_channel_->Notify(SyncerEvent(
       SyncerEvent::SHUTDOWN_USE_WITH_CARE));
   syncer_event_relay_channel_.reset();
-  directory_manager_hookup_.reset();
   syncer_events_.reset();
   delete vault_.syncer_;
   CHECK(!thread_.IsRunning());
 }
 
 // Creates and starts a syncer thread.
 // Returns true if it creates a thread or if there's currently a thread running
 // and false otherwise.
 bool SyncerThread::Start() {
   {
@@ skipping 468 matching lines @@
 
 void SyncerThread::HandleChannelEvent(const SyncerEvent& event) {
   AutoLock lock(lock_);
   relay_channel()->Notify(event);
   if (SyncerEvent::REQUEST_SYNC_NUDGE != event.what_happened) {
     return;
   }
   NudgeSyncImpl(event.nudge_delay_milliseconds, kUnknown);
 }
 
-void SyncerThread::HandleDirectoryManagerEvent(
-    const syncable::DirectoryManagerEvent& event) {
-  LOG(INFO) << "Handling a directory manager event";
-  if (syncable::DirectoryManagerEvent::OPENED == event.what_happened) {
-    AutoLock lock(lock_);
-    LOG(INFO) << "Syncer starting up for: " << event.dirname;
-    // The underlying database structure is ready, and we should create
-    // the syncer.
-    CHECK(vault_.syncer_ == NULL);
-    session_context_->set_account_name(event.dirname);
-    vault_.syncer_ = new Syncer(session_context_.get());
+void SyncerThread::CreateSyncer(const std::string& dirname) {
+  AutoLock lock(lock_);
+  LOG(INFO) << "Creating syncer up for: " << dirname;
+  // The underlying database structure is ready, and we should create
+  // the syncer.
+  CHECK(vault_.syncer_ == NULL);
+  session_context_->set_account_name(dirname);
+  vault_.syncer_ = new Syncer(session_context_.get());
 
-    syncer_events_.reset(
-        session_context_->syncer_event_channel()->AddObserver(this));
-    vault_field_changed_.Broadcast();
-  }
+  syncer_events_.reset(
+      session_context_->syncer_event_channel()->AddObserver(this));
+  vault_field_changed_.Broadcast();
 }
 
 // Sets |*connected| to false if it is currently true but |code| suggests that
 // the current network configuration and/or auth state cannot be used to make
 // forward progress, and user intervention (e.g changing server URL or auth
 // credentials) is likely necessary.  If |*connected| is false, set it to true
 // if |code| suggests that we just recently made healthy contact with the
 // server.
 static inline void CheckConnected(bool* connected,
                                   HttpResponse::ServerConnectionCode code,
@@ skipping 176 matching lines @@
     was_logged = true;
     LOG(INFO) << "UserIdleTime unimplemented on this platform, "
         "synchronization will not throttle when user idle";
   }
 #endif
 
   return 0;
 }
 
 }  // namespace browser_sync