chrome.audio API: treat mute as system wide property

extensions/browser/api/audio/audio_api.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 "extensions/browser/api/audio/audio_api.h"
 
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/values.h"
@@ skipping 41 matching lines @@
     std::unique_ptr<base::ListValue> args =
         audio::OnLevelChanged::Create(id, level);
     std::unique_ptr<Event> event(new Event(events::AUDIO_ON_LEVEL_CHANGED,
                                            audio::OnLevelChanged::kEventName,
                                            std::move(args)));
     EventRouter::Get(browser_context_)->BroadcastEvent(std::move(event));
   }
 }
 
 void AudioAPI::OnMuteChanged(bool is_input, bool is_muted) {
-  if (EventRouter::Get(browser_context_)) {
-    std::unique_ptr<base::ListValue> args =
-        audio::OnMuteChanged::Create(is_input, is_muted);
-    std::unique_ptr<Event> event(new Event(events::AUDIO_ON_MUTE_CHANGED,
-                                           audio::OnMuteChanged::kEventName,
-                                           std::move(args)));
-    EventRouter::Get(browser_context_)->BroadcastEvent(std::move(event));
-  }
+  EventRouter* event_router = EventRouter::Get(browser_context_);
+  if (!event_router)
+    return;
+
+  // Dispatch onMuteChanged event.
+  audio::MuteChangedEvent raw_event;
+  raw_event.stream_type =
+      is_input ? audio::STREAM_TYPE_INPUT : audio::STREAM_TYPE_OUTPUT;
+  raw_event.value = is_muted;
+  std::unique_ptr<base::ListValue> event_args =
+      audio::OnMuteChanged::Create(raw_event);
+  std::unique_ptr<Event> event(new Event(events::AUDIO_ON_MUTE_CHANGED,
+                                         audio::OnMuteChanged::kEventName,
+                                         std::move(event_args)));
+  event_router->BroadcastEvent(std::move(event));
 }
 
 void AudioAPI::OnDevicesChanged(const DeviceInfoList& devices) {
   if (EventRouter::Get(browser_context_)) {
     std::unique_ptr<base::ListValue> args =
         audio::OnDevicesChanged::Create(devices);
     std::unique_ptr<Event> event(new Event(events::AUDIO_ON_DEVICES_CHANGED,
                                            audio::OnDevicesChanged::kEventName,
                                            std::move(args)));
     EventRouter::Get(browser_context_)->BroadcastEvent(std::move(event));
@@ skipping 42 matching lines @@
   AudioService* service =
       AudioAPI::GetFactoryInstance()->Get(browser_context())->GetService();
   DCHECK(service);
 
   int volume_value = params->properties.volume.get() ?
       *params->properties.volume : -1;
 
   int gain_value = params->properties.gain.get() ?
       *params->properties.gain : -1;
 
-  if (!service->SetDeviceProperties(params->id, params->properties.is_muted,
-                                    volume_value, gain_value)) {
-    return RespondNow(Error("Could not set properties"));
+  if (!service->SetDeviceSoundLevel(params->id, volume_value, gain_value))
+    return RespondNow(Error("Could not set volume/gain properties"));
+
+  if (params->properties.is_muted.get() &&
+      !service->SetMuteForDevice(params->id, *params->properties.is_muted)) {
+    return RespondNow(Error("Could not set mute property."));
+  }
+
+  return RespondNow(NoArguments());
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ExtensionFunction::ResponseAction AudioSetMuteFunction::Run() {
+  std::unique_ptr<audio::SetMute::Params> params(
+      audio::SetMute::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+
+  AudioService* service =
+      AudioAPI::GetFactoryInstance()->Get(browser_context())->GetService();
+  DCHECK(service);
+
+  if (!service->SetMute(params->stream_type == audio::STREAM_TYPE_INPUT,
+                        params->value)) {
+    return RespondNow(Error("Could not set mute state."));
   }
   return RespondNow(NoArguments());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+ExtensionFunction::ResponseAction AudioGetMuteFunction::Run() {
+  std::unique_ptr<audio::GetMute::Params> params(
+      audio::GetMute::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+
+  AudioService* service =
+      AudioAPI::GetFactoryInstance()->Get(browser_context())->GetService();
+  DCHECK(service);
+
+  bool value = false;
+  if (!service->GetMute(params->stream_type == audio::STREAM_TYPE_INPUT,
+                        &value)) {
+    return RespondNow(Error("Could not get mute state."));
+  }
+  return RespondNow(ArgumentList(audio::GetMute::Results::Create(value)));
+}
+
 }  // namespace extensions