Full Implementation of Audio for the Chrome Os Device Emulator

chrome/browser/ui/webui/chromeos/emulator/device_emulator_message_handler.cc

 // Copyright 2015 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/ui/webui/chromeos/emulator/device_emulator_message_handler.h"
 
 #include "ash/shell.h"
+#include "ash/system/audio/audio_observer.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "base/bind.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_bluetooth_adapter_client.h"
 #include "chromeos/dbus/fake_bluetooth_device_client.h"
+#include "chromeos/dbus/fake_cras_audio_client.h"
 #include "chromeos/dbus/fake_power_manager_client.h"
 #include "content/public/browser/web_ui.h"
 #include "device/bluetooth/bluetooth_device_chromeos.h"
 
 namespace {
 
 // Define the name of the callback functions that will be used by JavaScript.
 const char kBluetoothDiscoverFunction[] = "requestBluetoothDiscover";
 const char kBluetoothPairFunction[] = "requestBluetoothPair";
 const char kRequestBluetoothInfo[] = "requestBluetoothInfo";
 const char kRequestPowerInfo[] = "requestPowerInfo";
+const char kRequestAudioNodes[] = "requestAudioNodes";
+
+// Define update function that will update the state of the audio ui.
+const char kInsertAudioNode[] = "insertAudioNode";
+const char kRemoveAudioNode[] = "removeAudioNode";
 
 // Define update functions that will update the power properties to the
 // variables defined in the web UI.
 const char kRemoveBluetoothDevice[] = "removeBluetoothDevice";
 const char kUpdateBatteryPercent[] = "updateBatteryPercent";
 const char kUpdateBatteryState[] = "updateBatteryState";
 const char kUpdateExternalPower[] = "updateExternalPower";
 const char kUpdateTimeToEmpty[] = "updateTimeToEmpty";
 const char kUpdateTimeToFull[] = "updateTimeToFull";
 
 // Define callback functions that will update the JavaScript variable
 // and the web UI.
+const char kUpdateAudioNodes[] =
+    "device_emulator.audioSettings.updateAudioNodes";
 const char kAddBluetoothDeviceJSCallback[] =
     "device_emulator.bluetoothSettings.addBluetoothDevice";
 const char kDevicePairedFromTrayJSCallback[] =
     "device_emulator.bluetoothSettings.devicePairedFromTray";
 const char kDeviceRemovedFromMainAdapterJSCallback[] =
     "device_emulator.bluetoothSettings.deviceRemovedFromMainAdapter";
 const char kPairFailedJSCallback[] =
     "device_emulator.bluetoothSettings.pairFailed";
 const char kUpdateBluetoothInfoJSCallback[] =
     "device_emulator.bluetoothSettings.updateBluetoothInfo";
@@ skipping 29 matching lines @@
   void DeviceRemoved(const dbus::ObjectPath& object_path) override;
 
  private:
   DeviceEmulatorMessageHandler* owner_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothObserver);
 };
 
 void DeviceEmulatorMessageHandler::BluetoothObserver::DeviceAdded(
     const dbus::ObjectPath& object_path) {
-  scoped_ptr<base::DictionaryValue> device = owner_->GetDeviceInfo(
-      object_path);
+  scoped_ptr<base::DictionaryValue> device = owner_->GetDeviceInfo(object_path);
 
   // Request to add the device to the view's list of devices.
   owner_->web_ui()->CallJavascriptFunction(kAddBluetoothDeviceJSCallback,
-      *device);
+                                           *device);
 }
 
 void DeviceEmulatorMessageHandler::BluetoothObserver::DevicePropertyChanged(
   const dbus::ObjectPath& object_path,
   const std::string& property_name) {
   if (property_name == kPairedPropertyName) {
     owner_->web_ui()->CallJavascriptFunction(kDevicePairedFromTrayJSCallback,
         base::StringValue(object_path.value()));
   }
 }
 
 void DeviceEmulatorMessageHandler::BluetoothObserver::DeviceRemoved(
     const dbus::ObjectPath& object_path) {
   owner_->web_ui()->CallJavascriptFunction(
+      kRemoveBluetoothDeviceJSCallback, base::StringValue(object_path.value()));
+}
+
+class DeviceEmulatorMessageHandler::CrasAudioObserver
+    : public CrasAudioClient::Observer {
+ public:
+  explicit CrasAudioObserver(DeviceEmulatorMessageHandler* owner)
+      : owner_(owner) {
+    owner_->fake_cras_audio_client_->AddObserver(this);
+  }
+
+  ~CrasAudioObserver() override {
+    owner_->fake_cras_audio_client_->RemoveObserver(this);
+  }
+
+  // chromeos::CrasAudioClient::Observer.
+  void NodesChanged() override;
+
+ private:
+  DeviceEmulatorMessageHandler* owner_;
+
+  DISALLOW_COPY_AND_ASSIGN(CrasAudioObserver);
+};
+
+void DeviceEmulatorMessageHandler::CrasAudioObserver::NodesChanged() {
+  owner_->HandleRequestAudioNodes(nullptr);
     kDeviceRemovedFromMainAdapterJSCallback,
     base::StringValue(object_path.value()));
 }
 
 class DeviceEmulatorMessageHandler::PowerObserver
     : public PowerManagerClient::Observer {
  public:
   explicit PowerObserver(DeviceEmulatorMessageHandler* owner)
       : owner_(owner) {
     owner_->fake_power_manager_client_->AddObserver(this);
   }
 
   ~PowerObserver() override {
     owner_->fake_power_manager_client_->RemoveObserver(this);
   }
 
-  void PowerChanged(
-      const power_manager::PowerSupplyProperties& proto) override;
+  void PowerChanged(const power_manager::PowerSupplyProperties& proto) override;
 
  private:
-   DeviceEmulatorMessageHandler* owner_;
+  DeviceEmulatorMessageHandler* owner_;
 
-   DISALLOW_COPY_AND_ASSIGN(PowerObserver);
+  DISALLOW_COPY_AND_ASSIGN(PowerObserver);
 };
 
 void DeviceEmulatorMessageHandler::PowerObserver::PowerChanged(
     const power_manager::PowerSupplyProperties& proto) {
   base::DictionaryValue power_properties;
 
   power_properties.SetInteger("battery_percent", proto.battery_percent());
   power_properties.SetInteger("battery_state", proto.battery_state());
   power_properties.SetInteger("external_power", proto.external_power());
   power_properties.SetInteger("battery_time_to_empty_sec",
                               proto.battery_time_to_empty_sec());
   power_properties.SetInteger("battery_time_to_full_sec",
                               proto.battery_time_to_full_sec());
 
   owner_->web_ui()->CallJavascriptFunction(kUpdatePowerPropertiesJSCallback,
-                                   power_properties);
+                                           power_properties);
 }
 
 DeviceEmulatorMessageHandler::DeviceEmulatorMessageHandler()
     : fake_bluetooth_device_client_(
           static_cast<chromeos::FakeBluetoothDeviceClient*>(
               chromeos::DBusThreadManager::Get()
                   ->GetBluetoothDeviceClient())),
