Simplify CrasAudioHandler code.

chromeos/audio/cras_audio_handler.cc

 // Copyright (c) 2013 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 "chromeos/audio/cras_audio_handler.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 23 matching lines @@
 const int kMuteThresholdPercent = 1;
 
 // The duration of HDMI output re-discover grace period in milliseconds.
 const int kHDMIRediscoverGracePeriodDurationInMs = 2000;
 
 // Mixer matrix, [0.5, 0.5; 0.5, 0.5]
 const double kStereoToMono[] = {0.5, 0.5, 0.5, 0.5};
 // Mixer matrix, [1, 0; 0, 1]
 const double kStereoToStereo[] = {1, 0, 0, 1};
 
-static CrasAudioHandler* g_cras_audio_handler = nullptr;
+CrasAudioHandler* g_cras_audio_handler = nullptr;
 
 bool IsSameAudioDevice(const AudioDevice& a, const AudioDevice& b) {
   return a.stable_device_id == b.stable_device_id && a.is_input == b.is_input &&
          a.type == b.type && a.device_name == b.device_name;
 }
 
 bool IsDeviceInList(const AudioDevice& device, const AudioNodeList& node_list) {
   for (const AudioNode& node : node_list) {
     if (device.stable_device_id == node.StableDeviceId())
       return true;
   }
   return false;
 }
 
+CrasAudioClient* GetCrasAudioClient() {
+  return DBusThreadManager::Get()->GetCrasAudioClient();
+}
+
+bool HasCrasAudioClient() {
+  return DBusThreadManager::IsInitialized() && DBusThreadManager::Get() &&
+         DBusThreadManager::Get()->GetCrasAudioClient();
+}
+
 }  // namespace
 
 CrasAudioHandler::AudioObserver::AudioObserver() {
 }
 
 CrasAudioHandler::AudioObserver::~AudioObserver() {
 }
 
 void CrasAudioHandler::AudioObserver::OnOutputNodeVolumeChanged(
     uint64_t /* node_id */,
@@ skipping 180 matching lines @@
 
 int CrasAudioHandler::GetOutputDefaultVolumeMuteThreshold() {
   return kMuteThresholdPercent;
 }
 
 int CrasAudioHandler::GetOutputVolumePercent() {
   return output_volume_;
 }
 
 int CrasAudioHandler::GetOutputVolumePercentForDevice(uint64_t device_id) {
-  if (device_id == active_output_node_id_) {
+  if (device_id == active_output_node_id_)
     return output_volume_;
-  } else {
-    const AudioDevice* device = GetDeviceFromId(device_id);
-    return static_cast<int>(audio_pref_handler_->GetOutputVolumeValue(device));
-  }
+  const AudioDevice* device = GetDeviceFromId(device_id);
+  return static_cast<int>(audio_pref_handler_->GetOutputVolumeValue(device));
 }
 
 int CrasAudioHandler::GetInputGainPercent() {
   return input_gain_;
 }
 
 int CrasAudioHandler::GetInputGainPercentForDevice(uint64_t device_id) {
-  if (device_id == active_input_node_id_) {
+  if (device_id == active_input_node_id_)
     return input_gain_;
-  } else {
-    const AudioDevice* device = GetDeviceFromId(device_id);
-    return static_cast<int>(audio_pref_handler_->GetInputGainValue(device));
-  }
+  const AudioDevice* device = GetDeviceFromId(device_id);
+  return static_cast<int>(audio_pref_handler_->GetInputGainValue(device));
 }
 
 uint64_t CrasAudioHandler::GetPrimaryActiveOutputNode() const {
   return active_output_node_id_;
 }
 
 uint64_t CrasAudioHandler::GetPrimaryActiveInputNode() const {
   return active_input_node_id_;
 }
 
@@ skipping 38 matching lines @@
   if ((device->is_input && !active_input_node_id_) ||
       (!device->is_input && !active_output_node_id_)) {
     SwitchToDevice(*device, notify, ACTIVATE_BY_USER);
     return;
   }
 
   AddAdditionalActiveNode(node_id, notify);
 }
 
 void CrasAudioHandler::ChangeActiveNodes(const NodeIdList& new_active_ids) {
-  chromeos::AudioDeviceList input_devices;
-  chromeos::AudioDeviceList output_devices;
+  AudioDeviceList input_devices;
+  AudioDeviceList output_devices;
 
   for (uint64_t id : new_active_ids) {
-    const chromeos::AudioDevice* device = GetDeviceFromId(id);
+    const AudioDevice* device = GetDeviceFromId(id);
     if (!device)
       continue;
     if (device->is_input)
       input_devices.push_back(*device);
     else
       output_devices.push_back(*device);
   }
   if (!input_devices.empty())
     SetActiveDevices(input_devices, true /* is_input */);
   if (!output_devices.empty())
     SetActiveDevices(output_devices, false /* is_input */);
 }
 
 bool CrasAudioHandler::SetActiveInputNodes(const NodeIdList& node_ids) {
   return SetActiveNodes(node_ids, true /* is_input */);
 }
 
 bool CrasAudioHandler::SetActiveOutputNodes(const NodeIdList& node_ids) {
   return SetActiveNodes(node_ids, false /* is_input */);
 }
 
 bool CrasAudioHandler::SetActiveNodes(const NodeIdList& node_ids,
                                       bool is_input) {
-  chromeos::AudioDeviceList devices;
+  AudioDeviceList devices;
   for (uint64_t id : node_ids) {
-    const chromeos::AudioDevice* device = GetDeviceFromId(id);
+    const AudioDevice* device = GetDeviceFromId(id);
     if (!device || device->is_input != is_input)
       return false;
 
     devices.push_back(*device);
   }
 
   SetActiveDevices(devices, is_input);
   return true;
 }
 
