Add OS and firmware version to device status reports.

chrome/browser/policy/device_status_collector.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_status_collector.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/message_loop.h"

[Joao da Silva, 2011/12/12 14:23:04]

Nit: not needed

[Patrick Dubroy, 2011/12/12 15:18:01]

Done.

 #include "base/string_number_conversions.h"
 #include "base/task.h"

[Joao da Silva, 2011/12/12 14:23:04]

Nit: not needed

[Patrick Dubroy, 2011/12/12 15:18:01]

Good catch. These were used in an older version of the code.

Done.

 #include "base/time.h"
+#include "chrome/browser/chromeos/version_loader.h"
 #include "chrome/browser/idle.h"

[Joao da Silva, 2011/12/12 14:23:04]

Nit: these 3 are already included in .h, not needed here (time.h,
version_loader.h and idle.h)

[Patrick Dubroy, 2011/12/12 15:18:01]

Ok, I've never been quite sure what the recommended thing to do in this case
was.

Done.

 #include "chrome/browser/policy/proto/device_management_backend.pb.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 
 using base::Time;
 using base::TimeDelta;
+using chromeos::VersionLoader;
 
 namespace em = enterprise_management;
 
 namespace {
 // How many seconds of inactivity triggers the idle state.
 const unsigned int kIdleStateThresholdSeconds = 300;
 
 // The maximum number of time periods stored in the local state.
 const unsigned int kMaxStoredActivePeriods = 500;
 
@@ skipping 16 matching lines @@
 
 DeviceStatusCollector::DeviceStatusCollector(PrefService* local_state)
     : max_stored_active_periods_(kMaxStoredActivePeriods),
       local_state_(local_state),
       last_idle_check_(Time()),
       last_idle_state_(IDLE_STATE_UNKNOWN) {
   timer_.Start(FROM_HERE,
                TimeDelta::FromSeconds(
                    DeviceStatusCollector::kPollIntervalSeconds),
                this, &DeviceStatusCollector::CheckIdleState);
+
+  // Get the the OS and firmware version info.
+  version_loader_.GetVersion(&consumer_,
+                             base::Bind(&DeviceStatusCollector::OnOSVersion,
+                                        base::Unretained(this)),
+                             VersionLoader::VERSION_FULL);
+  version_loader_.GetFirmware(&consumer_,
+                              base::Bind(&DeviceStatusCollector::OnOSFirmware,
+                                         base::Unretained(this)));
 }
 
 DeviceStatusCollector::~DeviceStatusCollector() {
 }
 
 // static
 void DeviceStatusCollector::RegisterPrefs(PrefService* local_state) {
   local_state->RegisterInt64Pref(kPrefBaselineTime, Time::Now().ToTimeT());
   local_state->RegisterListPref(kPrefDeviceActivePeriods, new ListValue);
 }
@@ skipping 74 matching lines @@
       // Something is amiss -- bail out.
       NOTREACHED();
       break;
     }
     time_period = request->add_active_time();
     time_period->set_start_timestamp(start);
     time_period->set_end_timestamp(end);
   }
   ListPrefUpdate update(local_state_, kPrefDeviceActivePeriods);
   update.Get()->Clear();
+
+  request->set_os_version(os_version_);
+  request->set_firmware_version(firmware_version_);
+}
+
+void DeviceStatusCollector::OnOSVersion(VersionLoader::Handle handle,
+                                        std::string version) {
+  os_version_ = version;
+}
+
+void DeviceStatusCollector::OnOSFirmware(VersionLoader::Handle handle,
+                                         std::string version) {
+  firmware_version_ = version;
 }
 
 }  // namespace policy