+      fake_cras_audio_client_(static_cast<chromeos::FakeCrasAudioClient*>(
+          chromeos::DBusThreadManager::Get()
+              ->GetCrasAudioClient())),
       fake_power_manager_client_(static_cast<chromeos::FakePowerManagerClient*>(
           chromeos::DBusThreadManager::Get()
               ->GetPowerManagerClient())) {}
 
 DeviceEmulatorMessageHandler::~DeviceEmulatorMessageHandler() {
 }
 
 void DeviceEmulatorMessageHandler::Init() {
   bluetooth_observer_.reset(new BluetoothObserver(this));
+  cras_audio_observer_.reset(new CrasAudioObserver(this));
   power_observer_.reset(new PowerObserver(this));
 }
 
 void DeviceEmulatorMessageHandler::RequestPowerInfo(
     const base::ListValue* args) {
   fake_power_manager_client_->RequestStatusUpdate();
 }
 
 void DeviceEmulatorMessageHandler::HandleRemoveBluetoothDevice(
     const base::ListValue* args) {
@@ skipping 61 matching lines @@
   // Try to pair the device with the main adapter. The device is identified
   // by its device ID, which, in this case is the same as its address.
   ash::Shell::GetInstance()->system_tray_delegate()->ConnectToBluetoothDevice(
       props->address.value());
   if (!props->paired.value()) {
     web_ui()->CallJavascriptFunction(kPairFailedJSCallback,
         base::StringValue(path));
   }
 }
 
