Device status reporting for Child users.

Bug: 826402
Change-Id: I8fa2f91e4dae3c391568ca3a47b5fae080bf3745
Reviewed-on: https://chromium-review.googlesource.com/1000535
Commit-Queue: Aga Wronska <agawronska@chromium.org>
Reviewed-by: Alexander Alekseev <alemate@chromium.org>
Cr-Commit-Position: refs/heads/master@{#549547}

chrome/browser/chromeos/policy/device_cloud_policy_manager_chromeos.cc

@@ -375,7 +375,8 @@ void DeviceCloudPolicyManagerChromeOS::CreateStatusUploader() {
           DeviceStatusCollector::VolumeInfoFetcher(),
           DeviceStatusCollector::CPUStatisticsFetcher(),
           DeviceStatusCollector::CPUTempFetcher(),
-          DeviceStatusCollector::AndroidStatusFetcher()),
+          DeviceStatusCollector::AndroidStatusFetcher(),
+          true /* is_enterprise_device */),
       task_runner_));
 }
 

chrome/browser/chromeos/policy/device_status_collector.cc

@@ -490,7 +490,8 @@ DeviceStatusCollector::DeviceStatusCollector(
     const VolumeInfoFetcher& volume_info_fetcher,
     const CPUStatisticsFetcher& cpu_statistics_fetcher,
     const CPUTempFetcher& cpu_temp_fetcher,
-    const AndroidStatusFetcher& android_status_fetcher)
+    const AndroidStatusFetcher& android_status_fetcher,
+    bool is_enterprise_device)
     : max_stored_past_activity_days_(kMaxStoredPastActivityDays),
       max_stored_future_activity_days_(kMaxStoredFutureActivityDays),
       local_state_(local_state),
