Persist 'this device is not managed' information

chrome/browser/policy/device_management_policy_provider.h

 // 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_MANAGEMENT_POLICY_PROVIDER_H_
 #define CHROME_BROWSER_POLICY_DEVICE_MANAGEMENT_POLICY_PROVIDER_H_
 #pragma once
 
 #include <string>
 
@@ skipping 38 matching lines @@
 
   // DeviceTokenFetcher::Observer implementation:
   void OnTokenSuccess();
   void OnTokenError();
   void OnNotManaged();
 
   // True if a policy request has been sent to the device management backend
   // server and no response or error has yet been received.
   bool IsPolicyRequestPending() const { return policy_request_pending_; }
 
-  // Returns true if the policy cache is empty and hence no policies are
-  // available.
-  bool IsPolicyCacheEmpty() const;
-
-  // Returns true if the device management policy provider has an empty policy
-  // cache and is waiting for a pending policy request to retrive the inital
-  // set of policies. If cached policies are available false is returned even in
-  // the case of a pending policy request.
+  // Returns true if the device management policy provider is currently waiting
+  // for the first attempt to fetch policies to complete.

[markusheintz_, 2010/11/25 17:49:44]

Should we mention that the method also returns true even if the request wasn't
issued yet? This is the case right?

[Jakob Kummerow, 2010/11/26 09:17:23]

Strictly speaking, yes. But the request is issued immediately (that is, as soon
as the IOThread is available). Also, I'd argue that the current formulation
covers that situation. But we can make it more explicit if you wish.

   bool WaitingForInitialPolicies() const;
 
   // Tells the provider that the passed in token service reference is about to
   // become invalid.
   void Shutdown();
 
  private:
   class InitializeAfterIOThreadExistsTask;
   class RefreshTask;
 
@@ skipping 16 matching lines @@
   // Triggers policy refresh, re-requesting device token and policy information
   // as necessary.
   void RefreshTaskExecute();
 
   // Schedules a new RefreshTask.
   void ScheduleRefreshTask(int64 delay_in_milliseconds);
 
   // Calculates when the next RefreshTask shall be executed.
   int64 GetRefreshTaskDelay();
 
+  void StopWaitingForInitialPolicies();
+
 #if defined(OS_CHROMEOS)
   // Sent a CLOUD_POLICY_UPDATE notification.
   void NotifyCloudPolicyUpdate() const;
 #endif
 
+  static FilePath GetUnmanagedDeviceMarkerPath(const FilePath& storage_dir);
+  static void CreateUnmanagedDeviceMarker(const FilePath& storage_dir,
+                                          const base::Time& timestamp);
+  static void DeleteUnmanagedDeviceMarker(const FilePath& storage_dir);
+  bool UnmanagedDeviceMarkerExists();
+  base::Time GetUnmanagedDeviceTimestamp();
+
   // Provides the URL at which requests are sent to from the device management
   // backend.
   static std::string GetDeviceManagementURL();
 
   // Returns the path to the sub-directory in the user data directory
   // in which device management persistent state is stored.
   static FilePath GetOrCreateDeviceManagementDir(
       const FilePath& user_data_dir);
 
   // Give unit tests the ability to override timeout settings.
   void set_policy_refresh_rate_ms(int64 policy_refresh_rate_ms) {
     policy_refresh_rate_ms_ = policy_refresh_rate_ms;
   }
   void set_policy_refresh_max_earlier_ms(int64 policy_refresh_max_earlier_ms) {
     policy_refresh_max_earlier_ms_ = policy_refresh_max_earlier_ms;
   }
   void set_policy_refresh_error_delay_ms(int64 policy_refresh_error_delay_ms) {
     policy_refresh_error_delay_ms_ = policy_refresh_error_delay_ms;
   }
   void set_token_fetch_error_delay_ms(int64 token_fetch_error_delay_ms) {
     token_fetch_error_delay_ms_ = token_fetch_error_delay_ms;
   }
+  void set_unmanaged_device_refresh_rate_ms(
+      int64 unmanaged_device_refresh_rate_ms) {
+    unmanaged_device_refresh_rate_ms_ = unmanaged_device_refresh_rate_ms;

[danno, 2010/11/25 16:35:01]

Can you use a new private/protected constructor for these that's only called by
the tests? I think I'd like that better.

[Jakob Kummerow, 2010/11/26 09:17:23]

Done.

+  }
 
   scoped_ptr<DeviceManagementBackend> backend_;
   TokenService* token_service_;  // weak
   scoped_ptr<DeviceManagementPolicyCache> cache_;
   scoped_refptr<DeviceTokenFetcher> token_fetcher_;
   DeviceTokenFetcher::ObserverRegistrar registrar_;
   FilePath storage_dir_;
   bool policy_request_pending_;
   bool refresh_task_pending_;
+  bool waiting_for_initial_policies_;
   int64 policy_refresh_rate_ms_;
   int64 policy_refresh_max_earlier_ms_;
   int64 policy_refresh_error_delay_ms_;
   int64 token_fetch_error_delay_ms_;
+  int64 unmanaged_device_refresh_rate_ms_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceManagementPolicyProvider);
 };
 
 }  // namespace policy
 
 #endif  // CHROME_BROWSER_POLICY_DEVICE_MANAGEMENT_POLICY_PROVIDER_H_