Initial RemoteCommandsInvalidator

chrome/browser/policy/cloud/remote_commands_invalidator.h

Index: chrome/browser/policy/cloud/remote_commands_invalidator.h
diff --git a/chrome/browser/policy/cloud/remote_commands_invalidator.h b/chrome/browser/policy/cloud/remote_commands_invalidator.h
new file mode 100644
index 0000000000000000000000000000000000000000..1eea5c01e1235d83668d6d212000b0871098d561
--- /dev/null
+++ b/chrome/browser/policy/cloud/remote_commands_invalidator.h
@@ -0,0 +1,130 @@
+// Copyright 2015 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.
+
+#ifndef CHROME_BROWSER_POLICY_CLOUD_REMOTE_COMMANDS_INVALIDATOR_H_
+#define CHROME_BROWSER_POLICY_CLOUD_REMOTE_COMMANDS_INVALIDATOR_H_
+
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
+#include "base/threading/thread_checker.h"
+#include "components/invalidation/invalidation_handler.h"
+#include "google/cacheinvalidation/include/types.h"
+#include "policy/proto/device_management_backend.pb.h"
+
+namespace base {
+class SequencedTaskRunner;
+}  // namespace base
+
+namespace invalidation {
+class InvalidationService;
+}  // namespace invalidation
+
+namespace policy {
+
+// Base class for RemoteCommandsInvalidator, this class doesn't interact with

[bartfab (slow), 2015/05/15 15:55:08]

Nit: Update the comment:
1) The class was renamed.
2) This is not really a base for "subclasses" (plural) to build on. It is the
guts of the implementation with a few methods abstracted out for easier mocking.

[binjin, 2015/05/15 16:12:40]

Done.

+// CloudPolicyStore and CloudPolicyCore directly. Instead, several interface
+// functions are provided, to allow subclasses to integrate with cloud policy
+// infrastructure.
+class RemoteCommandsInvalidator : public syncer::InvalidationHandler {
+ public:
+  // |task_runner| will be used to post DoRemoteCommandsFetch() tasks.
+  explicit RemoteCommandsInvalidator(
+      const scoped_refptr<base::SequencedTaskRunner>& task_runner);
+  ~RemoteCommandsInvalidator() override;
+
+  // Initialize this invalidator to pair with |invalidation_service|. Must be
+  // called before Start().
+  void Initialize(invalidation::InvalidationService* invalidation_service);
+
+  // Shutdown this invalidator. Will stop the invalidator first, and after
+  // shutting down, the invalidator can't be started anymore.
+  void Shutdown();
+
+  // Starts to process the invalidations.
+  void Start();
+
+  // Stops to process the invalidation. Must be called after Start().
+  void Stop();
+
+  // Helpful accessors.
+  invalidation::InvalidationService* invalidation_service() {
+    return invalidation_service_;
+  }
+  bool invalidations_enabled() { return invalidations_enabled_; }
+
+  // syncer::InvalidationHandler:
+  void OnInvalidatorStateChange(syncer::InvalidatorState state) override;
+  void OnIncomingInvalidation(
+      const syncer::ObjectIdInvalidationMap& invalidation_map) override;
+  std::string GetOwnerName() const override;
+
+ protected:
+  // Subclasses should override the following functions, if they want to get
+  // notified on corresponding events.
+  virtual void OnInitialize() = 0;
+  virtual void OnShutdown() = 0;
+  virtual void OnStart() = 0;
+  virtual void OnStop() = 0;
+
+  // Subclasses must override this method to implements the actual remote
+  // commands fetch. A callback to this function will be posted to
+  // |task_runner_|.
+  virtual void DoRemoteCommandsFetch() = 0;
+
+  // Subclasses must call this function to set the object id for remote command
+  // invalidations.
+  void ReloadPolicyData(const enterprise_management::PolicyData* policy);
+
+ private:
+  // Registers the given object with the invalidation service.
+  void Register(const invalidation::ObjectId& object_id);
+
+  // Unregisters the current object with the invalidation service.
+  void Unregister();
+
+  // Updates invalidations_enabled_.
+  void UpdateInvalidationsEnabled();
+
+  // The state of the object.
+  enum State {
+    SHUT_DOWN,
+    STOPPED,
+    STARTED,
+  };
+  State state_ = SHUT_DOWN;
+
+  // Schedules delayed tasks.
+  const scoped_refptr<base::SequencedTaskRunner> task_runner_;
+
+  // The invalidation service.
+  invalidation::InvalidationService* invalidation_service_ = nullptr;
+
+  // Whether the invalidator currently has the ability to receive invalidations.
+  // This is true if the invalidation service is enabled and the invalidator
+  // has registered for a remote commands object.
+  bool invalidations_enabled_ = false;
+
+  // Whether the invalidation service is currently enabled.
+  bool invalidation_service_enabled_ = false;
+
+  // Whether this object has registered for remote commands invalidations.
+  bool is_registered_ = false;
+
+  // The object id representing the remote commands in the invalidation service.
+  invalidation::ObjectId object_id_;
+
+  // A thread checker to make sure that callbacks are invoked on the correct
+  // thread.
+  base::ThreadChecker thread_checker_;
+
+  // WeakPtrFactory used to create callbacks to this object.
+  base::WeakPtrFactory<RemoteCommandsInvalidator> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(RemoteCommandsInvalidator);
+};
+
+}  // namespace policy
+
+#endif  // CHROME_BROWSER_POLICY_CLOUD_REMOTE_COMMANDS_INVALIDATOR_H_