@@ skipping 36 matching lines @@
   }
 
   if (active_devices_changed)
     NotifyActiveNodeChanged(is_input);
 }
 
 void CrasAudioHandler::SwapInternalSpeakerLeftRightChannel(bool swap) {
   for (const auto& item : audio_devices_) {
     const AudioDevice& device = item.second;
     if (!device.is_input && device.type == AUDIO_TYPE_INTERNAL_SPEAKER) {
-      chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->SwapLeftRight(
-          device.id, swap);
+      GetCrasAudioClient()->SwapLeftRight(device.id, swap);
       break;
     }
   }
 }
 
 void CrasAudioHandler::SetOutputMono(bool mono_on) {
   output_mono_on_ = mono_on;
   if (mono_on) {
-    chromeos::DBusThreadManager::Get()
-        ->GetCrasAudioClient()
-        ->SetGlobalOutputChannelRemix(
-            output_channels_,
-            std::vector<double>(kStereoToMono, std::end(kStereoToMono)));
+    GetCrasAudioClient()->SetGlobalOutputChannelRemix(
+        output_channels_,
+        std::vector<double>(kStereoToMono, std::end(kStereoToMono)));
   } else {
-    chromeos::DBusThreadManager::Get()
-        ->GetCrasAudioClient()
-        ->SetGlobalOutputChannelRemix(
-            output_channels_,
-            std::vector<double>(kStereoToStereo, std::end(kStereoToStereo)));
+    GetCrasAudioClient()->SetGlobalOutputChannelRemix(
+        output_channels_,
+        std::vector<double>(kStereoToStereo, std::end(kStereoToStereo)));
   }
 
   for (auto& observer : observers_)
     observer.OnOuputChannelRemixingChanged(mono_on);
 }
 
 bool CrasAudioHandler::IsOutputMonoEnabled() const {
   return output_mono_on_;
 }
 
