Even more virtual method deinlining.

chrome/browser/sync/engine/syncer_thread.cc

 // 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.
 #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>
@@ skipping 346 matching lines @@
     VLOG(1) << "Updating the next polling time after SyncMain";
     vault_.current_wait_interval_ = CalculatePollingWaitTime(
         static_cast<int>(vault_.current_wait_interval_.poll_delta.InSeconds()),
         &user_idle_milliseconds, &continue_sync_cycle, nudged);
   }
 #if defined(OS_LINUX)
   idle_query_.reset();
 #endif
 }
 
+void SyncerThread::SetConnected(bool connected) {
+  DCHECK(!thread_.IsRunning());
+  vault_.connected_ = connected;
+}
+
+void SyncerThread::SetSyncerPollingInterval(base::TimeDelta interval) {
+  // TODO(timsteele): Use TimeDelta internally.
+  syncer_polling_interval_ = static_cast<int>(interval.InSeconds());
+}
+
+void SyncerThread::SetSyncerShortPollInterval(base::TimeDelta interval) {
+  // TODO(timsteele): Use TimeDelta internally.
+  syncer_short_poll_interval_seconds_ =
+      static_cast<int>(interval.InSeconds());
+}
+
 void SyncerThread::WaitUntilConnectedOrQuit() {
   VLOG(1) << "Syncer thread waiting for connection.";
   Notify(SyncEngineEvent::SYNCER_THREAD_WAITING_FOR_CONNECTION);
 
   bool is_paused = vault_.paused_;
 
   while (!vault_.connected_ && !vault_.stop_syncer_thread_) {
     if (!is_paused && vault_.pause_requested_) {
       // If we get a pause request while waiting for a connection,
       // enter the paused state.
@@ skipping 44 matching lines @@
   Notify(SyncEngineEvent::SYNCER_THREAD_PAUSED);
 }
 
 void SyncerThread::ExitPausedState() {
   lock_.AssertAcquired();
   vault_.paused_ = false;
   vault_field_changed_.Broadcast();
   Notify(SyncEngineEvent::SYNCER_THREAD_RESUMED);
 }
 
+void SyncerThread::DisableIdleDetection() {
+  disable_idle_detection_ = true;
+}
+
 // We check how long the user's been idle and sync less often if the machine is
 // not in use. The aim is to reduce server load.
 SyncerThread::WaitInterval SyncerThread::CalculatePollingWaitTime(
     int last_poll_wait,  // Time in seconds.
     int* user_idle_milliseconds,
     bool* continue_sync_cycle,
     bool was_nudged) {
   lock_.AssertAcquired();  // We access 'vault' in here, so we need the lock.
   WaitInterval return_interval;
 
@@ skipping 382 matching lines @@
     was_logged = true;
     VLOG(1) << "UserIdleTime unimplemented on this platform, synchronization "
                "will not throttle when user idle";
   }
 #endif
 
   return 0;
 }
 
 }  // namespace browser_sync