1 // Copyright (c) 2011 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_POLICY_DEVICE_TOKEN_FETCHER_H_ 6 #define CHROME_BROWSER_POLICY_DEVICE_TOKEN_FETCHER_H_ 7 #pragma once 8 9 #include <string> 10 11 #include "base/memory/scoped_ptr.h" 12 #include "base/observer_list.h" 13 #include "base/task.h" 14 #include "chrome/browser/policy/device_management_backend.h" 15 #include "chrome/browser/policy/policy_notifier.h" 16 #include "chrome/browser/policy/proto/device_management_backend.pb.h" 17 18 namespace policy { 19 20 class CloudPolicyCacheBase; 21 class DeviceManagementService; 22 23 namespace em = enterprise_management; 24 25 // Fetches the device token that can be used for policy requests with the device 26 // management server, either from disk if it already has been successfully 27 // requested, otherwise from the device management server. An instance of the 28 // fetcher is shared as a singleton by all users of the device management token 29 // to ensure they all get the same token. 30 class DeviceTokenFetcher 31 : public DeviceManagementBackend::DeviceRegisterResponseDelegate { 32 public: 33 class Observer { 34 public: ~Observer()35 virtual ~Observer() {} 36 virtual void OnDeviceTokenAvailable() = 0; 37 }; 38 39 // |service| is used to talk to the device management service and |cache| is 40 // used to persist whether the device is unmanaged. 41 DeviceTokenFetcher(DeviceManagementService* service, 42 CloudPolicyCacheBase* cache, 43 PolicyNotifier* notifier); 44 // Version for tests that allows to set timing parameters. 45 DeviceTokenFetcher(DeviceManagementService* service, 46 CloudPolicyCacheBase* cache, 47 PolicyNotifier* notifier, 48 int64 token_fetch_error_delay_ms, 49 int64 token_fetch_error_max_delay_ms, 50 int64 unmanaged_device_refresh_rate_ms); 51 virtual ~DeviceTokenFetcher(); 52 53 // Starts fetching a token. 54 // Declared virtual so it can be overridden by mocks. 55 virtual void FetchToken(const std::string& auth_token, 56 const std::string& device_id, 57 em::DeviceRegisterRequest_Type policy_type, 58 const std::string& machine_id, 59 const std::string& machine_model); 60 61 virtual void SetUnmanagedState(); 62 63 // Returns the device management token or the empty string if not available. 64 // Declared virtual so it can be overridden by mocks. 65 virtual const std::string& GetDeviceToken(); 66 67 // Disables the auto-retry-on-error behavior of this token fetcher. 68 void StopAutoRetry(); 69 70 void AddObserver(Observer* observer); 71 void RemoveObserver(Observer* observer); 72 73 // DeviceManagementBackend::DeviceRegisterResponseDelegate method overrides: 74 virtual void HandleRegisterResponse( 75 const em::DeviceRegisterResponse& response); 76 virtual void OnError(DeviceManagementBackend::ErrorCode code); 77 78 private: 79 friend class DeviceTokenFetcherTest; 80 81 // The different states that the fetcher can be in during the process of 82 // getting the device token. |state_| is initialized to INACTIVE, depending 83 // on the result of a token fetching attempt can transition to either of 84 // TOKEN_AVAILABLE, UNMANAGED, or ERROR. The first attempt must be triggered 85 // externally. When |state_| is UNMANAGED, a new fetching attempt is 86 // performed every |unmanaged_device_refresh_rate_ms_|; when it's ERROR, 87 // a new attempt is done after |effective_token_fetch_error_delay_ms_|. 88 enum FetcherState { 89 // Fetcher inactive. 90 STATE_INACTIVE, 91 // Token available. 92 STATE_TOKEN_AVAILABLE, 93 // Device unmanaged. 94 STATE_UNMANAGED, 95 // Error, retry later. 96 STATE_ERROR, 97 // Temporary error. Retry sooner. 98 STATE_TEMPORARY_ERROR, 99 // Server rejected the auth token. 100 STATE_BAD_AUTH 101 }; 102 103 // Common initialization helper. 104 void Initialize(DeviceManagementService* service, 105 CloudPolicyCacheBase* cache, 106 PolicyNotifier* notifier, 107 int64 token_fetch_error_delay_ms, 108 int64 token_fetch_error_max_delay_ms, 109 int64 unmanaged_device_refresh_rate_ms); 110 111 // Moves the fetcher into a new state. 112 void SetState(FetcherState state); 113 114 // Resets |backend_|, then uses |auth_token_| and |device_id_| to perform 115 // an actual token fetch. 116 void FetchTokenInternal(); 117 118 // Called back from the |retry_task_|. 119 void ExecuteRetryTask(); 120 121 // Cancels the |retry_task_|. 122 void CancelRetryTask(); 123 124 // Service and backend. A new backend is created whenever the fetcher gets 125 // reset. 126 DeviceManagementService* service_; // weak 127 scoped_ptr<DeviceManagementBackend> backend_; 128 129 // Reference to the cache. Used to persist and read unmanaged state. 130 CloudPolicyCacheBase* cache_; 131 132 PolicyNotifier* notifier_; 133 134 // Refresh parameters. 135 int64 token_fetch_error_delay_ms_; 136 int64 token_fetch_error_max_delay_ms_; 137 int64 effective_token_fetch_error_delay_ms_; 138 int64 unmanaged_device_refresh_rate_ms_; 139 140 // State the fetcher is currently in. 141 FetcherState state_; 142 143 // Current device token. 144 std::string device_token_; 145 146 // Contains the AuthToken for the device management server. 147 std::string auth_token_; 148 // Device identifier to send to the server. 149 std::string device_id_; 150 // Contains policy type to send to the server. 151 em::DeviceRegisterRequest_Type policy_type_; 152 // Contains physical machine id to send to the server. 153 std::string machine_id_; 154 // Contains physical machine model to send to server. 155 std::string machine_model_; 156 157 // Task that has been scheduled to retry fetching a token. 158 CancelableTask* retry_task_; 159 160 ScopedRunnableMethodFactory<DeviceTokenFetcher> method_factory_; 161 162 ObserverList<Observer, true> observer_list_; 163 }; 164 165 } // namespace policy 166 167 #endif // CHROME_BROWSER_POLICY_DEVICE_TOKEN_FETCHER_H_ 168