Implement device token fetcher

chrome/browser/policy/device_token_fetcher.h

Index: chrome/browser/policy/device_token_fetcher.h
diff --git a/chrome/browser/policy/device_token_fetcher.h b/chrome/browser/policy/device_token_fetcher.h
new file mode 100644
index 0000000000000000000000000000000000000000..f5a0770a5d2400fd994baebd7d50ea9f871dd3ed
--- /dev/null
+++ b/chrome/browser/policy/device_token_fetcher.h
@@ -0,0 +1,134 @@
+// 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.
+
+#ifndef CHROME_BROWSER_POLICY_DEVICE_TOKEN_FETCHER_H_
+#define CHROME_BROWSER_POLICY_DEVICE_TOKEN_FETCHER_H_
+#pragma once
+
+#include <string>
+
+#include "base/file_path.h"
+#include "base/non_thread_safe.h"
+#include "base/waitable_event.h"
+#include "chrome/common/notification_observer.h"
+#include "chrome/common/notification_registrar.h"
+#include "chrome/browser/policy/device_management_backend.h"
+
+namespace policy {
+
+namespace em = enterprise_management;
+
+// Abstracts how the path is determined where the DeviceTokenFetcher stores the
+// device token once it has been returned from the server. Tests provide a mock
+// implementation to the DeviceTokenFetcher that doesn't write to DIR_USER_DATA.
+class StoredDeviceTokenPathProvider {
+ public:
+  virtual ~StoredDeviceTokenPathProvider() {}
+
+  // Sets |path| to contain the path at which to use to store the device
+  // management token file. Returns true if successful, otherwise false.
+  virtual bool GetPath(FilePath* path) const = 0;
+ protected:
+  StoredDeviceTokenPathProvider() {}
+ private:
+  DISALLOW_COPY_AND_ASSIGN(StoredDeviceTokenPathProvider);
+};
+
+// Provides a path to the device token that's inside DIR_USER_DATA.
+class UserDirDeviceTokenPathProvider : public StoredDeviceTokenPathProvider {
+ public:
+  UserDirDeviceTokenPathProvider() {}
+  virtual ~UserDirDeviceTokenPathProvider() {}
+  virtual bool GetPath(FilePath* path) const;
+ private:
+  DISALLOW_COPY_AND_ASSIGN(UserDirDeviceTokenPathProvider);
+};
+
+// Fetches the device token that can be used for policy requests with the device
+// management server, either from disk if it already has been successfully
+// requested, otherwise from the device management server. An instance of the
+// fetcher is shared as a singleton by all users of the device management token
+// to ensure they all get the same token.
+class DeviceTokenFetcher
+    : public NonThreadSafe,
+      public NotificationObserver,
+      public DeviceManagementBackend::DeviceRegisterResponseDelegate {
+ public:
+  // Requests to the device management server are sent through |backend|.  The
+  // DeviceTokenFetcher assumes ownership of |backend|, which is passed in
+  // explicitly to simplify mocking of the backend for unit testing.  The
+  // fetcher uses |path_provider| to determine the directory in which the device
+  // token is stored once it's retrieved from the server. The fetcher assumes
+  // ownership of |path_provider|.
+  DeviceTokenFetcher(DeviceManagementBackend* backend,
+                     StoredDeviceTokenPathProvider* path_provider);
+  virtual ~DeviceTokenFetcher() {}
+
+  // NotificationObserver method overrides:
+  virtual void Observe(NotificationType type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details);
+
+  // DeviceManagementBackend::DeviceRegisterResponseDelegate method overrides:
+  virtual void HandleRegisterResponse(
+      const em::DeviceRegisterResponse& response);
+  virtual void OnError(DeviceManagementBackend::ErrorCode code);
+
+  // Called by subscribers of the device management token to indicate that they
+  // will need the token in the future.
+  void StartFetching();
+
+  // Returns true if there is a pending token request to the device management
+  // server.
+  bool IsTokenPending();
+
+  // Returns the device management token for this device, blocking until
+  // outstanding requests to the device management server are satisfied.  In the
+  // case that the token could not be fetched, an empty string is returned.
+  std::string GetDeviceToken();
+
+  // True if the device token has been fetched and is valid.
+  bool IsTokenValid() const;
+
+ private:
+  // The different states that the fetcher can be in during the process of
+  // getting the device token.
+  enum FetcherState {
+    kStateLoadDeviceTokenFromDisk,
+    kStateFetchingAuthToken,
+    kStateHasAuthToken,
+    kStateHasDeviceToken,
+    kStateFailure
+  };
+
+  // Moves the fetcher into a new state. If the fetcher has the device token
+  // or is moving into the failure state, callers waiting on WaitForToken
+  // are unblocked.
+  void SetState(FetcherState state);
+
+  // Saves the device management token to disk once it has been retrieved from
+  // the server. Must be called on the FILE thread.
+  static void WriteDeviceTokenToDisk(const FilePath& path,
+                                     const std::string& token);
+
+  // Returns the device ID used to register the device with the device
+  // management server and generate the device token.
+  static std::string GetDeviceID();
+
+  scoped_ptr<DeviceManagementBackend> backend_;
+  scoped_ptr<StoredDeviceTokenPathProvider> path_provider_;
+  FetcherState state_;
+  std::string device_token_;
+
+  // An event that is signaled only once the device token has been fetched
+  // or it has been determined that there was an error during fetching.
+  base::WaitableEvent device_token_load_complete_event_;
+
+  // Registers the fetcher for notification of successful Gaia logins.
+  NotificationRegistrar registrar_;
+};
+
+}  // namespace policy
+
+#endif  // CHROME_BROWSER_POLICY_DEVICE_TOKEN_FETCHER_H_