Apply individual policies for the various parts of device status reports.

chrome/browser/policy/device_status_collector.cc

 // Copyright (c) 2012 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/string_number_conversions.h"
 #include "chrome/browser/chromeos/system/statistics_provider.h"
 #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"
+#include "chrome/common/pref_names.h"

[Joao da Silva, 2012/01/26 09:48:58]

Nit: alphabetic order

[Patrick Dubroy, 2012/01/27 15:20:29]

Done.

 #include "chrome/common/chrome_version_info.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;
 
-// Stores the baseline timestamp, to which the active periods are relative.
-const char* const kPrefBaselineTime = "device_status.baseline_timestamp";
-
 // Stores a list of timestamps representing device active periods.
 const char* const kPrefDeviceActivePeriods = "device_status.active_periods";
 
 bool GetTimestamp(const ListValue* list, int index, int64* out_value) {
   std::string string_value;
   if (list->GetString(index, &string_value))
     return base::StringToInt64(string_value, out_value);
   return false;
 }
 
@@ skipping 22 matching lines @@
   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);
+  local_state->RegisterBooleanPref(prefs::kReportDeviceVersionInfo, false);

[pastarmovj, 2012/01/26 09:52:11]

You won't need this once you regard my next comment on line 122.

[Patrick Dubroy, 2012/01/27 15:20:29]

Done.

+  local_state->RegisterBooleanPref(prefs::kReportDeviceActivityTimes, false);
+  local_state->RegisterBooleanPref(prefs::kReportDeviceBootMode, false);
 }
 
 void DeviceStatusCollector::CheckIdleState() {
   CalculateIdleState(kIdleStateThresholdSeconds,
       base::Bind(&DeviceStatusCollector::IdleStateCallback,
                  base::Unretained(this)));
 }
 
 Time DeviceStatusCollector::GetCurrentTime() {
   return Time::Now();
@@ skipping 25 matching lines @@
       return;
     }
   }
   // Add a new period to the list.
   active_periods->Append(
       new StringValue(base::Int64ToString(start_timestamp)));
   active_periods->Append(end_value);
 }
 
 void DeviceStatusCollector::IdleStateCallback(IdleState state) {
+  // Do nothing if device activity reporting is disabled.
+  if (!local_state_->GetBoolean(prefs::kReportDeviceActivityTimes))

[pastarmovj, 2012/01/26 09:52:11]

This is not the right way to read device policy. If you read it this way you
open up the possibility for an attacker to put arbitrary values in |local_state|
as long as this policy is not set on the server. The right way would be to use
the CrosSettings interface to DeviceSettingsProvider which can tell if the
values that it ships are really coming from the trusted policy blob so it will
be much harder to override those as the policy blob is root owned.

[Patrick Dubroy, 2012/01/27 15:20:29]

Done.

+    return;
+
   Time now = GetCurrentTime();
 
   if (state == IDLE_STATE_ACTIVE) {
     unsigned int poll_interval = DeviceStatusCollector::kPollIntervalSeconds;
 
     // If it's been too long since the last report, assume that the system was
     // in standby, and only count a single interval of activity.
     if ((now - last_idle_check_).InSeconds() >= (2 * poll_interval))
       AddActivePeriod(now - TimeDelta::FromSeconds(poll_interval), now);
     else
       AddActivePeriod(last_idle_check_, now);
   }
   last_idle_check_ = now;
   last_idle_state_ = state;
 }
 
-void DeviceStatusCollector::GetStatus(em::DeviceStatusReportRequest* request) {
-  // Report device active periods.
+void DeviceStatusCollector::GetActivityTimes(
+    em::DeviceStatusReportRequest* request) {
   const ListValue* active_periods =
       local_state_->GetList(kPrefDeviceActivePeriods);
   em::TimePeriod* time_period;
 
   DCHECK(active_periods->GetSize() % 2 == 0);
 
   int period_count = active_periods->GetSize() / 2;
   for (int i = 0; i < period_count; i++) {
     int64 start, end;
 
     if (!GetTimestamp(active_periods, 2 * i, &start) ||
         !GetTimestamp(active_periods, 2 * i + 1, &end) ||
         end < start) {
       // 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();
+}
 
+void DeviceStatusCollector::GetVersionInfo(
+    em::DeviceStatusReportRequest* request) {
   chrome::VersionInfo version_info;
   request->set_browser_version(version_info.Version());
   request->set_os_version(os_version_);
   request->set_firmware_version(firmware_version_);
+}
 
-  // Report the state of the dev switch at boot.
+void DeviceStatusCollector::GetBootMode(
+    em::DeviceStatusReportRequest* request) {
   std::string dev_switch_mode;
   if (statistics_provider_->GetMachineStatistic(
       "devsw_boot", &dev_switch_mode)) {
     if (dev_switch_mode == "1")
       request->set_boot_mode("Dev");
     else if (dev_switch_mode == "0")
       request->set_boot_mode("Verified");
   }
 }
 
+void DeviceStatusCollector::GetStatus(em::DeviceStatusReportRequest* request) {
+  if (local_state_->GetBoolean(prefs::kReportDeviceActivityTimes))

[pastarmovj, 2012/01/26 09:52:11]

Ditto.

[Patrick Dubroy, 2012/01/27 15:20:29]

Done.

+    GetActivityTimes(request);
+
+  if (local_state_->GetBoolean(prefs::kReportDeviceVersionInfo))

[pastarmovj, 2012/01/26 09:52:11]

Ditto.

[Patrick Dubroy, 2012/01/27 15:20:29]

Done.

+    GetVersionInfo(request);
+
+  if (local_state_->GetBoolean(prefs::kReportDeviceBootMode))

[pastarmovj, 2012/01/26 09:52:11]

Ditto.

[Patrick Dubroy, 2012/01/27 15:20:29]

Done.

+    GetBootMode(request);
+}
+
 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