Update policy backend and testserver for the newest policy protocol

chrome/browser/policy/device_policy_identity_strategy.cc

 // Copyright (c) 2011 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_policy_identity_strategy.h"
 
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/login/ownership_service.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/net/gaia/token_service.h"
+#include "chrome/browser/policy/proto/device_management_constants.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/common/guid.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 
+#if defined(OS_CHROMEOS)

[Mattias Nissler (ping if slow), 2011/02/21 14:55:27]

Not needed, this file is on compiled on CrOS

[gfeher, 2011/02/22 15:57:29]

Done.

+#include "chrome/browser/chromeos/cros/cros_library.h"
+#include "chrome/browser/chromeos/cros/system_library.h"
+#endif
+
 namespace policy {
 
+namespace {
+  // Key name for MachineInfo.
+  const char kMachineInfoSerialNumber[] = "serial_number";
+}
+
 DevicePolicyIdentityStrategy::DevicePolicyIdentityStrategy()
     : should_register_(false) {
   registrar_.Add(this,
                  NotificationType::TOKEN_AVAILABLE,
                  NotificationService::AllSources());
   registrar_.Add(this,
                  NotificationType::LOGIN_USER_CHANGED,
                  NotificationService::AllSources());
   registrar_.Add(this,
                  NotificationType::OWNERSHIP_TAKEN,
                  NotificationService::AllSources());
   registrar_.Add(this,
                  NotificationType::OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED,
                  NotificationService::AllSources());
 
-  // TODO(mnissler): Figure out how to read the machine id.
-  machine_id_ = "dummy-cros-machine-ID";
+  machine_id_ = "unknown-cros-machine-ID";
+#if defined(OS_CHROMEOS)
+  chromeos::SystemLibrary* sys_lib =
+      chromeos::CrosLibrary::Get()->GetSystemLibrary();

[Mattias Nissler (ping if slow), 2011/02/21 14:55:27]

Nice!

But I've heard rumors about the serial number not being available during regular
operation, have you tested this?

[gfeher, 2011/02/22 15:57:29]

I am still fighting with ChromeOS build to make a working image and test this.
If that won't work I'll remove this.

+
+  // Required info.
+  std::string serial_number;
+  if (!sys_lib->GetMachineStatistic(kMachineInfoSerialNumber, &machine_id_)) {
+    LOG(WARNING) << "Failed to get machine serial number." << std::endl;
+  }
+#endif
 }
 
 std::string DevicePolicyIdentityStrategy::GetDeviceToken() {
   return device_token_;
 }
 
 std::string DevicePolicyIdentityStrategy::GetDeviceID() {
   return machine_id_;

[Jakob Kummerow, 2011/02/21 16:15:00]

s/machine_id_/device_id_/ ?

[gfeher, 2011/02/22 15:57:29]

Whoops!

 }
 
+std::string DevicePolicyIdentityStrategy::GetMachineID() {
+  return machine_id_;
+}
+
+em::DeviceRegisterRequest_Type
+DevicePolicyIdentityStrategy::GetPolicyRegisterType() {
+  return em::DeviceRegisterRequest::DEVICE;
+}
+
+std::string DevicePolicyIdentityStrategy::GetPolicyType() {
+  return kChromeDevicePolicyType;
+}
+
 bool DevicePolicyIdentityStrategy::GetCredentials(std::string* username,
                                                   std::string* auth_token) {
   // Only register if requested.
   if (!should_register_)
     return false;
 
   // Need to know the machine id.
   if (machine_id_.empty())
     return false;
 
@@ skipping 23 matching lines @@
   // Reset registration flag, so we only attempt registration once.
   should_register_ = false;
 
   device_token_ = token;
   NotifyDeviceTokenChanged();
 }
 
 void DevicePolicyIdentityStrategy::CheckAndTriggerFetch() {
   std::string username;
   std::string auth_token;
-  if (GetCredentials(&username, &auth_token))
+  if (GetCredentials(&username, &auth_token)) {
+    device_id_ = guid::GenerateGUID();
     NotifyAuthChanged();
+  }
 }
 
 void DevicePolicyIdentityStrategy::Observe(NotificationType type,
                                            const NotificationSource& source,
                                            const NotificationDetails& details) {
   if (type == NotificationType::TOKEN_AVAILABLE) {
     const TokenService::TokenAvailableDetails* token_details =
         Details<const TokenService::TokenAvailableDetails>(details).ptr();
     if (token_details->service() == GaiaConstants::kDeviceManagementService)
       CheckAndTriggerFetch();
   } else if (type == NotificationType::LOGIN_USER_CHANGED) {
     should_register_ = false;
     CheckAndTriggerFetch();
   } else if (type == NotificationType::OWNERSHIP_TAKEN) {
     should_register_ = true;
     CheckAndTriggerFetch();
   } else if (type == NotificationType::OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED) {
     CheckAndTriggerFetch();
   } else {
     NOTREACHED();
   }
 }
 
 }  // namespace policy