Initialize ActivityStorage with pref service and pref name.

It makes ActivityStorage customizable, so it can work with
different pref stores. For enterprise reporintg activity is
stored in local state and for consumer reporting it is kept
in user prefs.

Bug: 837001
Test: 
Run: DeviceStatusCollectorTest, ConsumerDeviceCollectorTest, UserCloudPolicyManagerChromeOSTest.
Manully: Add child account to device and observe status upload after ~60s, Sign in as child user and observe status upload after ~60s.
Change-Id: Id82d3b0d3b8a3486ceae38acf9499b6825fbbb00
Reviewed-on: https://chromium-review.googlesource.com/1056264
Commit-Queue: Aga Wronska <agawronska@chromium.org>
Reviewed-by: Maksim Ivanov <emaxx@chromium.org>
Cr-Commit-Position: refs/heads/master@{#560930}

chrome/browser/chromeos/policy/device_status_collector.cc

@@ -83,10 +83,10 @@ namespace {
 const int kIdleStateThresholdSeconds = 300;
 
 // How much time in the past to store active periods for.
-constexpr TimeDelta kMaxStoredPastActivity = TimeDelta::FromDays(30);
+constexpr TimeDelta kMaxStoredPastActivityInterval = TimeDelta::FromDays(30);
 
 // How much time in the future to store active periods for.
-constexpr TimeDelta kMaxStoredFutureActivity = TimeDelta::FromDays(2);
+constexpr TimeDelta kMaxStoredFutureActivityInterval = TimeDelta::FromDays(2);
 
 // How often, in seconds, to sample the hardware resource usage.
 const unsigned int kResourceUsageSampleIntervalSeconds = 120;
@@ -440,7 +440,9 @@ class DeviceStatusCollector::ActivityStorage {
     int activity_milliseconds;
   };
 
-  explicit ActivityStorage(PrefService* local_state);
+  // Creates activity storage. Activity data will be stored in the given
+  // |pref_service| under |pref_name| preference.
+  ActivityStorage(PrefService* pref_service, const std::string& pref_name);
   ~ActivityStorage();
 
   // Adds an activity period. Accepts empty |active_user_email| if it should not
@@ -450,10 +452,11 @@ class DeviceStatusCollector::ActivityStorage {
                          const std::string& active_user_email);
 
   // Clears stored activity periods outside of storage range defined by
-  // |max_past_activity| and |max_future_activity| from |base_time|.
+  // |max_past_activity_interval| and |max_future_activity_interval| from
+  // |base_time|.
   void PruneActivityPeriods(Time base_time,
-                            TimeDelta max_past_activity,
-                            TimeDelta max_future_activity);
+                            TimeDelta max_past_activity_interval,
+                            TimeDelta max_future_activity_interval);
 
   // Trims the store activity periods to only retain data within the
   // [|min_day_key|, |max_day_key|). The record for |min_day_key| will be
@@ -485,14 +488,22 @@ class DeviceStatusCollector::ActivityStorage {
                               const std::vector<std::string>& reporting_users,
                               base::DictionaryValue* const filtered_times);
 
-  PrefService* const local_state_ = nullptr;
+  PrefService* const pref_service_ = nullptr;
+  const std::string pref_name_;
 
   DISALLOW_COPY_AND_ASSIGN(ActivityStorage);
 };
 
 DeviceStatusCollector::ActivityStorage::ActivityStorage(
-    PrefService* local_state)
-    : local_state_(local_state) {}
+    PrefService* pref_service,
+    const std::string& pref_name)
+    : pref_service_(pref_service), pref_name_(pref_name) {
+  DCHECK(pref_service_);
+  const PrefService::PrefInitializationStatus pref_service_status =
+      pref_service_->GetInitializationStatus();
+  DCHECK(pref_service_status != PrefService::INITIALIZATION_STATUS_WAITING &&
+         pref_service_status != PrefService::INITIALIZATION_STATUS_ERROR);
+}
 
 DeviceStatusCollector::ActivityStorage::~ActivityStorage() = default;
 
