CrOS policies: Store device ID with device token

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"
 #include "chrome/browser/net/gaia/token_service.h"
+#include "chrome/browser/policy/proto/device_management_local.pb.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/notification_details.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_source.h"
 #include "chrome/common/notification_type.h"
 
 namespace policy {
 
+namespace em = enterprise_management;
+
 DeviceTokenFetcher::DeviceTokenFetcher(
     DeviceManagementBackend* backend,
     const FilePath& token_path)
     : token_path_(token_path),
       backend_(backend),
       state_(kStateNotStarted),
       device_token_load_complete_event_(true, false) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // The token fetcher gets initialized AuthTokens for the device management
   // server are available. Install a notification observer to ensure that the
@@ skipping 26 matching lines @@
     const em::DeviceRegisterResponse& response) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_EQ(kStateRequestingDeviceTokenFromServer, state_);
   if (response.has_device_management_token()) {
     device_token_ = response.device_management_token();
     BrowserThread::PostTask(
         BrowserThread::FILE,
         FROM_HERE,
         NewRunnableFunction(&WriteDeviceTokenToDisk,
                             token_path_,
-                            device_token_));
+                            device_token_,
+                            device_id_));
     SetState(kStateHasDeviceToken);
   } else {
     NOTREACHED();
     SetState(kStateFailure);
   }
 }
 
 void DeviceTokenFetcher::OnError(DeviceManagementBackend::ErrorCode code) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   SetState(kStateFailure);
@@ skipping 10 matching lines @@
         FROM_HERE,
         NewRunnableMethod(this,
                           &DeviceTokenFetcher::AttemptTokenLoadFromDisk));
   }
 }
 
 void DeviceTokenFetcher::AttemptTokenLoadFromDisk() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   FetcherState new_state = kStateFailure;
   if (file_util::PathExists(token_path_)) {
-    std::string device_token;
-    if (file_util::ReadFileToString(token_path_, &device_token_)) {
+    std::string data;
+    em::DeviceToken stored_device_token;
+    if (file_util::ReadFileToString(token_path_, &data) &&
+        stored_device_token.ParseFromArray(data.c_str(), data.size())) {
+      device_token_ = stored_device_token.device_token();
+      device_id_ = stored_device_token.device_id();
       new_state = kStateHasDeviceToken;
     }
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         NewRunnableMethod(this,
                           &DeviceTokenFetcher::SetState,
                           new_state));
     return;
   }
@@ skipping 11 matching lines @@
   SendServerRequestIfPossible();
 }
 
 void DeviceTokenFetcher::SendServerRequestIfPossible() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (state_ == kStateReadyToRequestDeviceTokenFromServer
       && HasAuthToken()) {
     em::DeviceRegisterRequest register_request;
     SetState(kStateRequestingDeviceTokenFromServer);
     backend_->ProcessRegisterRequest(auth_token_,
-                                     GenerateNewDeviceID(),
+                                     GetDeviceID(),
                                      register_request,
                                      this);
   }
 }
 
 bool DeviceTokenFetcher::IsTokenPending() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return !device_token_load_complete_event_.IsSignaled();
 }
 
 std::string DeviceTokenFetcher::GetDeviceToken() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   device_token_load_complete_event_.Wait();
   return device_token_;
 }
 
+std::string DeviceTokenFetcher::GetDeviceID() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  // As long as access to this is only allowed from the UI thread, no explicit
+  // locking is necessary to prevent the ID from being generated twice.
+  if (device_id_.empty()) {
+    device_id_ = GenerateNewDeviceID();
+  }

[Mattias Nissler (ping if slow), 2010/11/15 18:02:51]

no curlies needed here.

[Jakob Kummerow (corp), 2010/11/16 09:37:02]

Alright, alright, I give up.
Done.

[Mattias Nissler (ping if slow), 2010/11/16 09:58:14]

:)

+  return device_id_;
+}
+
 void DeviceTokenFetcher::SetState(FetcherState state) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (state_ == state)
+  if (state_ == state) {
     return;
+  }

[Mattias Nissler (ping if slow), 2010/11/15 18:02:51]

Same here? Or do you have a reason for changing the style?

[Jakob Kummerow (corp), 2010/11/16 09:37:02]

Done.

   state_ = state;
   if (state == kStateFailure) {
     device_token_load_complete_event_.Signal();
   } else if (state == kStateHasDeviceToken) {
     device_token_load_complete_event_.Signal();
     NotificationService::current()->Notify(
         NotificationType::DEVICE_TOKEN_AVAILABLE,
         Source<DeviceTokenFetcher>(this),
         NotificationService::NoDetails());
   }
 }
 
 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));
   return state_ == kStateHasDeviceToken;
 }
 
 // static
 void DeviceTokenFetcher::WriteDeviceTokenToDisk(
     const FilePath& path,
-    const std::string& device_token) {
+    const std::string& device_token,
+    const std::string& device_id) {
+  em::DeviceToken storable_device_token;
+  storable_device_token.set_device_token(device_token);
+  storable_device_token.set_device_id(device_id);
+  std::string data;
+  storable_device_token.SerializeToString(&data);

[Mattias Nissler (ping if slow), 2010/11/15 18:02:51]

Should probably put a DCHECK() for the SerializeToString return value.

[Jakob Kummerow (corp), 2010/11/16 09:37:02]

Done.

   file_util::WriteFile(path,
-                       device_token.c_str(),
-                       device_token.length());
+                       data.c_str(),
+                       data.length());

[Mattias Nissler (ping if slow), 2010/11/15 18:02:51]

Hm, doesn't this fit on line 203?

[Jakob Kummerow (corp), 2010/11/16 09:37:02]

Done.

 }
 
 // static
 std::string DeviceTokenFetcher::GenerateNewDeviceID() {
   return guid::GenerateGUID();
 }
 
 }