Add sound volume to device attribute reporting

chrome/browser/chromeos/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/chromeos/policy/device_status_collector.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 25 matching lines @@
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.h"
 #include "chrome/browser/chromeos/policy/user_policy_manager_factory_chromeos.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/policy/profile_policy_connector.h"
 #include "chrome/browser/policy/profile_policy_connector_factory.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/pref_names.h"
+#include "chromeos/audio/cras_audio_handler.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/update_engine_client.h"
 #include "chromeos/disks/disk_mount_manager.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "chromeos/system/statistics_provider.h"
 #include "components/arc/arc_bridge_service.h"
@@ skipping 422 matching lines @@
   users_subscription_ = cros_settings_->AddSettingsObserver(
       chromeos::kReportDeviceUsers, callback);
   hardware_status_subscription_ = cros_settings_->AddSettingsObserver(
       chromeos::kReportDeviceHardwareStatus, callback);
   session_status_subscription_ = cros_settings_->AddSettingsObserver(
       chromeos::kReportDeviceSessionStatus, callback);
   os_update_status_subscription_ = cros_settings_->AddSettingsObserver(
       chromeos::kReportOsUpdateStatus, callback);
   running_kiosk_app_subscription_ = cros_settings_->AddSettingsObserver(
       chromeos::kReportRunningKioskApp, callback);
+  sound_volume_subscription_ = cros_settings_->AddSettingsObserver(
+      chromeos::kReportSoundVolume, callback);
 
   // Fetch the current values of the policies.
   UpdateReportingSettings();
 
   // Get the the OS and firmware version info.
   base::PostTaskAndReplyWithResult(
       content::BrowserThread::GetBlockingPool(),
       FROM_HERE,
       base::Bind(&chromeos::version_loader::GetVersion,
                  chromeos::version_loader::VERSION_FULL),
@@ skipping 53 matching lines @@
   }
   if (!cros_settings_->GetBoolean(
           chromeos::kReportDeviceNetworkInterfaces,
           &report_network_interfaces_)) {
     report_network_interfaces_ = true;
   }
   if (!cros_settings_->GetBoolean(
           chromeos::kReportDeviceUsers, &report_users_)) {
     report_users_ = true;
   }
+  if (!cros_settings_->GetBoolean(
+          chromeos::kReportSoundVolume, &report_sound_volume_)) {
+    report_sound_volume_ = true;
+  }
 
   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;
@@ skipping 404 matching lines @@
     scoped_refptr<GetStatusState> state) {
   // Sample disk volume info in a background thread.
   state->SampleVolumeInfo(volume_info_fetcher_);
 
   // Sample CPU temperature in a background thread.
   state->SampleCPUTempInfo(cpu_temp_fetcher_);
 
   // Add CPU utilization and free RAM. Note that these stats are sampled in
   // regular intervals. Unlike CPU temp and volume info these are not one-time
   // sampled values, hence the difference in logic.
   status->set_system_ram_total(base::SysInfo::AmountOfPhysicalMemory());

[Andrew T Wilson (Slow), 2017/03/09 15:56:34]

I'd include the volume reporting here.

   status->clear_system_ram_free();
   status->clear_cpu_utilization_pct();
   for (const ResourceUsage& usage : resource_usage_) {
     status->add_cpu_utilization_pct(usage.cpu_usage_percent);
     status->add_system_ram_free(usage.bytes_of_ram_free);
   }
   return true;
 }
 
 bool DeviceStatusCollector::GetOsUpdateStatus(
@@ skipping 76 matching lines @@
 
   chromeos::KioskAppManager::App app_info;
   if (chromeos::KioskAppManager::Get()->GetApp(account->kiosk_app_id,
                                                &app_info)) {
     running_kiosk_app->set_required_platform_version(
         app_info.required_platform_version);
   }
   return true;
 }
 
+bool DeviceStatusCollector::GetSoundVolume(
+    em::DeviceStatusReportRequest* status) {
+  chromeos::CrasAudioHandler* audio_handler = chromeos::CrasAudioHandler::Get();
+  status->set_sound_volume(audio_handler->GetOutputVolumePercent());
+  return true;
+}
+
 void DeviceStatusCollector::GetDeviceAndSessionStatusAsync(
     const StatusCallback& response) {
   // Must be on creation thread since some stats are written to in that thread
   // and accessing them from another thread would lead to race conditions.
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Some of the data we're collecting is gathered in background threads.
   // This object keeps track of the state of each async request.
   scoped_refptr<GetStatusState> state(
       new GetStatusState(task_runner_, response));
@@ skipping 32 matching lines @@
 
   if (report_hardware_status_)
     anything_reported |= GetHardwareStatus(status, state);
 
   if (report_os_update_status_)
     anything_reported |= GetOsUpdateStatus(status);
 
   if (report_running_kiosk_app_)
     anything_reported |= GetRunningKioskApp(status);
 
+  if (report_sound_volume_)
+    anything_reported |= GetSoundVolume(status);
+
   // Wipe pointer if we didn't actually add any data.
   if (!anything_reported)
     state->ResetDeviceStatus();
 }
 
 std::string DeviceStatusCollector::GetDMTokenForProfile(Profile* profile) {
   CloudPolicyManager* user_cloud_policy_manager =
       UserPolicyManagerFactoryChromeOS::GetCloudPolicyManagerForProfile(
           profile);
   if (!user_cloud_policy_manager) {
@@ skipping 101 matching lines @@
 
 void DeviceStatusCollector::OnOSVersion(const std::string& version) {
   os_version_ = version;
 }
 
 void DeviceStatusCollector::OnOSFirmware(const std::string& version) {
   firmware_version_ = version;
 }
 
 }  // namespace policy