@@ -503,7 +514,7 @@ void DeviceStatusCollector::ActivityStorage::AddActivityPeriod(
   DCHECK(start <= end);
 
   // Maintain the list of active periods in a local_state pref.
-  DictionaryPrefUpdate update(local_state_, prefs::kDeviceActivityTimes);
+  DictionaryPrefUpdate update(pref_service_, pref_name_);
   base::DictionaryValue* activity_times = update.Get();
 
   // Assign the period to day buckets in local time.
@@ -522,10 +533,10 @@ void DeviceStatusCollector::ActivityStorage::AddActivityPeriod(
 
 void DeviceStatusCollector::ActivityStorage::PruneActivityPeriods(
     Time base_time,
-    TimeDelta max_past_activity,
-    TimeDelta max_future_activity) {
-  Time min_time = base_time - max_past_activity;
-  Time max_time = base_time + max_future_activity;
+    TimeDelta max_past_activity_interval,
+    TimeDelta max_future_activity_interval) {
+  Time min_time = base_time - max_past_activity_interval;
+  Time max_time = base_time + max_future_activity_interval;
   TrimActivityPeriods(TimestampToDayKey(min_time), 0,
                       TimestampToDayKey(max_time));
 }
@@ -535,7 +546,7 @@ void DeviceStatusCollector::ActivityStorage::TrimActivityPeriods(
     int min_day_trim_duration,
     int64_t max_day_key) {
   const base::DictionaryValue* activity_times =
-      local_state_->GetDictionary(prefs::kDeviceActivityTimes);
+      pref_service_->GetDictionary(pref_name_);
 
   std::unique_ptr<base::DictionaryValue> copy(activity_times->DeepCopy());
   for (base::DictionaryValue::Iterator it(*activity_times); !it.IsAtEnd();
@@ -559,23 +570,23 @@ void DeviceStatusCollector::ActivityStorage::TrimActivityPeriods(
     // The entry is out of range or couldn't be parsed. Remove it.
     copy->Remove(it.key(), NULL);
   }
-  local_state_->Set(prefs::kDeviceActivityTimes, *copy);
+  pref_service_->Set(pref_name_, *copy);
 }
 
 void DeviceStatusCollector::ActivityStorage::FilterActivityPeriodsByUsers(
     const std::vector<std::string>& reporting_users) {
   const base::DictionaryValue* stored_activity_periods =
-      local_state_->GetDictionary(prefs::kDeviceActivityTimes);
+      pref_service_->GetDictionary(pref_name_);
   base::DictionaryValue filtered_activity_periods;
   ProcessActivityPeriods(*stored_activity_periods, reporting_users,
                          &filtered_activity_periods);
-  local_state_->Set(prefs::kDeviceActivityTimes, filtered_activity_periods);
+  pref_service_->Set(prefs::kDeviceActivityTimes, filtered_activity_periods);
 }
 
 std::vector<DeviceStatusCollector::ActivityStorage::ActivityPeriod>
 DeviceStatusCollector::ActivityStorage::GetFilteredActivityPeriods(
     bool omit_emails) {
-  DictionaryPrefUpdate update(local_state_, prefs::kDeviceActivityTimes);
+  DictionaryPrefUpdate update(pref_service_, pref_name_);
   base::DictionaryValue* stored_activity_periods = update.Get();
 
   base::DictionaryValue filtered_activity_periods;
@@ -666,16 +677,16 @@ void DeviceStatusCollector::ActivityStorage::ProcessActivityPeriods(
 }
 
 DeviceStatusCollector::DeviceStatusCollector(
-    PrefService* local_state,
+    PrefService* pref_service,
     chromeos::system::StatisticsProvider* provider,
     const VolumeInfoFetcher& volume_info_fetcher,
     const CPUStatisticsFetcher& cpu_statistics_fetcher,
     const CPUTempFetcher& cpu_temp_fetcher,
     const AndroidStatusFetcher& android_status_fetcher,
     bool is_enterprise_device)
-    : max_stored_past_activity_(kMaxStoredPastActivity),
-      max_stored_future_activity_(kMaxStoredFutureActivity),
-      local_state_(local_state),
+    : max_stored_past_activity_interval_(kMaxStoredPastActivityInterval),
+      max_stored_future_activity_interval_(kMaxStoredFutureActivityInterval),
+      pref_service_(pref_service),
       last_idle_check_(Time()),
       volume_info_fetcher_(volume_info_fetcher),
       cpu_statistics_fetcher_(cpu_statistics_fetcher),
@@ -683,7 +694,6 @@ DeviceStatusCollector::DeviceStatusCollector(
       android_status_fetcher_(android_status_fetcher),
       statistics_provider_(provider),
       cros_settings_(chromeos::CrosSettings::Get()),
-      activity_storage_(std::make_unique<ActivityStorage>(local_state)),
       is_enterprise_device_(is_enterprise_device),
       task_runner_(nullptr),
       weak_factory_(this) {
@@ -753,12 +763,31 @@ DeviceStatusCollector::DeviceStatusCollector(
   chromeos::version_loader::GetTpmVersion(
       base::BindOnce(&DeviceStatusCollector::OnTpmVersion,
                      weak_factory_.GetWeakPtr()));
-  pref_change_registrar_ = std::make_unique<PrefChangeRegistrar>();
-  pref_change_registrar_->Init(local_state_);
-  pref_change_registrar_->Add(
-      prefs::kReportingUsers,
-      base::BindRepeating(&DeviceStatusCollector::ReportingUsersChanged,
-                          weak_factory_.GetWeakPtr()));
+
+  // If doing enterprise device-level reporting, observe the list of users to be
+  // reported. Consumer reporting is enforced for the signed-in registered user
+  // therefore this preference is not observed.
+  if (is_enterprise_device_) {
+    pref_change_registrar_ = std::make_unique<PrefChangeRegistrar>();
+    pref_change_registrar_->Init(pref_service_);
+    pref_change_registrar_->Add(
+        prefs::kReportingUsers,
+        base::BindRepeating(&DeviceStatusCollector::ReportingUsersChanged,
+                            weak_factory_.GetWeakPtr()));
+  }
+
+  // User |pref_service| might not be initialized yet. This can be removed once
+  // creation of DeviceStatusCollector for non-enterprise reporting guarantees
+  // that pref service is ready.
+  if (pref_service_->GetInitializationStatus() ==
+      PrefService::INITIALIZATION_STATUS_WAITING) {
+    pref_service->AddPrefInitObserver(
+        base::BindOnce(&DeviceStatusCollector::OnPrefServiceInitialized,
+                       weak_factory_.GetWeakPtr()));
+    return;
+  }
+  OnPrefServiceInitialized(pref_service_->GetInitializationStatus() !=
+                           PrefService::INITIALIZATION_STATUS_ERROR);
 }
 
 DeviceStatusCollector::~DeviceStatusCollector() {
@@ -773,6 +802,8 @@ void DeviceStatusCollector::RegisterPrefs(PrefRegistrySimple* registry) {
 // static
 void DeviceStatusCollector::RegisterProfilePrefs(PrefRegistrySimple* registry) {
   registry->RegisterBooleanPref(prefs::kReportArcStatusEnabled, false);
+  registry->RegisterDictionaryPref(prefs::kUserActivityTimes,
+                                   std::make_unique<base::DictionaryValue>());
 }
 
 void DeviceStatusCollector::CheckIdleState() {
@@ -855,8 +886,9 @@ void DeviceStatusCollector::ClearCachedResourceUsage() {
 }
 
 void DeviceStatusCollector::IdleStateCallback(ui::IdleState state) {
-  // Do nothing if device activity reporting is disabled.
-  if (!report_activity_times_)
+  // Do nothing if |activity_storage_| is not ready or device activity reporting
+  // is disabled.
+  if (!activity_storage_ || !report_activity_times_)
     return;
 
   Time now = GetCurrentTime();
@@ -888,8 +920,9 @@ void DeviceStatusCollector::IdleStateCallback(ui::IdleState state) {
                                            primary_user_email);
     }
 
-    activity_storage_->PruneActivityPeriods(now, max_stored_past_activity_,
-                                            max_stored_future_activity_);
+    activity_storage_->PruneActivityPeriods(
+        now, max_stored_past_activity_interval_,
+        max_stored_future_activity_interval_);
   }
   last_idle_check_ = now;
 }
@@ -987,16 +1020,38 @@ void DeviceStatusCollector::ReceiveCPUStatistics(const std::string& stats) {
 }
 
 void DeviceStatusCollector::ReportingUsersChanged() {
+  // Do nothing if |activity_storage_| is not ready.
+  if (!activity_storage_)
+    return;
+
   std::vector<std::string> reporting_users;
-  for (auto& value : local_state_->GetList(prefs::kReportingUsers)->GetList()) {
+  for (auto& value :
+       pref_service_->GetList(prefs::kReportingUsers)->GetList()) {
     if (value.is_string())
       reporting_users.push_back(value.GetString());
   }
   activity_storage_->FilterActivityPeriodsByUsers(reporting_users);
 }
 
+void DeviceStatusCollector::OnPrefServiceInitialized(bool succeeded) {
+  if (!succeeded) {
+    LOG(ERROR) << "Pref service was not initialized successfully - activity "
+                  "for device status reporting cannot be stored.";
+    return;
+  }
+
+  DCHECK(!activity_storage_);
+  activity_storage_ = std::make_unique<ActivityStorage>(
+      pref_service_, (is_enterprise_device_ ? prefs::kDeviceActivityTimes
+                                            : prefs::kUserActivityTimes));
+}
+
 bool DeviceStatusCollector::GetActivityTimes(
     em::DeviceStatusReportRequest* status) {
+  // Do nothing if |activity_storage_| is not ready.
+  if (!activity_storage_)
+    return false;
+
   // If user reporting is off, data should be aggregated per day.
   std::vector<ActivityStorage::ActivityPeriod> activity_times =
       activity_storage_->GetFilteredActivityPeriods(!report_users_);
@@ -1496,6 +1551,10 @@ std::string DeviceStatusCollector::GetAppVersion(
 }
 
 void DeviceStatusCollector::OnSubmittedSuccessfully() {
+  // Do nothing if |activity_storage_| is not ready.
+  if (!activity_storage_)
+    return;
+
   activity_storage_->TrimActivityPeriods(last_reported_day_,
                                          duration_for_last_reported_day_,
                                          std::numeric_limits<int64_t>::max());

chrome/browser/chromeos/policy/device_status_collector.h

@@ -94,7 +94,7 @@ class DeviceStatusCollector {
   // the default implementation. These callbacks are always executed on Blocking
   // Pool. If |is_enterprise_device| additional enterprise relevant status data
   // will be reported.
-  DeviceStatusCollector(PrefService* local_state,
+  DeviceStatusCollector(PrefService* pref_service,
                         chromeos::system::StatisticsProvider* provider,
                         const VolumeInfoFetcher& volume_info_fetcher,
                         const CPUStatisticsFetcher& cpu_statistics_fetcher,
@@ -150,12 +150,12 @@ class DeviceStatusCollector {
 
   // The timeout in the past to store device activity.
   // This is kept in case device status uploads fail for a number of days.
-  base::TimeDelta max_stored_past_activity_;
+  base::TimeDelta max_stored_past_activity_interval_;
 
   // The timeout in the future to store device activity.
   // When changing the system time and/or timezones, it's possible to record
   // activity time that is slightly in the future.
-  base::TimeDelta max_stored_future_activity_;
+  base::TimeDelta max_stored_future_activity_interval_;
 
  private:
   class ActivityStorage;
@@ -212,7 +212,11 @@ class DeviceStatusCollector {
   // Callback invoked when reporting users pref is changed.
   void ReportingUsersChanged();
 
-  PrefService* const local_state_;
+  // Called when |pref_service_| is initialized.
+  void OnPrefServiceInitialized(bool succeeded);
+
+  // Pref service that is mainly used to store activity periods for reporting.
+  PrefService* const pref_service_;
 
   // The last time an idle state check was performed.
   base::Time last_idle_check_;

chrome/browser/chromeos/policy/device_status_collector_browsertest.cc

@@ -97,7 +97,7 @@ const char kShillFakeUserhash[] = "user1";
 class TestingDeviceStatusCollector : public policy::DeviceStatusCollector {
  public:
   TestingDeviceStatusCollector(
-      PrefService* local_state,
+      PrefService* pref_service,
       chromeos::system::StatisticsProvider* provider,
       const policy::DeviceStatusCollector::VolumeInfoFetcher&
           volume_info_fetcher,
@@ -106,7 +106,7 @@ class TestingDeviceStatusCollector : public policy::DeviceStatusCollector {
       const policy::DeviceStatusCollector::AndroidStatusFetcher&
           android_status_fetcher,
       bool is_enterprise_device)
-      : policy::DeviceStatusCollector(local_state,
+      : policy::DeviceStatusCollector(pref_service,
                                       provider,
                                       volume_info_fetcher,
                                       cpu_fetcher,
@@ -123,12 +123,12 @@ class TestingDeviceStatusCollector : public policy::DeviceStatusCollector {
       IdleStateCallback(states[i]);
   }
 
-  void set_max_stored_past_activity(TimeDelta value) {
-    max_stored_past_activity_ = value;
+  void set_max_stored_past_activity_interval(TimeDelta value) {
+    max_stored_past_activity_interval_ = value;
   }
 
-  void set_max_stored_future_activity(TimeDelta value) {
-    max_stored_future_activity_ = value;
+  void set_max_stored_future_activity_interval(TimeDelta value) {
+    max_stored_future_activity_interval_ = value;
   }
 
   // Reset the baseline time.
@@ -339,6 +339,8 @@ class DeviceStatusCollectorTest : public testing::Test {
     // DiskMountManager takes ownership of the MockDiskMountManager.
     DiskMountManager::InitializeForTesting(mock_disk_mount_manager.release());
     TestingDeviceStatusCollector::RegisterPrefs(local_state_.registry());
+    TestingDeviceStatusCollector::RegisterProfilePrefs(
+        profile_pref_service_.registry());
 
     settings_helper_.ReplaceProvider(chromeos::kReportDeviceActivityTimes);
     owner_settings_service_ =
@@ -548,6 +550,7 @@ class DeviceStatusCollectorTest : public testing::Test {
   em::SessionStatusReportRequest session_status_;
   bool got_session_status_;
   TestingPrefServiceSimple local_state_;
+  TestingPrefServiceSimple profile_pref_service_;
   std::unique_ptr<TestingDeviceStatusCollector> status_collector_;
   const policy::DeviceLocalAccount fake_kiosk_device_local_account_;
   const policy::ArcKioskAppBasicInfo fake_arc_kiosk_app_basic_info_;
@@ -696,6 +699,25 @@ TEST_F(DeviceStatusCollectorTest, StateKeptInPref) {
             GetActiveMilliseconds(device_status_));
 }
 
+TEST_F(DeviceStatusCollectorTest, ActivityNotWrittenToProfilePref) {
+  EXPECT_TRUE(
+      profile_pref_service_.GetDictionary(prefs::kUserActivityTimes)->empty());
+
+  ui::IdleState test_states[] = {ui::IDLE_STATE_ACTIVE, ui::IDLE_STATE_ACTIVE,
+                                 ui::IDLE_STATE_ACTIVE};
+  status_collector_->Simulate(test_states,
+                              sizeof(test_states) / sizeof(ui::IdleState));
+  GetStatus();
+  EXPECT_EQ(1, device_status_.active_period_size());
+  EXPECT_EQ(3 * ActivePeriodMilliseconds(),
+            GetActiveMilliseconds(device_status_));
+
+  // Nothing should be written to profile pref service, because it is only used
+  // for consumer reporting.
+  EXPECT_TRUE(
+      profile_pref_service_.GetDictionary(prefs::kUserActivityTimes)->empty());
+}
+
 TEST_F(DeviceStatusCollectorTest, MaxStoredPeriods) {
   ui::IdleState test_states[] = {
     ui::IDLE_STATE_ACTIVE,
@@ -704,9 +726,10 @@ TEST_F(DeviceStatusCollectorTest, MaxStoredPeriods) {
   const int kMaxDays = 10;
 
   settings_helper_.SetBoolean(chromeos::kReportDeviceActivityTimes, true);
-  status_collector_->set_max_stored_past_activity(
+  status_collector_->set_max_stored_past_activity_interval(
       TimeDelta::FromDays(kMaxDays - 1));
-  status_collector_->set_max_stored_future_activity(TimeDelta::FromDays(1));
+  status_collector_->set_max_stored_future_activity_interval(
+      TimeDelta::FromDays(1));
   Time baseline = Time::Now().LocalMidnight();
 
   // Simulate 12 active periods.
@@ -1820,6 +1843,14 @@ TEST_F(DeviceStatusCollectorNetworkInterfacesTest, ReportIfPublicSession) {
 
 // Tests collecting device status for registered consumer device.
 class ConsumerDeviceStatusCollectorTest : public DeviceStatusCollectorTest {
+ public:
+  ConsumerDeviceStatusCollectorTest() {
+    user_account_id_ = AccountId::FromUserEmail("user0@gmail.com");
+    MockRegularUserWithAffiliation(user_account_id_, true);
+  }
+
+  ~ConsumerDeviceStatusCollectorTest() override = default;
+
  protected:
   void RestartStatusCollector(
       const policy::DeviceStatusCollector::VolumeInfoFetcher& volume_info,
@@ -1827,11 +1858,13 @@ class ConsumerDeviceStatusCollectorTest : public DeviceStatusCollectorTest {
       const policy::DeviceStatusCollector::CPUTempFetcher& cpu_temp_fetcher,
       const policy::DeviceStatusCollector::AndroidStatusFetcher&
           android_status_fetcher) override {
-    status_collector_.reset(new TestingDeviceStatusCollector(
-        &local_state_, &fake_statistics_provider_, volume_info, cpu_stats,
-        cpu_temp_fetcher, android_status_fetcher,
-        false /* is_enterprise_device */));
+    status_collector_ = std::make_unique<TestingDeviceStatusCollector>(
+        &profile_pref_service_, &fake_statistics_provider_, volume_info,
+        cpu_stats, cpu_temp_fetcher, android_status_fetcher,
+        false /* is_enterprise_device */);
   }
+
+  AccountId user_account_id_;
 };
 
 TEST_F(ConsumerDeviceStatusCollectorTest, ReportingBootMode) {
@@ -1858,6 +1891,50 @@ TEST_F(ConsumerDeviceStatusCollectorTest, ReportingActivityTimes) {
             GetActiveMilliseconds(device_status_));
 }
 
+TEST_F(ConsumerDeviceStatusCollectorTest, ActivityKeptInPref) {
+  EXPECT_TRUE(
+      profile_pref_service_.GetDictionary(prefs::kUserActivityTimes)->empty());
+
+  ui::IdleState test_states[] = {ui::IDLE_STATE_ACTIVE, ui::IDLE_STATE_IDLE,
+                                 ui::IDLE_STATE_ACTIVE, ui::IDLE_STATE_ACTIVE,
+                                 ui::IDLE_STATE_IDLE,   ui::IDLE_STATE_IDLE};
+  status_collector_->Simulate(test_states,
+                              sizeof(test_states) / sizeof(ui::IdleState));
+  EXPECT_FALSE(
+      profile_pref_service_.GetDictionary(prefs::kUserActivityTimes)->empty());
+
+  // Process the list a second time after restarting the collector. It should be
+  // able to count the active periods found by the original collector, because
+  // the results are stored in a pref.
+  RestartStatusCollector(base::BindRepeating(&GetEmptyVolumeInfo),
+                         base::BindRepeating(&GetEmptyCPUStatistics),
+                         base::BindRepeating(&GetEmptyCPUTempInfo),
+                         base::BindRepeating(&GetEmptyAndroidStatus));
+  status_collector_->Simulate(test_states,
+                              sizeof(test_states) / sizeof(ui::IdleState));
+
+  GetStatus();
+  EXPECT_EQ(6 * ActivePeriodMilliseconds(),
+            GetActiveMilliseconds(device_status_));
+}
+
+TEST_F(ConsumerDeviceStatusCollectorTest, ActivityNotWrittenToLocalState) {
+  EXPECT_TRUE(local_state_.GetDictionary(prefs::kDeviceActivityTimes)->empty());
+
+  ui::IdleState test_states[] = {ui::IDLE_STATE_ACTIVE, ui::IDLE_STATE_ACTIVE,
+                                 ui::IDLE_STATE_ACTIVE};
+  status_collector_->Simulate(test_states,
+                              sizeof(test_states) / sizeof(ui::IdleState));
+  GetStatus();
+  EXPECT_EQ(1, device_status_.active_period_size());
+  EXPECT_EQ(3 * ActivePeriodMilliseconds(),
+            GetActiveMilliseconds(device_status_));
+
+  // Nothing should be written to local state, because it is only used for
+  // enterprise reporting.
+  EXPECT_TRUE(local_state_.GetDictionary(prefs::kDeviceActivityTimes)->empty());
+}
+
 TEST_F(ConsumerDeviceStatusCollectorTest, ReportingArcStatus) {
   RestartStatusCollector(
       base::BindRepeating(&GetEmptyVolumeInfo),
@@ -1865,8 +1942,6 @@ TEST_F(ConsumerDeviceStatusCollectorTest, ReportingArcStatus) {
       base::BindRepeating(&GetEmptyCPUTempInfo),
       base::BindRepeating(&GetFakeAndroidStatus, kArcStatus, kDroidGuardInfo));
 
-  const AccountId account_id(AccountId::FromUserEmail("user0@gmail.com"));
-  MockRegularUserWithAffiliation(account_id, true);
   testing_profile_->GetPrefs()->SetBoolean(prefs::kReportArcStatusEnabled,
                                            true);
 
@@ -1876,7 +1951,7 @@ TEST_F(ConsumerDeviceStatusCollectorTest, ReportingArcStatus) {
   EXPECT_EQ(kDroidGuardInfo,
             session_status_.android_status().droid_guard_info());
   // In tests, GetUserDMToken returns the e-mail for easy verification.
-  EXPECT_EQ(account_id.GetUserEmail(), session_status_.user_dm_token());
+  EXPECT_EQ(user_account_id_.GetUserEmail(), session_status_.user_dm_token());
 }
 
 TEST_F(ConsumerDeviceStatusCollectorTest, ReportingPartialVersionInfo) {
@@ -1930,20 +2005,6 @@ TEST_F(ConsumerDeviceStatusCollectorTest, NotReportingUsers) {
   EXPECT_EQ(0, device_status_.user_size());
 }
 
-TEST_F(ConsumerDeviceStatusCollectorTest, NotReportingRunningKioskApp) {
-  MockPlatformVersion("1234.0.0");
-  MockAutoLaunchKioskAppWithRequiredPlatformVersion(
-      fake_kiosk_device_local_account_, "1235");
-  MockRunningKioskApp(fake_kiosk_device_local_account_, false /* arc_kiosk */);
-  status_collector_->set_kiosk_account(
-      std::make_unique<policy::DeviceLocalAccount>(
-          fake_kiosk_device_local_account_));
-
-  GetStatus();
-
-  EXPECT_FALSE(device_status_.has_running_kiosk_app());
-}
-
 TEST_F(ConsumerDeviceStatusCollectorTest, NotReportingOSUpdateStatus) {
   MockPlatformVersion("1234.0.0");
   MockAutoLaunchKioskAppWithRequiredPlatformVersion(

chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.cc

@@ -31,6 +31,7 @@
 #include "chrome/browser/chromeos/policy/status_uploader.h"
 #include "chrome/browser/chromeos/policy/user_policy_manager_factory_chromeos.h"
 #include "chrome/browser/chromeos/policy/wildcard_login_checker.h"
+#include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/invalidation/profile_invalidation_provider_factory.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/policy/cloud/remote_commands_invalidator_impl.h"
@@ -81,6 +82,10 @@ const char kUMAInitialFetchOAuth2Error[] =
 const char kUMAInitialFetchOAuth2NetworkError[] =
     "Enterprise.UserPolicyChromeOS.InitialFetch.OAuth2NetworkError";
 
+// Default frequency for uploading non-enterprise status reports.
+constexpr base::TimeDelta kDeviceStatusUploadFrequency =
+    base::TimeDelta::FromMinutes(10);
+
 // This class is used to subscribe for notifications that the current profile is
 // being shut down.
 class UserCloudPolicyManagerChromeOSNotifierFactory
@@ -400,6 +405,22 @@ void UserCloudPolicyManagerChromeOS::OnRegistrationStateChanged(
       CancelWaitForPolicyFetch(true);
     }
   }
+
+  // TODO(agawronska): Move StatusUploader creation to profile keyed
+  // service, where profile pref service is fully initialized.
+
+  // If child is registered with DMServer and has User Policy applied, it
+  // should upload device status to the server. For enterprise reporting
+  // status upload is controlled by DeviceCloudPolicyManagerChromeOS.
+  const user_manager::User* const user =
+      chromeos::ProfileHelper::Get()->GetUserByProfile(profile_);
+  if (client()->is_registered() && user &&
+      user->GetType() == user_manager::USER_TYPE_CHILD) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::BindOnce(&UserCloudPolicyManagerChromeOS::CreateStatusUploader,
+                       base::Unretained(this)));
+  }
 }
 
 void UserCloudPolicyManagerChromeOS::OnClientError(
@@ -683,4 +704,22 @@ void UserCloudPolicyManagerChromeOS::ProfileShutdown() {
   shutdown_notifier_.reset();
 }
 
+void UserCloudPolicyManagerChromeOS::CreateStatusUploader() {
+  // Do not recreate status uploader if this is called multiple times.
+  if (status_uploader_)
+    return;
+
+  status_uploader_ = std::make_unique<StatusUploader>(
+      client(),
+      std::make_unique<DeviceStatusCollector>(
+          profile_->GetPrefs(),
+          chromeos::system::StatisticsProvider::GetInstance(),
+          DeviceStatusCollector::VolumeInfoFetcher(),
+          DeviceStatusCollector::CPUStatisticsFetcher(),
+          DeviceStatusCollector::CPUTempFetcher(),
+          DeviceStatusCollector::AndroidStatusFetcher(),
+          false /* is_enterprise_device */),
+      task_runner_, kDeviceStatusUploadFrequency);
+}
+
 }  // namespace policy

chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.h

@@ -215,6 +215,8 @@ class UserCloudPolicyManagerChromeOS : public CloudPolicyManager,
   // Observer called on profile shutdown.
   void ProfileShutdown();
 
+  void CreateStatusUploader();
+
   // Profile associated with the current user.
   Profile* const profile_;
 

chrome/common/pref_names.cc

@@ -1729,6 +1729,10 @@ const char kAutoEnrollmentPowerLimit[] = "AutoEnrollmentPowerLimit";
 // them to the policy server.
 const char kDeviceActivityTimes[] = "device_status.activity_times";
 
+// A pref that stores user activity times before reporting them to the policy
+// server.
+const char kUserActivityTimes[] = "consumer_device_status.activity_times";
+
 // A pref holding the value of the policy used to disable mounting of external
 // storage for the user.
 const char kExternalStorageDisabled[] = "hardware.external_storage_disabled";

chrome/common/pref_names.h

@@ -593,6 +593,7 @@ extern const char kCarrierDealPromoShown[];
 extern const char kShouldAutoEnroll[];
 extern const char kAutoEnrollmentPowerLimit[];
 extern const char kDeviceActivityTimes[];
+extern const char kUserActivityTimes[];
 extern const char kExternalStorageDisabled[];
 extern const char kExternalStorageReadOnly[];
 extern const char kOwnerPrimaryMouseButtonRight[];