@@ skipping 61 matching lines @@
 
 void CrasAudioHandler::SetInputMute(bool mute_on) {
   SetInputMuteInternal(mute_on);
   for (auto& observer : observers_)
     observer.OnInputMuteChanged(input_mute_on_);
 }
 
 void CrasAudioHandler::SetActiveDevice(const AudioDevice& active_device,
                                        bool notify,
                                        DeviceActivateType activate_by) {
-  if (active_device.is_input) {
-    chromeos::DBusThreadManager::Get()
-        ->GetCrasAudioClient()
-        ->SetActiveInputNode(active_device.id);
-  } else {
-    chromeos::DBusThreadManager::Get()
-        ->GetCrasAudioClient()
-        ->SetActiveOutputNode(active_device.id);
-  }
+  if (active_device.is_input)
+    GetCrasAudioClient()->SetActiveInputNode(active_device.id);
+  else
+    GetCrasAudioClient()->SetActiveOutputNode(active_device.id);
 
   if (notify)
     NotifyActiveNodeChanged(active_device.is_input);
 
   // Save active state for the nodes.
   for (const auto& item : audio_devices_) {
     const AudioDevice& device = item.second;
     if (device.is_input != active_device.is_input)
       continue;
     SaveDeviceState(device, device.active, activate_by);
@@ skipping 35 matching lines @@
   if (device->is_input)
     SetInputNodeGainPercent(device_id, value);
   else
     SetOutputNodeVolumePercent(device_id, value);
 }
 
 void CrasAudioHandler::SetMuteForDevice(uint64_t device_id, bool mute_on) {
   if (device_id == active_output_node_id_) {
     SetOutputMute(mute_on);
     return;
-  } else if (device_id == active_input_node_id_) {
+  }
+  if (device_id == active_input_node_id_) {
     VLOG(1) << "SetMuteForDevice sets active input device id="
             << "0x" << std::hex << device_id << " mute=" << mute_on;
     SetInputMute(mute_on);
     return;
   }
 
   const AudioDevice* device = GetDeviceFromId(device_id);
   // Input device's mute state is not recorded in the pref. crbug.com/365050.
   if (device && !device->is_input)
     audio_pref_handler_->SetMuteValue(*device, mute_on);
@@ skipping 39 matching lines @@
       output_mono_on_(false),
       log_errors_(false),
       hdmi_rediscover_grace_period_duration_in_ms_(
           kHDMIRediscoverGracePeriodDurationInMs),
       hdmi_rediscovering_(false),
       weak_ptr_factory_(this) {
   if (!audio_pref_handler.get())
     return;
   // If the DBusThreadManager or the CrasAudioClient aren't available, there
   // isn't much we can do. This should only happen when running tests.
-  if (!chromeos::DBusThreadManager::IsInitialized() ||
-      !chromeos::DBusThreadManager::Get() ||
-      !chromeos::DBusThreadManager::Get()->GetCrasAudioClient())
+  if (!HasCrasAudioClient())
     return;
-  chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->AddObserver(this);
+  GetCrasAudioClient()->AddObserver(this);
   audio_pref_handler_->AddAudioPrefObserver(this);
-  if (chromeos::DBusThreadManager::Get()->GetSessionManagerClient()) {
-    chromeos::DBusThreadManager::Get()->GetSessionManagerClient()->
-        AddObserver(this);
-  }
+  if (DBusThreadManager::Get()->GetSessionManagerClient())
+    DBusThreadManager::Get()->GetSessionManagerClient()->AddObserver(this);
   InitializeAudioState();
 }
 
 CrasAudioHandler::~CrasAudioHandler() {
   hdmi_rediscover_timer_.Stop();
-  if (!chromeos::DBusThreadManager::IsInitialized() ||
-      !chromeos::DBusThreadManager::Get() ||
-      !chromeos::DBusThreadManager::Get()->GetCrasAudioClient())
+  if (!HasCrasAudioClient())
     return;
-  chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->
-      RemoveObserver(this);
-  chromeos::DBusThreadManager::Get()->GetSessionManagerClient()->
-      RemoveObserver(this);
+  GetCrasAudioClient()->RemoveObserver(this);
+  if (DBusThreadManager::Get()->GetSessionManagerClient())
+    DBusThreadManager::Get()->GetSessionManagerClient()->RemoveObserver(this);
   if (audio_pref_handler_.get())
     audio_pref_handler_->RemoveAudioPrefObserver(this);
   audio_pref_handler_ = nullptr;
 }
 
 void CrasAudioHandler::AudioClientRestarted() {
   // Make sure the logging is enabled in case cras server
   // restarts after crashing.
   LogErrors();
   InitializeAudioState();
@@ skipping 91 matching lines @@
 void CrasAudioHandler::EmitLoginPromptVisibleCalled() {
   // Enable logging after cras server is started, which will be after
   // EmitLoginPromptVisible.
   LogErrors();
 }
 
 const AudioDevice* CrasAudioHandler::GetDeviceFromId(uint64_t device_id) const {
   AudioDeviceMap::const_iterator it = audio_devices_.find(device_id);
   if (it == audio_devices_.end())
     return nullptr;
-
-  return &(it->second);
+  return &it->second;
 }
 
 const AudioDevice* CrasAudioHandler::GetDeviceFromStableDeviceId(
     uint64_t stable_device_id) const {
   for (const auto& item : audio_devices_) {
     const AudioDevice& device = item.second;
     if (device.stable_device_id == stable_device_id)
       return &device;
   }
   return nullptr;
@@ skipping 81 matching lines @@
     SetOutputNodeVolumePercent(node_id, GetOutputVolumePercent());
   }
 }
 
 void CrasAudioHandler::InitializeAudioState() {
   initializing_audio_state_ = true;
   ApplyAudioPolicy();
 
   // Defer querying cras for GetNodes until cras service becomes available.
   cras_service_available_ = false;
-  chromeos::DBusThreadManager::Get()
-      ->GetCrasAudioClient()
-      ->WaitForServiceToBeAvailable(base::Bind(
-          &CrasAudioHandler::InitializeAudioAfterCrasServiceAvailable,
-          weak_ptr_factory_.GetWeakPtr()));
+  GetCrasAudioClient()->WaitForServiceToBeAvailable(
+      base::Bind(&CrasAudioHandler::InitializeAudioAfterCrasServiceAvailable,
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 void CrasAudioHandler::InitializeAudioAfterCrasServiceAvailable(
     bool service_is_available) {
   if (!service_is_available) {
     LOG(ERROR) << "Cras service is not available";
     cras_service_available_ = false;
     return;
   }
 
@@ skipping 12 matching lines @@
     const AudioDevice* device = GetDeviceFromId(active_output_node_id_);
     if (device)
       SetOutputMuteInternal(audio_pref_handler_->GetMuteValue(*device));
   }
 
   // Policy for audio input is handled by kAudioCaptureAllowed in the Chrome
   // media system.
 }
 
 void CrasAudioHandler::SetOutputNodeVolume(uint64_t node_id, int volume) {
-  chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->
-      SetOutputNodeVolume(node_id, volume);
+  GetCrasAudioClient()->SetOutputNodeVolume(node_id, volume);
 }
 
 void CrasAudioHandler::SetOutputNodeVolumePercent(uint64_t node_id,
                                                   int volume_percent) {
   const AudioDevice* device = GetDeviceFromId(node_id);
   if (!device || device->is_input)
     return;
 
   volume_percent = min(max(volume_percent, 0), 100);
   if (volume_percent <= kMuteThresholdPercent)
     volume_percent = 0;
 
   // Save the volume setting in pref in case this is called on non-active
   // node for configuration.
   audio_pref_handler_->SetVolumeGainValue(*device, volume_percent);
 
   if (device->active)
     SetOutputNodeVolume(node_id, volume_percent);
 }
 
 bool  CrasAudioHandler::SetOutputMuteInternal(bool mute_on) {
   if (output_mute_locked_)
     return false;
 
   output_mute_on_ = mute_on;
-  chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->
-      SetOutputUserMute(mute_on);
+  GetCrasAudioClient()->SetOutputUserMute(mute_on);
   return true;
 }
 
 void CrasAudioHandler::SetInputNodeGain(uint64_t node_id, int gain) {
-  chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->
-      SetInputNodeGain(node_id, gain);
+  GetCrasAudioClient()->SetInputNodeGain(node_id, gain);
 }
 
 void CrasAudioHandler::SetInputNodeGainPercent(uint64_t node_id,
                                                int gain_percent) {
   const AudioDevice* device = GetDeviceFromId(node_id);
   if (!device || !device->is_input)
     return;
 
   // NOTE: We do not sanitize input gain values since the range is completely
   // dependent on the device.
   if (active_input_node_id_ == node_id)
     input_gain_ = gain_percent;
 
   audio_pref_handler_->SetVolumeGainValue(*device, gain_percent);
 
   if (device->active) {
     SetInputNodeGain(node_id, gain_percent);
     for (auto& observer : observers_)
       observer.OnInputNodeGainChanged(node_id, gain_percent);
   }
 }
 
 void CrasAudioHandler::SetInputMuteInternal(bool mute_on) {
   input_mute_on_ = mute_on;
-  chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->
-      SetInputMute(mute_on);
+  GetCrasAudioClient()->SetInputMute(mute_on);
 }
 
 void CrasAudioHandler::GetNodes() {
-  chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->GetNodes(
+  GetCrasAudioClient()->GetNodes(
       base::Bind(&CrasAudioHandler::HandleGetNodes,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&CrasAudioHandler::HandleGetNodesError,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 bool CrasAudioHandler::ChangeActiveDevice(
     const AudioDevice& new_active_device) {
   uint64_t& current_active_node_id = new_active_device.is_input
                                          ? active_input_node_id_
@@ skipping 88 matching lines @@
   const AudioDevice* device_found =
       GetDeviceFromStableDeviceId(device.stable_device_id);
   if (!device_found)
     return NEW_DEVICE;
 
   if (!IsSameAudioDevice(device, *device_found)) {
     LOG(ERROR) << "Different Audio devices with same stable device id:"
                << " new device: " << device.ToString()
                << " old device: " << device_found->ToString();
     return CHANGED_DEVICE;
-  } else if (device.active != device_found->active) {
+  }
+  if (device.active != device_found->active)
     return CHANGED_DEVICE;
-  }
-
   return OLD_DEVICE;
 }
 
 void CrasAudioHandler::NotifyActiveNodeChanged(bool is_input) {
-  if (is_input)
+  if (is_input) {
     for (auto& observer : observers_)
       observer.OnActiveInputNodeChanged();
-  else
+  } else {
     for (auto& observer : observers_)
       observer.OnActiveOutputNodeChanged();
+  }
 }
 
 bool CrasAudioHandler::GetActiveDeviceFromUserPref(bool is_input,
                                                    AudioDevice* active_device) {
   bool found_active_device = false;
   bool last_active_device_activate_by_user = false;
   for (const auto& item : audio_devices_) {
     const AudioDevice& device = item.second;
     if (device.is_input != is_input || !device.is_for_simple_usage())
       continue;
@@ skipping 14 matching lines @@
 
     if (!found_active_device) {
       found_active_device = true;
       *active_device = device;
       last_active_device_activate_by_user = activate_by_user;
       continue;
     }
 
     // Choose the best one among multiple active devices from prefs.
     if (activate_by_user) {
-      if (!last_active_device_activate_by_user) {
-        // Device activated by user has higher priority than the one
-        // is not activated by user.
-        *active_device = device;
-        last_active_device_activate_by_user = true;
-      } else {
+      if (last_active_device_activate_by_user) {
         // If there are more than one active devices activated by user in the
         // prefs, most likely, after the device was shut down, and before it
         // is rebooted, user has plugged in some previously unplugged audio
         // devices. For such case, it does not make sense to honor the active
         // states in the prefs.
         VLOG(1) << "Found more than one user activated devices in the prefs.";
         return false;
       }
+      // Device activated by user has higher priority than the one
+      // is not activated by user.
+      *active_device = device;
+      last_active_device_activate_by_user = true;
     } else if (!last_active_device_activate_by_user) {
       // If there are more than one active devices activated by priority in the
       // prefs, most likely, cras is still enumerating the audio devices
       // progressively. For such case, it does not make sense to honor the
       // active states in the prefs.
       VLOG(1) << "Found more than one active devices by priority in the prefs.";
       return false;
     }
   }
 
@@ skipping 254 matching lines @@
     VLOG(1) << "AddActiveInputNode: Cannot find device id="
             << "0x" << std::hex << node_id;
     return;
   }
 
   audio_devices_[node_id].active = true;
   SetupAdditionalActiveAudioNodeState(node_id);
 
   if (device->is_input) {
     DCHECK(node_id != active_input_node_id_);
-    chromeos::DBusThreadManager::Get()
-        ->GetCrasAudioClient()
-        ->AddActiveInputNode(node_id);
+    GetCrasAudioClient()->AddActiveInputNode(node_id);
     if (notify)
       NotifyActiveNodeChanged(true);
   } else {
     DCHECK(node_id != active_output_node_id_);
-    chromeos::DBusThreadManager::Get()
-        ->GetCrasAudioClient()
-        ->AddActiveOutputNode(node_id);
+    GetCrasAudioClient()->AddActiveOutputNode(node_id);
     if (notify)
       NotifyActiveNodeChanged(false);
   }
 }
 
 void CrasAudioHandler::RemoveActiveNodeInternal(uint64_t node_id, bool notify) {
   const AudioDevice* device = GetDeviceFromId(node_id);
   if (!device) {
     VLOG(1) << "RemoveActiveInputNode: Cannot find device id="
             << "0x" << std::hex << node_id;
     return;
   }
 
   audio_devices_[node_id].active = false;
   if (device->is_input) {
     if (node_id == active_input_node_id_)
       active_input_node_id_ = 0;
-    chromeos::DBusThreadManager::Get()
-        ->GetCrasAudioClient()
-        ->RemoveActiveInputNode(node_id);
+    GetCrasAudioClient()->RemoveActiveInputNode(node_id);
     if (notify)
       NotifyActiveNodeChanged(true);
   } else {
     if (node_id == active_output_node_id_)
       active_output_node_id_ = 0;
-    chromeos::DBusThreadManager::Get()
-        ->GetCrasAudioClient()
-        ->RemoveActiveOutputNode(node_id);
+    GetCrasAudioClient()->RemoveActiveOutputNode(node_id);
     if (notify)
       NotifyActiveNodeChanged(false);
   }
 }
 
 void CrasAudioHandler::UpdateAudioAfterHDMIRediscoverGracePeriod() {
   VLOG(1) << "HDMI output re-discover grace period ends.";
   hdmi_rediscovering_ = false;
   if (!IsOutputMutedForDevice(active_output_node_id_)) {
     // Unmute the audio output after the HDMI transition period.
     VLOG(1) << "Unmute output after HDMI rediscovering grace period.";
     SetOutputMuteInternal(false);
 
     // Notify UI about the mute state change.
     for (auto& observer : observers_) {
       observer.OnOutputMuteChanged(output_mute_on_,
                                    true /* system adjustment */);
     }
   }
 }
 
 bool CrasAudioHandler::IsHDMIPrimaryOutputDevice() const {
   const AudioDevice* device = GetDeviceFromId(active_output_node_id_);
-  return (device && device->type == chromeos::AUDIO_TYPE_HDMI);
+  return device && device->type == AUDIO_TYPE_HDMI;
 }
 
 void CrasAudioHandler::StartHDMIRediscoverGracePeriod() {
   VLOG(1) << "Start HDMI rediscovering grace period.";
   hdmi_rediscovering_ = true;
   hdmi_rediscover_timer_.Stop();
   hdmi_rediscover_timer_.Start(
       FROM_HERE, base::TimeDelta::FromMilliseconds(
                      hdmi_rediscover_grace_period_duration_in_ms_),
       this, &CrasAudioHandler::UpdateAudioAfterHDMIRediscoverGracePeriod);
@@ skipping 88 matching lines @@
 bool CrasAudioHandler::HasExternalDevice(bool is_input) const {
   for (const auto& item : audio_devices_) {
     const AudioDevice& device = item.second;
     if (is_input == device.is_input && device.IsExternalDevice())
       return true;
   }
   return false;
 }
 
 }  // namespace chromeos