Handle the dual microphones and dual cameras cases. Activate the proper microphone when user activa…

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 std::vector<double> kStereoToMono = {0.5, 0.5, 0.5, 0.5};
 // Mixer matrix, [1, 0; 0, 1]
 const std::vector<double> kStereoToStereo = {1, 0, 0, 1};
 
-static CrasAudioHandler* g_cras_audio_handler = NULL;
+static 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;
@@ skipping 49 matching lines @@
 // static
 void CrasAudioHandler::InitializeForTesting() {
   CHECK(!g_cras_audio_handler);
   CrasAudioHandler::Initialize(new AudioDevicesPrefHandlerStub());
 }
 
 // static
 void CrasAudioHandler::Shutdown() {
   CHECK(g_cras_audio_handler);
   delete g_cras_audio_handler;
-  g_cras_audio_handler = NULL;
+  g_cras_audio_handler = nullptr;
 }
 
 // static
 bool CrasAudioHandler::IsInitialized() {
-  return g_cras_audio_handler != NULL;
+  return g_cras_audio_handler != nullptr;
 }
 
 // static
 CrasAudioHandler* CrasAudioHandler::Get() {
   CHECK(g_cras_audio_handler)
       << "CrasAudioHandler::Get() called before Initialize().";
   return g_cras_audio_handler;
 }
 
 void CrasAudioHandler::OnVideoCaptureStarted(media::VideoFacingMode facing) {
-  // TODO(jennyz): Switch active audio device according to video facing.
+  // Do nothing if the device doesn't have both front and rear microphones.
+  if (!HasDualInternalMic())
+    return;
+
+  bool camera_is_already_on = IsCameraOn();
+  switch (facing) {
+    case media::MEDIA_VIDEO_FACING_USER:
+      front_camera_on_ = true;
+      break;
+    case media::MEDIA_VIDEO_FACING_ENVIRONMENT:
+      rear_camera_on_ = true;
+      break;
+    default:
+      LOG_IF(WARNING, facing == media::NUM_MEDIA_VIDEO_FACING_MODES)
+          << "On the device with dual microphone, got video capture "
+          << "notification with invalid camera facing mode value";
+      return;
+  }
+
+  // If the camera is already on before this notification, don't change active
+  // input. In the case that both cameras are turned on at the same time, we
+  // won't change the active input after the first camera is turned on. We only
+  // support the use case of one camera on at a time. The third party
+  // developer can turn on/off both microphones with extension api if they like
+  // to.
+  if (camera_is_already_on)
+    return;
+
+  // If the current active input is an external device, keep it.
+  const AudioDevice* active_input = GetDeviceFromId(active_input_node_id_);
+  if (active_input && active_input->IsExternalDevice())
+    return;
+
+  // Activate the correct mic for the current active camera.
+  ActivateMicForCamera(facing);
 }
 
 void CrasAudioHandler::OnVideoCaptureStopped(media::VideoFacingMode facing) {
-  // TODO(jennyz): Switch active audio device according to video facing.
+  // Do nothing if the device doesn't have both front and rear microphones.
+  if (!HasDualInternalMic())
+    return;
+
+  switch (facing) {
+    case media::MEDIA_VIDEO_FACING_USER:
+      front_camera_on_ = false;
+      break;
+    case media::MEDIA_VIDEO_FACING_ENVIRONMENT:
+      rear_camera_on_ = false;
+      break;
+    default:
+      LOG_IF(WARNING, facing == media::NUM_MEDIA_VIDEO_FACING_MODES)
+          << "On the device with dual microphone, got video capture "
+          << "notification with invalid camera facing mode value";
+      return;
+  }
+
+  // If not all cameras are turned off, don't change active input. In the case
+  // that both cameras are turned on at the same time before one of them is
+  // stopped, we won't change active input until all of them are stopped.
+  // We only support the use case of one camera on at a time. The third party
+  // developer can turn on/off both microphones with extension api if they like
+  // to.
+  if (IsCameraOn())
+    return;
+
+  // If the current active input is an external device, keep it.
+  const AudioDevice* active_input = GetDeviceFromId(active_input_node_id_);
+  if (active_input && active_input->IsExternalDevice())
+    return;
+
+  // Switch to front mic properly.
+  DeviceActivateType activated_by =
+      HasExternalDevice(true) ? ACTIVATE_BY_USER : ACTIVATE_BY_PRIORITY;
+  SwitchToDevice(*GetDeviceByType(AUDIO_TYPE_FRONT_MIC), true, activated_by);
 }
 
 void CrasAudioHandler::AddAudioObserver(AudioObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void CrasAudioHandler::RemoveAudioObserver(AudioObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 bool CrasAudioHandler::HasKeyboardMic() {
-  return GetKeyboardMic() != NULL;
+  return GetKeyboardMic() != nullptr;
 }
 
 bool CrasAudioHandler::IsOutputMuted() {
   return output_mute_on_;
 }
 
 bool CrasAudioHandler::IsOutputMutedForDevice(uint64_t device_id) {
   const AudioDevice* device = GetDeviceFromId(device_id);
   if (!device)
     return false;
@@ skipping 54 matching lines @@
 uint64_t CrasAudioHandler::GetPrimaryActiveOutputNode() const {
   return active_output_node_id_;
 }
 
 uint64_t CrasAudioHandler::GetPrimaryActiveInputNode() const {
   return active_input_node_id_;
 }
 
 void CrasAudioHandler::GetAudioDevices(AudioDeviceList* device_list) const {
   device_list->clear();
-  for (AudioDeviceMap::const_iterator it = audio_devices_.begin();
-       it != audio_devices_.end(); ++it)
-    device_list->push_back(it->second);
+  for (const auto& item : audio_devices_) {
+    const AudioDevice& device = item.second;
+    device_list->push_back(device);
+  }
 }
 
 bool CrasAudioHandler::GetPrimaryActiveOutputDevice(AudioDevice* device) const {
   const AudioDevice* active_device = GetDeviceFromId(active_output_node_id_);
   if (!active_device || !device)
     return false;
   *device = *active_device;
   return true;
 }
 
@@ skipping 106 matching lines @@
       AddActiveNode(existing_device.id, false /* notify */);
     else
       RemoveActiveNodeInternal(existing_device.id, false /* notify */);
   }
 
   if (active_devices_changed)
     NotifyActiveNodeChanged(is_input);
 }
 
 void CrasAudioHandler::SwapInternalSpeakerLeftRightChannel(bool swap) {
-  for (AudioDeviceMap::const_iterator it = audio_devices_.begin();
-       it != audio_devices_.end();
-       ++it) {
-    const AudioDevice& device = it->second;
+  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);
       break;
     }
   }
 }
 
 void CrasAudioHandler::SetOutputMono(bool mono_on) {
   output_mono_on_ = mono_on;
@@ skipping 16 matching lines @@
 bool CrasAudioHandler::has_alternative_input() const {
   return has_alternative_input_;
 }
 
 bool CrasAudioHandler::has_alternative_output() const {
   return has_alternative_output_;
 }
 
 void CrasAudioHandler::SetOutputVolumePercent(int volume_percent) {
   // Set all active devices to the same volume.
-  for (AudioDeviceMap::const_iterator it = audio_devices_.begin();
-       it != audio_devices_.end();
-       it++) {
-    const AudioDevice& device = it->second;
+  for (const auto& item : audio_devices_) {
+    const AudioDevice& device = item.second;
     if (!device.is_input && device.active)
       SetOutputNodeVolumePercent(device.id, volume_percent);
   }
 }
 
 void CrasAudioHandler::SetOutputVolumePercentWithoutNotifyingObservers(
     int volume_percent,
     AutomatedVolumeChangeReason reason) {
   automated_volume_change_reasons_.push_back(reason);
   SetOutputVolumePercent(volume_percent);
 }
 
 // TODO: Rename the 'Percent' to something more meaningful.
 void CrasAudioHandler::SetInputGainPercent(int gain_percent) {
   // TODO(jennyz): Should we set all input devices' gain to the same level?
-  for (AudioDeviceMap::const_iterator it = audio_devices_.begin();
-       it != audio_devices_.end();
-       it++) {
-    const AudioDevice& device = it->second;
+  for (const auto& item : audio_devices_) {
+    const AudioDevice& device = item.second;
     if (device.is_input && device.active)
       SetInputNodeGainPercent(active_input_node_id_, gain_percent);
   }
 }
 
 void CrasAudioHandler::AdjustOutputVolumeByPercent(int adjust_by_percent) {
   SetOutputVolumePercent(output_volume_ + adjust_by_percent);
 }
 
 void CrasAudioHandler::SetOutputMute(bool mute_on) {
   if (!SetOutputMuteInternal(mute_on))
     return;
 
   // Save the mute state for all active output audio devices.
-  for (AudioDeviceMap::const_iterator it = audio_devices_.begin();
-       it != audio_devices_.end();
-       it++) {
-    const AudioDevice& device = it->second;
+  for (const auto& item : audio_devices_) {
+    const AudioDevice& device = item.second;
     if (!device.is_input && device.active) {
       audio_pref_handler_->SetMuteValue(device, output_mute_on_);
     }
   }
 
   for (auto& observer : observers_)
     observer.OnOutputMuteChanged(output_mute_on_, false /* system_adjust */);
 }
 
 void CrasAudioHandler::AdjustOutputVolumeToAudibleLevel() {
@@ skipping 20 matching lines @@
   } else {
     chromeos::DBusThreadManager::Get()
         ->GetCrasAudioClient()
         ->SetActiveOutputNode(active_device.id);
   }
 
   if (notify)
     NotifyActiveNodeChanged(active_device.is_input);
 
   // Save active state for the nodes.
-  for (AudioDeviceMap::iterator it = audio_devices_.begin();
-       it != audio_devices_.end(); ++it) {
-    const AudioDevice& device = it->second;
+  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);
   }
 }
 
 void CrasAudioHandler::SaveDeviceState(const AudioDevice& device,
                                        bool active,
                                        DeviceActivateType activate_by) {
   // Don't save the active state for non-simple usage device, which is invisible
@@ skipping 113 matching lines @@
   if (!chromeos::DBusThreadManager::IsInitialized() ||
       !chromeos::DBusThreadManager::Get() ||
       !chromeos::DBusThreadManager::Get()->GetCrasAudioClient())
     return;
   chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->
       RemoveObserver(this);
   chromeos::DBusThreadManager::Get()->GetSessionManagerClient()->
       RemoveObserver(this);
   if (audio_pref_handler_.get())
     audio_pref_handler_->RemoveAudioPrefObserver(this);
-  audio_pref_handler_ = NULL;
+  audio_pref_handler_ = nullptr;
 }
 
 void CrasAudioHandler::AudioClientRestarted() {
   // Make sure the logging is enabled in case cras server
   // restarts after crashing.
   LogErrors();
   InitializeAudioState();
 }
 
 void CrasAudioHandler::NodesChanged() {
@@ skipping 87 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 NULL;
+    return nullptr;
 
   return &(it->second);
 }
 
 const AudioDevice* CrasAudioHandler::GetDeviceFromStableDeviceId(
     uint64_t stable_device_id) const {
-  for (AudioDeviceMap::const_iterator it = audio_devices_.begin();
-       it != audio_devices_.end(); ++it) {
-    if (it->second.stable_device_id == stable_device_id)
-      return &(it->second);
+  for (const auto& item : audio_devices_) {
+    const AudioDevice& device = item.second;
+    if (device.stable_device_id == stable_device_id)
+      return &device;
   }
-  return NULL;
+  return nullptr;
 }
 
 const AudioDevice* CrasAudioHandler::GetKeyboardMic() const {
-  for (AudioDeviceMap::const_iterator it = audio_devices_.begin();
-       it != audio_devices_.end(); it++) {
-    if (it->second.is_input && it->second.type == AUDIO_TYPE_KEYBOARD_MIC)
-      return &(it->second);
+  for (const auto& item : audio_devices_) {
+    const AudioDevice& device = item.second;
+    if (device.is_input && device.type == AUDIO_TYPE_KEYBOARD_MIC)
+      return &device;
   }
-  return NULL;
+  return nullptr;
 }
 
 void CrasAudioHandler::SetupAudioInputState() {
   // Set the initial audio state to the ones read from audio prefs.
   const AudioDevice* device = GetDeviceFromId(active_input_node_id_);
   if (!device) {
     LOG_IF(ERROR, log_errors_)
         << "Can't set up audio state for unknown input device id ="
         << "0x" << std::hex << active_input_node_id_;
     return;
@@ skipping 186 matching lines @@
   // do nothing.
   if (new_active_device.active &&
       new_active_device.id == current_active_node_id) {
     return false;
   }
 
   bool found_new_active_device = false;
   // Reset all other input or output devices' active status. The active audio
   // device from the previous user session can be remembered by cras, but not
   // in chrome. see crbug.com/273271.
-  for (AudioDeviceMap::iterator it = audio_devices_.begin();
-       it != audio_devices_.end(); ++it) {
-    if (it->second.is_input == new_active_device.is_input &&
-        it->second.id != new_active_device.id) {
-      it->second.active = false;
-    } else if (it->second.is_input == new_active_device.is_input &&
-               it->second.id == new_active_device.id) {
+  for (auto& item : audio_devices_) {
+    AudioDevice& device = item.second;
+    if (device.is_input == new_active_device.is_input &&
+        device.id != new_active_device.id) {
+      device.active = false;
+    } else if (device.is_input == new_active_device.is_input &&
+               device.id == new_active_device.id) {
       found_new_active_device = true;
     }
   }
 
   if (!found_new_active_device) {
     LOG(ERROR) << "Invalid new active device: " << new_active_device.ToString();
     return false;
   }
 
   // Set the current active input/output device to the new_active_device.
@@ skipping 15 matching lines @@
 
   SetActiveDevice(device, notify, activate_by);
 }
 
 bool CrasAudioHandler::HasDeviceChange(const AudioNodeList& new_nodes,
                                        bool is_input,
                                        AudioDevicePriorityQueue* new_discovered,
                                        bool* device_removed,
                                        bool* active_device_removed) {
   *device_removed = false;
-  for (AudioDeviceMap::const_iterator it = audio_devices_.begin();
-       it != audio_devices_.end(); ++it) {
-    const AudioDevice& device = it->second;
+  for (const auto& item : audio_devices_) {
+    const AudioDevice& device = item.second;
     if (is_input != device.is_input)
       continue;
     if (!IsDeviceInList(device, new_nodes)) {
       *device_removed = true;
       if ((is_input && device.id == active_input_node_id_) ||
           (!is_input && device.id == active_output_node_id_)) {
         *active_device_removed = true;
       }
     }
   }
 
   bool new_or_changed_device = false;
   while (!new_discovered->empty())
     new_discovered->pop();
-  for (AudioNodeList::const_iterator it = new_nodes.begin();
-       it != new_nodes.end(); ++it) {
-    if (is_input != it->is_input)
+
+  for (const AudioNode& node : new_nodes) {
+    if (is_input != node.is_input)
       continue;
     // Check if the new device is not in the old device list.
-    AudioDevice device(*it);
+    AudioDevice device(node);
     DeviceStatus status = CheckDeviceStatus(device);
     if (status == NEW_DEVICE)
       new_discovered->push(device);
     if (status == NEW_DEVICE || status == CHANGED_DEVICE) {
       new_or_changed_device = true;
     }
   }
   return new_or_changed_device || *device_removed;
 }
 
@@ skipping 22 matching lines @@
       observer.OnActiveInputNodeChanged();
   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 (AudioDeviceMap::const_iterator it = audio_devices_.begin();
-       it != audio_devices_.end(); ++it) {
-    AudioDevice device = it->second;
+  for (const auto& item : audio_devices_) {
+    const AudioDevice& device = item.second;
     if (device.is_input != is_input || !device.is_for_simple_usage())
       continue;
 
     bool active = false;
     bool activate_by_user = false;
     // If the device entry is not found in prefs, it is likley a new audio
     // device plugged in after the cros is powered down. We should ignore the
     // previously saved active device, and select the active device by priority.
     // crbug.com/622045.
     if (!audio_pref_handler_->GetDeviceActive(device, &active,
@@ skipping 113 matching lines @@
   } else {
     // Do not active the device if its previous state is inactive.
     VLOG(1) << "Hotplug device remains inactive as its previous state:"
             << hotplug_device.ToString();
   }
 }
 
 void CrasAudioHandler::SwitchToTopPriorityDevice(bool is_input) {
   AudioDevice top_device =
       is_input ? input_devices_pq_.top() : output_devices_pq_.top();
-  if (top_device.is_for_simple_usage())
-    SwitchToDevice(top_device, true, ACTIVATE_BY_PRIORITY);
+  if (!top_device.is_for_simple_usage())
+    return;
+
+  // For the dual camera and dual microphone case, choose microphone
+  // that is consistent to the active camera.
+  if (IsFrontOrRearMic(top_device) && HasDualInternalMic() && IsCameraOn()) {
+    ActivateInternalMicForActiveCamera();
+    return;
+  }
+
+  SwitchToDevice(top_device, true, ACTIVATE_BY_PRIORITY);
 }
 
 void CrasAudioHandler::SwitchToPreviousActiveDeviceIfAvailable(bool is_input) {
   AudioDevice previous_active_device;
   if (GetActiveDeviceFromUserPref(is_input, &previous_active_device)) {
     DCHECK(previous_active_device.is_for_simple_usage());
     // Switch to previous active device stored in user prefs.
     SwitchToDevice(previous_active_device, true,
                    ACTIVATE_BY_RESTORE_PREVIOUS_STATE);
   } else {
     // No previous active device, switch to the top priority device.
     SwitchToTopPriorityDevice(is_input);
   }
 }
 
 void CrasAudioHandler::UpdateDevicesAndSwitchActive(
     const AudioNodeList& nodes) {
   size_t old_output_device_size = 0;
   size_t old_input_device_size = 0;
-  for (AudioDeviceMap::const_iterator it = audio_devices_.begin();
-       it != audio_devices_.end(); ++it) {
-    if (it->second.is_input)
+  for (const auto& item : audio_devices_) {
+    const AudioDevice& device = item.second;
+    if (device.is_input)
       ++old_input_device_size;
     else
       ++old_output_device_size;
   }
 
   AudioDevicePriorityQueue hotplug_output_nodes;
   AudioDevicePriorityQueue hotplug_input_nodes;
   bool has_output_removed = false;
   bool has_input_removed = false;
   bool active_output_removed = false;
@@ skipping 196 matching lines @@
       FROM_HERE, base::TimeDelta::FromMilliseconds(
                      hdmi_rediscover_grace_period_duration_in_ms_),
       this, &CrasAudioHandler::UpdateAudioAfterHDMIRediscoverGracePeriod);
 }
 
 void CrasAudioHandler::SetHDMIRediscoverGracePeriodForTesting(
     int duration_in_ms) {
   hdmi_rediscover_grace_period_duration_in_ms_ = duration_in_ms;
 }
 
+void CrasAudioHandler::ActivateMicForCamera(
+    media::VideoFacingMode camera_facing) {
+  const AudioDevice* mic = GetMicForCamera(camera_facing);
+  if (!mic || mic->active)
+    return;
+
+  SwitchToDevice(*mic, true, ACTIVATE_BY_CAMERA);
+}
+
+void CrasAudioHandler::ActivateInternalMicForActiveCamera() {
+  DCHECK(IsCameraOn());
+  if (HasDualInternalMic()) {
+    media::VideoFacingMode facing = front_camera_on_
+                                        ? media::MEDIA_VIDEO_FACING_USER
+                                        : media::MEDIA_VIDEO_FACING_ENVIRONMENT;
+    ActivateMicForCamera(facing);
+  }
+}
+
+// For the dual microphone case, from user point of view, they only see internal
+// microphone in UI. Chrome will make the best decision on which one to pick.
+// If the camera is off, the front microphone should be picked as the default
+// active microphone. Otherwise, it will switch to the microphone that
+// matches the active camera, i.e. front microphone for front camera and
+// rear microphone for rear camera.
+void CrasAudioHandler::SwitchToFrontOrRearMic() {
+  DCHECK(HasDualInternalMic());
+  if (IsCameraOn()) {
+    ActivateInternalMicForActiveCamera();
+  } else {
+    SwitchToDevice(*GetDeviceByType(AUDIO_TYPE_FRONT_MIC), true,
+                   ACTIVATE_BY_USER);
+  }
+}
+
+const AudioDevice* CrasAudioHandler::GetMicForCamera(
+    media::VideoFacingMode camera_facing) {
+  switch (camera_facing) {
+    case media::MEDIA_VIDEO_FACING_USER:
+      return GetDeviceByType(AUDIO_TYPE_FRONT_MIC);
+    case media::MEDIA_VIDEO_FACING_ENVIRONMENT:
+      return GetDeviceByType(AUDIO_TYPE_REAR_MIC);
+    default:
+      NOTREACHED();
+  }
+  return nullptr;
+}
+
+const AudioDevice* CrasAudioHandler::GetDeviceByType(AudioDeviceType type) {
+  for (const auto& item : audio_devices_) {
+    const AudioDevice& device = item.second;
+    if (device.type == type)
+      return &device;
+  }
+  return nullptr;
+}
+
+bool CrasAudioHandler::HasDualInternalMic() const {
+  bool has_front_mic = false;
+  bool has_rear_mic = false;
+  for (const auto& item : audio_devices_) {
+    const AudioDevice& device = item.second;
+    if (device.type == AUDIO_TYPE_FRONT_MIC)
+      has_front_mic = true;
+    else if (device.type == AUDIO_TYPE_REAR_MIC)
+      has_rear_mic = true;
+    if (has_front_mic && has_rear_mic)
+      break;
+  }
+  return has_front_mic && has_rear_mic;
+}
+
+bool CrasAudioHandler::IsFrontOrRearMic(const AudioDevice& device) const {
+  return device.is_input && (device.type == AUDIO_TYPE_FRONT_MIC ||
+                             device.type == AUDIO_TYPE_REAR_MIC);
+}
+
+bool CrasAudioHandler::IsCameraOn() const {
+  return front_camera_on_ || rear_camera_on_;
+}
+
+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