@@ -501,6 +502,7 @@ DeviceStatusCollector::DeviceStatusCollector(
       android_status_fetcher_(android_status_fetcher),
       statistics_provider_(provider),
       cros_settings_(chromeos::CrosSettings::Get()),
+      is_enterprise_device_(is_enterprise_device),
       task_runner_(nullptr),
       weak_factory_(this) {
   // Get the task runner of the current thread, so we can queue status responses
@@ -608,7 +610,6 @@ void DeviceStatusCollector::UpdateReportingSettings() {
     return;
   }
 
-  // All reporting settings default to 'enabled'.
   if (!cros_settings_->GetBoolean(
           chromeos::kReportDeviceVersionInfo, &report_version_info_)) {
     report_version_info_ = true;
@@ -621,25 +622,25 @@ void DeviceStatusCollector::UpdateReportingSettings() {
           chromeos::kReportDeviceBootMode, &report_boot_mode_)) {
     report_boot_mode_ = true;
   }
-  if (!cros_settings_->GetBoolean(
-          chromeos::kReportDeviceNetworkInterfaces,
-          &report_network_interfaces_)) {
-    report_network_interfaces_ = true;
+  if (!cros_settings_->GetBoolean(chromeos::kReportDeviceSessionStatus,
+                                  &report_kiosk_session_status_)) {
+    report_kiosk_session_status_ = true;
   }
+  // Network interfaces are reported for enterprise devices only by default.
+  if (!cros_settings_->GetBoolean(chromeos::kReportDeviceNetworkInterfaces,
+                                  &report_network_interfaces_)) {
+    report_network_interfaces_ = is_enterprise_device_ ? true : false;
+  }
+  // Device users are reported for enterprise devices only by default.
   if (!cros_settings_->GetBoolean(
           chromeos::kReportDeviceUsers, &report_users_)) {
-    report_users_ = true;
+    report_users_ = is_enterprise_device_ ? true : false;
   }
-
+  // Hardware status is reported for enterprise devices only by default.
   const bool already_reporting_hardware_status = report_hardware_status_;
   if (!cros_settings_->GetBoolean(
           chromeos::kReportDeviceHardwareStatus, &report_hardware_status_)) {
-    report_hardware_status_ = true;
-  }
-
-  if (!cros_settings_->GetBoolean(chromeos::kReportDeviceSessionStatus,
-                                  &report_kiosk_session_status_)) {
-    report_kiosk_session_status_ = true;
+    report_hardware_status_ = is_enterprise_device_ ? true : false;
   }
 
   if (!report_hardware_status_) {
@@ -930,8 +931,12 @@ bool DeviceStatusCollector::GetActivityTimes(
 
 bool DeviceStatusCollector::GetVersionInfo(
     em::DeviceStatusReportRequest* status) {
-  status->set_browser_version(version_info::GetVersionNumber());
   status->set_os_version(os_version_);
+  if (!is_enterprise_device_)
+    return true;
+
+  // Enterprise-only version reporting below.
+  status->set_browser_version(version_info::GetVersionNumber());
   status->set_firmware_version(firmware_version_);
 
   em::TpmVersionInfo* const tpm_version_info =

chrome/browser/chromeos/policy/device_status_collector.h

@@ -92,14 +92,15 @@ class DeviceStatusCollector {
   // Constructor. Callers can inject their own *Fetcher callbacks, e.g. for unit
   // testing. A null callback can be passed for any *Fetcher parameter, to use
   // the default implementation. These callbacks are always executed on Blocking
-  // Pool.
-  DeviceStatusCollector(
-      PrefService* local_state,
-      chromeos::system::StatisticsProvider* provider,
-      const VolumeInfoFetcher& volume_info_fetcher,
-      const CPUStatisticsFetcher& cpu_statistics_fetcher,
-      const CPUTempFetcher& cpu_temp_fetcher,
-      const AndroidStatusFetcher& android_status_fetcher);
+  // Pool. If |is_enterprise_device| additional enterprise relevant status data
+  // will be reported.
+  DeviceStatusCollector(PrefService* local_state,
+                        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);
   virtual ~DeviceStatusCollector();
 
   // Gathers device and session status information and calls the passed response
@@ -286,6 +287,9 @@ class DeviceStatusCollector {
   bool report_os_update_status_ = false;
   bool report_running_kiosk_app_ = false;
 
+  // Whether device is managed by enterprise or owned by consumer.
+  bool is_enterprise_device_ = false;
+
   std::unique_ptr<chromeos::CrosSettings::ObserverSubscription>
       version_info_subscription_;
   std::unique_ptr<chromeos::CrosSettings::ObserverSubscription>

chrome/browser/chromeos/policy/status_uploader_unittest.cc

@@ -51,7 +51,8 @@ class MockDeviceStatusCollector : public policy::DeviceStatusCollector {
             policy::DeviceStatusCollector::VolumeInfoFetcher(),
             policy::DeviceStatusCollector::CPUStatisticsFetcher(),
             policy::DeviceStatusCollector::CPUTempFetcher(),
-            policy::DeviceStatusCollector::AndroidStatusFetcher()) {}
+            policy::DeviceStatusCollector::AndroidStatusFetcher(),
+            true /* is_enterprise_device */) {}
 
   MOCK_METHOD1(GetDeviceAndSessionStatusAsync,
                void(const policy::DeviceStatusCollector::StatusCallback&));

chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.cc

@@ -21,7 +21,10 @@
 #include "chrome/browser/chromeos/login/users/affiliation.h"
 #include "chrome/browser/chromeos/login/users/chrome_user_manager_impl.h"
 #include "chrome/browser/chromeos/policy/app_install_event_log_uploader.h"
+#include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
+#include "chrome/browser/chromeos/policy/device_status_collector.h"
 #include "chrome/browser/chromeos/policy/policy_oauth2_token_fetcher.h"
+#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/lifetime/application_lifetime.h"
@@ -29,6 +32,7 @@
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/cryptohome/cryptohome_parameters.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/system/statistics_provider.h"
 #include "components/crash/core/common/crash_key.h"
 #include "components/policy/core/common/cloud/cloud_external_data_manager.h"
 #include "components/policy/core/common/cloud/cloud_policy_refresh_scheduler.h"
@@ -91,6 +95,7 @@ UserCloudPolicyManagerChromeOS::UserCloudPolicyManagerChromeOS(
                                     PolicyEnforcement::kServerCheckRequired ||
                                 !policy_refresh_timeout.is_zero()),
       enforcement_type_(enforcement_type),
+      task_runner_(task_runner),
       account_id_(account_id),
       fatal_error_callback_(std::move(fatal_error_callback)) {
   time_init_started_ = base::Time::Now();
@@ -197,6 +202,25 @@ void UserCloudPolicyManagerChromeOS::Connect(
 
   app_install_event_log_uploader_ =
       std::make_unique<AppInstallEventLogUploader>(client());
+
+  // If non-enterprise device is registered with DMServer and has User Policy
+  // applied, it should upload device status to the server. For devices in
+  // enterprise mode status upload is controlled by
+  // DeviceCloudPolicyManagerChromeOS.
+  policy::BrowserPolicyConnectorChromeOS* connector =
+      g_browser_process->platform_part()->browser_policy_connector_chromeos();
+  if (connector->GetDeviceMode() == DEVICE_MODE_CONSUMER) {
+    status_uploader_.reset(new StatusUploader(
+        client(),
+        std::make_unique<DeviceStatusCollector>(
+            local_state_, chromeos::system::StatisticsProvider::GetInstance(),
+            DeviceStatusCollector::VolumeInfoFetcher(),
+            DeviceStatusCollector::CPUStatisticsFetcher(),
+            DeviceStatusCollector::CPUTempFetcher(),
+            DeviceStatusCollector::AndroidStatusFetcher(),
+            false /* is_enterprise_device */),
+        task_runner_));
+  }
 }
 
 void UserCloudPolicyManagerChromeOS::OnAccessTokenAvailable(
@@ -262,6 +286,7 @@ void UserCloudPolicyManagerChromeOS::Shutdown() {
   if (service())
     service()->RemoveObserver(this);
   token_fetcher_.reset();
+  status_uploader_.reset();
   external_data_manager_->Disconnect();
   CloudPolicyManager::Shutdown();
 }

chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.h

@@ -41,6 +41,7 @@ class AppInstallEventLogUploader;
 class CloudExternalDataManager;
 class DeviceManagementService;
 class PolicyOAuth2TokenFetcher;
+class StatusUploader;
 
 // Implements logic for initializing user policy on Chrome OS.
 class UserCloudPolicyManagerChromeOS : public CloudPolicyManager,
@@ -151,6 +152,10 @@ class UserCloudPolicyManagerChromeOS : public CloudPolicyManager,
   // Helper function to force a policy fetch timeout.
   void ForceTimeoutForTest();
 
+  // Return the StatusUploader used to communicate consumer device status to the
+  // policy server.
+  StatusUploader* GetStatusUploader() const { return status_uploader_.get(); }
+
  protected:
   // CloudPolicyManager:
   void GetChromePolicy(PolicyMap* policy_map) override;
@@ -232,6 +237,12 @@ class UserCloudPolicyManagerChromeOS : public CloudPolicyManager,
   // Keeps alive the wildcard checker while its running.
   std::unique_ptr<WildcardLoginChecker> wildcard_login_checker_;
 
+  // Task runner used for non-enterprise device status upload.
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
+
+  // Helper object for updating the server with consumer device state.
+  std::unique_ptr<StatusUploader> status_uploader_;
+
   // The access token passed to OnAccessTokenAvailable. It is stored here so
   // that it can be used if OnInitializationCompleted is called later.
   std::string access_token_;

chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos_unittest.cc

@@ -22,6 +22,7 @@
 #include "chrome/browser/chromeos/login/users/fake_chrome_user_manager.h"
 #include "chrome/browser/chromeos/policy/user_cloud_policy_token_forwarder.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
+#include "chrome/browser/chromeos/settings/stub_install_attributes.h"
 #include "chrome/browser/policy/cloud/cloud_policy_test_utils.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/signin/fake_profile_oauth2_token_service_builder.h"
@@ -31,6 +32,7 @@
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
 #include "components/policy/core/common/cloud/cloud_external_data_manager.h"
 #include "components/policy/core/common/cloud/mock_cloud_external_data_manager.h"
 #include "components/policy/core/common/cloud/mock_cloud_policy_store.h"
@@ -126,6 +128,8 @@ class UserCloudPolicyManagerChromeOSTest : public testing::Test {
         user_manager_enabler_(base::WrapUnique(user_manager_)) {}
 
   void SetUp() override {
+    chromeos::DBusThreadManager::Initialize();
+
     // The initialization path that blocks on the initial policy fetch requires
     // a signin Profile to use its URLRequestContext.
     profile_manager_.reset(
@@ -194,6 +198,8 @@ class UserCloudPolicyManagerChromeOSTest : public testing::Test {
     signin_profile_ = NULL;
     profile_ = NULL;
     profile_manager_->DeleteTestingProfile(chrome::kInitialProfile);
+
+    chromeos::DBusThreadManager::Shutdown();
   }
 
   void MakeManagerWithEmptyStore(const base::TimeDelta& fetch_timeout,
@@ -794,4 +800,57 @@ TEST_F(UserCloudPolicyManagerChromeOSTest, TestHasAppInstallEventLogUploader) {
   EXPECT_TRUE(manager_->GetAppInstallEventLogUploader());
 }
 
+// Tests uploading status to DMServer. Install attributes for testing need to be
+// set before BrowserPolicyConnectorChromeOS is created, therefore
+// initialization of test environment is done at the begining of the test
+// instead of SetUp method.
+class StatusUploadingTest : public UserCloudPolicyManagerChromeOSTest {
+ protected:
+  StatusUploadingTest() = default;
+  ~StatusUploadingTest() override = default;
+
+  void SetUp() override{};
+  void TearDown() override{};
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(StatusUploadingTest);
+};
+
+TEST_F(StatusUploadingTest, UnownedDeviceShouldNotUploadStatus) {
+  auto install_attributes =
+      chromeos::ScopedStubInstallAttributes::CreateUnset();
+  UserCloudPolicyManagerChromeOSTest::SetUp();
+
+  ASSERT_NO_FATAL_FAILURE(MakeManagerWithPreloadedStore(base::TimeDelta()));
+  EXPECT_TRUE(manager_->core()->client()->is_registered());
+  EXPECT_EQ(nullptr, manager_->GetStatusUploader());
+
+  UserCloudPolicyManagerChromeOSTest::TearDown();
+}
+
+TEST_F(StatusUploadingTest, ManagedDeviceShouldNotUploadStatus) {
+  auto install_attributes =
+      chromeos::ScopedStubInstallAttributes::CreateCloudManaged("domain.com",
+                                                                "device-id");
+  UserCloudPolicyManagerChromeOSTest::SetUp();
+
+  ASSERT_NO_FATAL_FAILURE(MakeManagerWithPreloadedStore(base::TimeDelta()));
+  EXPECT_TRUE(manager_->core()->client()->is_registered());
+  EXPECT_EQ(nullptr, manager_->GetStatusUploader());
+
+  UserCloudPolicyManagerChromeOSTest::TearDown();
+}
+
+TEST_F(StatusUploadingTest, RegisteredConsumerDeviceShouldUploadStatus) {
+  auto install_attributes =
+      chromeos::ScopedStubInstallAttributes::CreateConsumerOwned();
+  UserCloudPolicyManagerChromeOSTest::SetUp();
+
+  ASSERT_NO_FATAL_FAILURE(MakeManagerWithPreloadedStore(base::TimeDelta()));
+  EXPECT_TRUE(manager_->core()->client()->is_registered());
+  EXPECT_NE(nullptr, manager_->GetStatusUploader());
+
+  UserCloudPolicyManagerChromeOSTest::TearDown();
+}
+
 }  // namespace policy