Refresh policies from DM server periodically

chrome/browser/policy/device_token_fetcher.cc

 // 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.
 
 #include "chrome/browser/policy/device_token_fetcher.h"
 
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/singleton.h"
 #include "chrome/browser/guid.h"
@@ skipping 69 matching lines @@
   }
 }
 
 void DeviceTokenFetcher::OnError(DeviceManagementBackend::ErrorCode code) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // For privacy reasons, delete all identifying data when this device is not
   // managed.
   if (code == DeviceManagementBackend::kErrorServiceManagementNotSupported) {
     device_token_ = std::string();
     device_id_ = std::string();
-    file_util::Delete(token_path_, false);
+    // This line is necessary to work around Windows compiler weirdness.

[danno, 2010/11/23 12:10:14]

Perhaps something more specific like: Without the following explicit type for
file_util::Delete, the Windows compiler is unable to properly match to the
correct NewRunnableFunction specialization and generates an error.

[Jakob Kummerow (corp), 2010/11/23 12:25:26]

Done.
I changed the whole workaround to a solution Mattias considers more elegant,
namely explicit instantiation of the NewRunnableFunction<> template.

+    bool (*delete_function) (const FilePath&, bool) = &file_util::Delete;
+    BrowserThread::PostTask(
+        BrowserThread::FILE,
+        FROM_HERE,
+        NewRunnableFunction(delete_function, token_path_, false));
+    SetState(kStateNotManaged);
+    return;
   }
   SetState(kStateFailure);
 }
 
+void DeviceTokenFetcher::Restart() {
+  DCHECK(!IsTokenPending());
+  device_token_.clear();
+  device_token_load_complete_event_.Reset();
+  MakeReadyToRequestDeviceToken();
+}
+
 void DeviceTokenFetcher::StartFetching() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (state_ == kStateNotStarted) {
     SetState(kStateLoadDeviceTokenFromDisk);
     // The file calls for loading the persisted token must be deferred to the
     // FILE thread.
     BrowserThread::PostTask(
         BrowserThread::FILE,
         FROM_HERE,
         NewRunnableMethod(this,
@@ skipping 74 matching lines @@
   return device_id_;
 }
 
 void DeviceTokenFetcher::SetState(FetcherState state) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (state_ == state)
     return;
   state_ = state;
   if (state == kStateFailure) {
     device_token_load_complete_event_.Signal();
+    NotifyTokenError();
+  } else if (state == kStateNotManaged) {
+    device_token_load_complete_event_.Signal();
+    NotifyNotManaged();
   } else if (state == kStateHasDeviceToken) {
     device_token_load_complete_event_.Signal();
-    NotificationService::current()->Notify(
-        NotificationType::DEVICE_TOKEN_AVAILABLE,
-        Source<DeviceTokenFetcher>(this),
-        NotificationService::NoDetails());
+    NotifyTokenSuccess();
   }
 }
 
 void DeviceTokenFetcher::GetDeviceTokenPath(FilePath* token_path) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   *token_path = token_path_;
 }
 
 bool DeviceTokenFetcher::IsTokenValid() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 13 matching lines @@
   DCHECK(no_error);
   file_util::WriteFile(path, data.c_str(), data.length());
 }
 
 // static
 std::string DeviceTokenFetcher::GenerateNewDeviceID() {
   return guid::GenerateGUID();
 }
 
 }  // namespace policy