chrome/browser/chromeos/policy/heartbeat_scheduler.h

   1 // Copyright (c) 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_CHROMEOS_POLICY_HEARTBEAT_SCHEDULER_H_
   6 #define CHROME_BROWSER_CHROMEOS_POLICY_HEARTBEAT_SCHEDULER_H_
   7
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "base/cancelable_callback.h"
  12 #include "base/macros.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/memory/weak_ptr.h"
  15 #include "base/time/time.h"
  16 #include "chrome/browser/chromeos/settings/cros_settings.h"
  17 #include "components/gcm_driver/gcm_app_handler.h"
  18 #include "components/gcm_driver/gcm_client.h"
  19
  20 namespace base {
  21 class SequencedTaskRunner;
  22 }
  23
  24 namespace gcm {
  25 class GCMDriver;
  26 }
  27
  28 namespace policy {
  29
  30 class EnterpriseInstallAttributes;
  31 class HeartbeatRegistrationHelper;
  32
  33 // Class responsible for periodically sending heartbeats to the policy service
  34 // for monitoring device connectivity.
  35 class HeartbeatScheduler : public gcm::GCMAppHandler {
  36  public:
  37   // Default interval for how often we send up a heartbeat.
  38   static const int64 kDefaultHeartbeatIntervalMs;
  39
  40   // Constructor. |driver| can be null for tests.
  41   HeartbeatScheduler(
  42       gcm::GCMDriver* driver,
  43       const std::string& enrollment_domain,
  44       const std::string& device_id,
  45       const scoped_refptr<base::SequencedTaskRunner>& task_runner);
  46
  47   ~HeartbeatScheduler() override;
  48
  49   // Returns the time of the last heartbeat, or Time(0) if no heartbeat
  50   // has ever happened.
  51   base::Time last_heartbeat() const { return last_heartbeat_; }
  52
  53   // GCMAppHandler overrides.
  54   void ShutdownHandler() override;
  55   void OnMessage(const std::string& app_id,
  56                  const gcm::GCMClient::IncomingMessage& message) override;
  57   void OnMessagesDeleted(const std::string& app_id) override;
  58   void OnSendError(const std::string& app_id,
  59                    const gcm::GCMClient::SendErrorDetails& details) override;
  60   void OnSendAcknowledged(const std::string& app_id,
  61                           const std::string& message_id) override;
  62
  63  private:
  64   // Callback invoked periodically to send a heartbeat to the policy service.
  65   void SendHeartbeat();
  66
  67   // Invoked after GCM registration has successfully completed.
  68   void OnRegistrationComplete(const std::string& registration_id);
  69
  70   // Invoked after a heartbeat has been sent to the server.
  71   void OnHeartbeatSent(const std::string& message_id,
  72                        gcm::GCMClient::Result result);
  73
  74   // Helper method that figures out when the next heartbeat should
  75   // be scheduled.
  76   void ScheduleNextHeartbeat();
  77
  78   // Updates the heartbeat-enabled status and frequency from settings and
  79   // schedules the next heartbeat.
  80   void RefreshHeartbeatSettings();
  81
  82   // Ensures that the passed interval is within a valid range (not too large or
  83   // too small).
  84   base::TimeDelta EnsureValidHeartbeatInterval(const base::TimeDelta& interval);
  85
  86   // Shuts down our GCM connection (called when heartbeats are disabled).
  87   void ShutdownGCM();
  88
  89   // TaskRunner used for scheduling heartbeats.
  90   const scoped_refptr<base::SequencedTaskRunner> task_runner_;
  91
  92   // The domain that this device is enrolled to.
  93   const std::string enrollment_domain_;
  94
  95   // The device_id for this device - sent up with the enrollment domain with
  96   // heartbeats to identify the device to the server.
  97   const std::string device_id_;
  98
  99   // True if heartbeats are enabled. Kept cached in this object because
 100   // CrosSettings can switch to an untrusted state temporarily, and we want
 101   // to use the last-known trusted values.
 102   bool heartbeat_enabled_;
 103
 104   // Cached copy of the current heartbeat interval, in milliseconds.
 105   base::TimeDelta heartbeat_interval_;
 106
 107   // Observers to changes in the heartbeat settings.
 108   scoped_ptr<chromeos::CrosSettings::ObserverSubscription>
 109       heartbeat_frequency_observer_;
 110   scoped_ptr<chromeos::CrosSettings::ObserverSubscription>
 111       heartbeat_enabled_observer_;
 112
 113   // The time the last heartbeat was sent.
 114   base::Time last_heartbeat_;
 115
 116   // Callback invoked via a delay to send a heartbeat.
 117   base::CancelableClosure heartbeat_callback_;
 118
 119   // The GCMDriver used to send heartbeat messages.
 120   gcm::GCMDriver* const gcm_driver_;
 121
 122   // The GCM registration ID - if empty, we are not registered yet.
 123   std::string registration_id_;
 124
 125   // If true, we are already registered with GCM and should unregister when
 126   // destroyed.
 127   bool registered_app_handler_ = false;
 128
 129   // Helper class to manage registering with the GCM server, including
 130   // retries, etc.
 131   scoped_ptr<HeartbeatRegistrationHelper> registration_helper_;
 132
 133   // Note: This should remain the last member so it'll be destroyed and
 134   // invalidate the weak pointers before any other members are destroyed.
 135   base::WeakPtrFactory<HeartbeatScheduler> weak_factory_;
 136
 137   DISALLOW_COPY_AND_ASSIGN(HeartbeatScheduler);
 138 };
 139
 140 }  // namespace policy
 141
 142 #endif  // CHROME_BROWSER_CHROMEOS_POLICY_HEARTBEAT_SCHEDULER_H_