components: Introduce AlarmTimer class and use it for GCM heartbeat

base/timer/timer.h

 // Copyright (c) 2012 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.
 
 // OneShotTimer and RepeatingTimer provide a simple timer API.  As the names
 // suggest, OneShotTimer calls you back once after a time delay expires.
 // RepeatingTimer on the other hand calls you back periodically with the
 // prescribed time interval.
 //
 // OneShotTimer and RepeatingTimer both cancel the timer when they go out of
@@ skipping 96 matching lines @@
  protected:
   // Used to initiate a new delayed task.  This has the side-effect of disabling
   // scheduled_task_ if it is non-null.
   void SetTaskInfo(const tracked_objects::Location& posted_from,
                    TimeDelta delay,
                    const base::Closure& user_task);
 
   bool retain_user_task() const { return retain_user_task_; }
   bool is_repeating() const { return is_repeating_; }
 
+  // Location in user code.
+  tracked_objects::Location posted_from_;
+  // Delay requested by user.
+  TimeDelta delay_;
+  // user_task_ is what the user wants to be run at desired_run_time_.
+  base::Closure user_task_;
+
+  // The desired run time of user_task_. The user may update this at any time,
+  // even if their previous request has not run yet. If desired_run_time_ is
+  // greater than scheduled_run_time_, a continuation task will be posted to
+  // wait for the remaining time. This allows us to reuse the pending task so as
+  // not to flood the MessageLoop with orphaned tasks when the user code
+  // excessively Stops and Starts the timer. This time can be a "zero" TimeTicks
+  // if the task must be run immediately.
+  TimeTicks desired_run_time_;
+
+  // Repeating timers automatically post the task again before calling the task
+  // callback.
+  const bool is_repeating_;

[Lei Zhang, 2014/10/21 22:34:11]

You can leave it in private: and call is_repeating() instead. Same for
|retain_user_task_|

[Chirantan Ekbote, 2014/10/21 22:52:21]

Acknowledged.

+
+  // If true, hold on to |user_task_| for reuse.
+  const bool retain_user_task_;
+
+  // If true, |user_task_| is scheduled to run sometime in the future.
+  bool is_running_;

[blundell, 2014/10/22 13:46:24]

To follow the pattern, I would make a getter for is_running_.

[Chirantan Ekbote, 2014/10/22 18:47:14]

But we also need to set |is_running_|.  So I guess my question is:  Is it better
to have a getter/setter for common variables or is it better to make them
protected?  In the case of |is_repeating_| and |retain_user_task_|, those
variables are const so there's no real reason for them to be in protected.

[blundell, 2014/10/23 05:54:20]

Google style is actually definitive on this point:
http://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Access_Control

[Chirantan Ekbote, 2014/10/23 23:53:30]

Done.

+
  private:
   friend class BaseTimerTaskInternal;
 
   // Allocates a new scheduled_task_ and posts it on the current MessageLoop
   // with the given |delay|. scheduled_task_ must be NULL. scheduled_run_time_
   // and desired_run_time_ are reset to Now() + delay.
   void PostNewScheduledTask(TimeDelta delay);
 
   // Disable scheduled_task_ and abandon it so that it no longer refers back to
   // this object.
   void AbandonScheduledTask();
 
   // Called by BaseTimerTaskInternal when the MessageLoop runs it.
   void RunScheduledTask();
 
   // Stop running task (if any) and abandon scheduled task (if any).
   void StopAndAbandon() {
     Stop();
     AbandonScheduledTask();
   }
 
   // When non-NULL, the scheduled_task_ is waiting in the MessageLoop to call
   // RunScheduledTask() at scheduled_run_time_.
   BaseTimerTaskInternal* scheduled_task_;
 
-  // Location in user code.
-  tracked_objects::Location posted_from_;
-  // Delay requested by user.
-  TimeDelta delay_;
-  // user_task_ is what the user wants to be run at desired_run_time_.
-  base::Closure user_task_;
-
   // The estimated time that the MessageLoop will run the scheduled_task_ that
   // will call RunScheduledTask(). This time can be a "zero" TimeTicks if the
   // task must be run immediately.
   TimeTicks scheduled_run_time_;
 
-  // The desired run time of user_task_. The user may update this at any time,
-  // even if their previous request has not run yet. If desired_run_time_ is
-  // greater than scheduled_run_time_, a continuation task will be posted to
-  // wait for the remaining time. This allows us to reuse the pending task so as
-  // not to flood the MessageLoop with orphaned tasks when the user code
-  // excessively Stops and Starts the timer. This time can be a "zero" TimeTicks
-  // if the task must be run immediately.
-  TimeTicks desired_run_time_;
-
   // Thread ID of current MessageLoop for verifying single-threaded usage.
   int thread_id_;
 
-  // Repeating timers automatically post the task again before calling the task
-  // callback.
-  const bool is_repeating_;
-
-  // If true, hold on to the user_task_ closure object for reuse.
-  const bool retain_user_task_;
-
-  // If true, user_task_ is scheduled to run sometime in the future.
-  bool is_running_;
-
   DISALLOW_COPY_AND_ASSIGN(Timer);
 };
 
 //-----------------------------------------------------------------------------
 // This class is an implementation detail of OneShotTimer and RepeatingTimer.
 // Please do not use this class directly.
 template <class Receiver, bool kIsRepeating>
 class BaseTimerMethodPointer : public Timer {
  public:
   typedef void (Receiver::*ReceiverMethod)();
@@ skipping 52 matching lines @@
       : Timer(posted_from, delay,
               base::Bind(method, base::Unretained(receiver)),
               false) {}
 
   void Reset() { Timer::Reset(); }
 };
 
 }  // namespace base
 
 #endif  // BASE_TIMER_TIMER_H_