+void DeviceEmulatorMessageHandler::HandleRequestAudioNodes(
+    const base::ListValue* args) {
+  // Get every active audio node and create a dictionary to
+  // send it to JavaScript.
+  base::ListValue audio_nodes;
+  for (const AudioNode& node : fake_cras_audio_client_->node_list()) {
+    scoped_ptr<base::DictionaryValue> audio_node(new base::DictionaryValue());
+
+    audio_node->SetBoolean("isInput", node.is_input);
+    audio_node->SetString("id", base::Uint64ToString(node.id));
+    audio_node->SetString("deviceName", node.device_name);
+    audio_node->SetString("type", node.type);
+    audio_node->SetString("name", node.name);
+    audio_node->SetBoolean("active", node.active);
+
+    audio_nodes.Append(audio_node.Pass());
+  }
+  web_ui()->CallJavascriptFunction(kUpdateAudioNodes, audio_nodes);
+}
+
+void DeviceEmulatorMessageHandler::HandleInsertAudioNode(
+    const base::ListValue* args) {
+  AudioNode audio_node;
+  const base::DictionaryValue* device_dict = nullptr;
+
+  CHECK(args->GetDictionary(0, &device_dict));
+  CHECK(args->GetString(1, &audio_node.type));
+
+  CHECK(device_dict->GetBoolean("isInput", &audio_node.is_input));
+  CHECK(device_dict->GetString("deviceName", &audio_node.device_name));
+  CHECK(device_dict->GetString("name", &audio_node.name));
+  CHECK(device_dict->GetBoolean("active", &audio_node.active));
+
+  std::string tmp_id;
+  CHECK(device_dict->GetString("id", &tmp_id));
+  CHECK(base::StringToUint64(tmp_id, &audio_node.id));
+
+  fake_cras_audio_client_->InsertAudioNodeToList(audio_node);
+}
+
+void DeviceEmulatorMessageHandler::HandleRemoveAudioNode(
+    const base::ListValue* args) {
+  std::string tmp_id;
+  uint64 id;
+  CHECK(args->GetString(0, &tmp_id));
+  CHECK(base::StringToUint64(tmp_id, &id));
+
+  fake_cras_audio_client_->RemoveAudioNodeFromList(id);
+}
+
 void DeviceEmulatorMessageHandler::UpdateBatteryPercent(
     const base::ListValue* args) {
   int new_percent;
   if (args->GetInteger(0, &new_percent)) {
     power_manager::PowerSupplyProperties props =
         fake_power_manager_client_->props();
     props.set_battery_percent(new_percent);
     fake_power_manager_client_->UpdatePowerProperties(props);
   }
 }
@@ skipping 77 matching lines @@
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       kBluetoothPairFunction,
       base::Bind(&DeviceEmulatorMessageHandler::HandleRequestBluetoothPair,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       kRequestBluetoothInfo,
       base::Bind(&DeviceEmulatorMessageHandler::HandleRequestBluetoothInfo,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
+      kRequestAudioNodes,
+      base::Bind(&DeviceEmulatorMessageHandler::HandleRequestAudioNodes,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      kInsertAudioNode,
+      base::Bind(&DeviceEmulatorMessageHandler::HandleInsertAudioNode,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      kRemoveAudioNode,
+      base::Bind(&DeviceEmulatorMessageHandler::HandleRemoveAudioNode,
       kRemoveBluetoothDevice,
       base::Bind(&DeviceEmulatorMessageHandler::HandleRemoveBluetoothDevice,
                  base::Unretained(this)));
 }
 
 std::string DeviceEmulatorMessageHandler::CreateBluetoothDeviceFromListValue(
     const base::ListValue* args) {
   const base::DictionaryValue* device_dict = nullptr;
   FakeBluetoothDeviceClient::IncomingDeviceProperties props;
 
@@ skipping 48 matching lines @@
   for (const std::string& uuid : props->uuids.value()) {
     uuids->AppendString(uuid);
   }
 
   device->Set("uuids", uuids.Pass());
 
   return device.Pass();
 }
 
 }  // namespace chromeos