Unplumb AllStatus from SyncerThread.

chrome/browser/sync/engine/syncer_thread.h

 // 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.
 //
 // A class to run the syncer on a thread.
 // This is the default implementation of SyncerThread whose Stop implementation
 // does not support a timeout, but is greatly simplified.
 #ifndef CHROME_BROWSER_SYNC_ENGINE_SYNCER_THREAD_H_
 #define CHROME_BROWSER_SYNC_ENGINE_SYNCER_THREAD_H_
 #pragma once
 
 #include <list>
 #include <map>
 #include <queue>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/condition_variable.h"
 #include "base/gtest_prod_util.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/thread.h"
 #include "base/time.h"
 #include "base/waitable_event.h"
-#include "chrome/browser/sync/engine/all_status.h"
 #if defined(OS_LINUX)
 #include "chrome/browser/sync/engine/idle_query_linux.h"
 #endif
 #include "chrome/browser/sync/sessions/sync_session.h"
 #include "chrome/common/deprecated/event_sys-inl.h"
 
 class EventListenerHookup;
 
 namespace syncable {
 class DirectoryManager;
@@ skipping 60 matching lines @@
     kContinuation
   };
   // Server can overwrite these values via client commands.
   // Standard short poll. This is used when XMPP is off.
   static const int kDefaultShortPollIntervalSeconds;
   // Long poll is used when XMPP is on.
   static const int kDefaultLongPollIntervalSeconds;
   // 30 minutes by default. If exponential backoff kicks in, this is the
   // longest possible poll interval.
   static const int kDefaultMaxPollIntervalMs;
+  // Maximum interval for exponential backoff.
+  static const int kMaxBackoffSeconds;
 
-  SyncerThread(sessions::SyncSessionContext* context, AllStatus* all_status);
+  explicit SyncerThread(sessions::SyncSessionContext* context);
   virtual ~SyncerThread();
 
   virtual void WatchConnectionManager(ServerConnectionManager* conn_mgr);
 
   // Starts a syncer thread.
   // Returns true if it creates a thread or if there's currently a thread
   // running and false otherwise.
   virtual bool Start();
 
   // Stop processing. |max_wait| doesn't do anything in this version.
@@ skipping 13 matching lines @@
   virtual bool RequestResume();
 
   // Nudges the syncer to sync with a delay specified. This API is for access
   // from the SyncerThread's controller and will cause a mutex lock.
   virtual void NudgeSyncer(int milliseconds_from_now, NudgeSource source);
 
   void SetNotificationsEnabled(bool notifications_enabled);
 
   virtual SyncerEventChannel* relay_channel();
 
+  // DDOS avoidance function.  The argument and return value is in seconds
+  static int GetRecommendedDelaySeconds(int base_delay_seconds);
+
  protected:
   virtual void ThreadMain();
   void ThreadMainLoop();
 
   virtual void SetConnected(bool connected) {
     DCHECK(!thread_.IsRunning());
     vault_.connected_ = connected;
   }
 
   virtual void SetSyncerPollingInterval(base::TimeDelta interval) {
@@ skipping 96 matching lines @@
   // Calculates the next sync wait time and exponential backoff state.
   // last_poll_wait is the time duration of the previous polling timeout which
   // was used. user_idle_milliseconds is updated by this method, and is a report
   // of the full amount of time since the last period of activity for the user.
   // The continue_sync_cycle parameter is used to determine whether or not we
   // are calculating a polling wait time that is a continuation of an sync cycle
   // which terminated while the syncer still had work to do. was_nudged is used
   // in case of exponential backoff so we only allow one nudge per backoff
   // interval.
   WaitInterval CalculatePollingWaitTime(
-      const AllStatus::Status& status,
       int last_poll_wait,  // in s
       int* user_idle_milliseconds,
       bool* continue_sync_cycle,
       bool was_nudged);
 
   // Helper to above function, considers effect of user idle time.
   virtual int CalculateSyncWaitTime(int last_wait, int user_idle_ms);
 
   // Sets the source value of the controlled syncer's updates_source value.
   // The initial sync boolean is updated if read as a sentinel.  The following
@@ skipping 26 matching lines @@
   // This sets all conditions for syncer thread termination but does not
   // actually join threads.  It is expected that Stop will be called at some
   // time after to fully stop and clean up.
   void RequestSyncerExitAndSetThreadStopConditions();
 
   // State of the notification framework is tracked by these values.
   bool p2p_authenticated_;
   bool p2p_subscribed_;
 
   scoped_ptr<EventListenerHookup> conn_mgr_hookup_;
-  const AllStatus* allstatus_;
 
   // Modifiable versions of kDefaultLongPollIntervalSeconds which can be
   // updated by the server.
   int syncer_short_poll_interval_seconds_;
   int syncer_long_poll_interval_seconds_;
 
   // The time we wait between polls in seconds. This is used as lower bound on
   // our wait time. Updated once per loop from the command line flag.
   int syncer_polling_interval_;
 
@@ skipping 32 matching lines @@
 
   // Useful for unit tests
   bool disable_idle_detection_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncerThread);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_ENGINE_SYNCER_THREAD_H_