Restrict deprecated parts of audio API usage to whitelisted apps

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"
 #include "extensions/browser/event_router.h"
 #include "extensions/common/api/audio.h"
+#include "extensions/common/extension.h"
+#include "extensions/common/features/behavior_feature.h"
+#include "extensions/common/features/feature_provider.h"
 
 namespace extensions {
 
 namespace audio = api::audio;
 
+namespace {
+
+// Checks if an extension is whitelisted to use deprecated version of audio API.
+// TODO(tbarzic): Retire this whitelist and remove the deprecated API methods,
+//     properties and events. This is currently targeted for M-60
+//     (http://crbug.com/697279).
+bool CanUseDeprecatedAudioApi(const Extension* extension) {
+  if (!extension)
+    return false;
+
+  const Feature* allow_deprecated_audio_api_feature =
+      FeatureProvider::GetBehaviorFeatures()->GetFeature(
+          behavior_feature::kAllowDeprecatedAudioApi);
+  if (!allow_deprecated_audio_api_feature)
+    return false;
+
+  return allow_deprecated_audio_api_feature->IsAvailableToExtension(extension)
+      .is_available();
+}
+
+bool CanReceiveDeprecatedAudioEvent(content::BrowserContext* context,
+                                    const Extension* extension,
+                                    Event* event,
+                                    const base::DictionaryValue* filter) {
+  return CanUseDeprecatedAudioApi(extension);
+}
+
+}  // namespace
+
 static base::LazyInstance<BrowserContextKeyedAPIFactory<AudioAPI> > g_factory =
     LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<AudioAPI>* AudioAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 AudioAPI::AudioAPI(content::BrowserContext* context)
     : browser_context_(context), service_(AudioService::CreateInstance()) {
   service_->AddObserver(this);
 }
 
 AudioAPI::~AudioAPI() {
   service_->RemoveObserver(this);
   delete service_;
   service_ = NULL;
 }
 
 AudioService* AudioAPI::GetService() const {
   return service_;
 }
 
 void AudioAPI::OnDeviceChanged() {
-  if (EventRouter::Get(browser_context_)) {
-    std::unique_ptr<Event> event(new Event(
-        events::AUDIO_ON_DEVICE_CHANGED, audio::OnDeviceChanged::kEventName,
-        std::unique_ptr<base::ListValue>(new base::ListValue())));
-    EventRouter::Get(browser_context_)->BroadcastEvent(std::move(event));
-  }
+  EventRouter* event_router = EventRouter::Get(browser_context_);
+  if (!event_router)
+    return;
+
+  std::unique_ptr<Event> event(new Event(
+      events::AUDIO_ON_DEVICE_CHANGED, audio::OnDeviceChanged::kEventName,
+      std::unique_ptr<base::ListValue>(new base::ListValue())));
+  event->will_dispatch_callback = base::Bind(&CanReceiveDeprecatedAudioEvent);
+  event_router->BroadcastEvent(std::move(event));
 }
 
 void AudioAPI::OnLevelChanged(const std::string& id, int level) {
   EventRouter* event_router = EventRouter::Get(browser_context_);
   if (!event_router)
     return;
 
   audio::LevelChangedEvent raw_event;
   raw_event.device_id = id;
   raw_event.level = level;
@@ skipping 33 matching lines @@
       audio::OnDeviceListChanged::Create(devices);
   std::unique_ptr<Event> event(new Event(events::AUDIO_ON_DEVICES_CHANGED,
                                          audio::OnDeviceListChanged::kEventName,
                                          std::move(args)));
   event_router->BroadcastEvent(std::move(event));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 ExtensionFunction::ResponseAction AudioGetInfoFunction::Run() {
+  if (!CanUseDeprecatedAudioApi(extension())) {
+    return RespondNow(
+        Error("audio.getInfo is deprecated, use audio.getDevices instead."));
+  }
+
   AudioService* service =
       AudioAPI::GetFactoryInstance()->Get(browser_context())->GetService();
   DCHECK(service);
   OutputInfo output_info;
   InputInfo input_info;
   if (!service->GetInfo(&output_info, &input_info)) {
     return RespondNow(
         Error("Error occurred when querying audio device information."));
   }
 
@@ skipping 32 matching lines @@
       AudioAPI::GetFactoryInstance()->Get(browser_context())->GetService();
   DCHECK(service);
 
   if (params->ids.as_device_id_lists) {
     if (!service->SetActiveDeviceLists(
             params->ids.as_device_id_lists->input,
             params->ids.as_device_id_lists->output)) {
       return RespondNow(Error("Failed to set active devices."));
     }
   } else if (params->ids.as_strings) {
-    // TODO(tbarzic): This way of setting active devices is deprecated - have
-    // this return error for apps that were not whitelisted for deprecated
-    // version of audio API.
+    if (!CanUseDeprecatedAudioApi(extension())) {
+      return RespondNow(
+          Error("String list |ids| is deprecated, use DeviceIdLists type."));
+    }
     service->SetActiveDevices(*params->ids.as_strings);
   }
   return RespondNow(NoArguments());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 ExtensionFunction::ResponseAction AudioSetPropertiesFunction::Run() {
   std::unique_ptr<audio::SetProperties::Params> params(
       audio::SetProperties::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   AudioService* service =
       AudioAPI::GetFactoryInstance()->Get(browser_context())->GetService();
   DCHECK(service);
 
+  if (!CanUseDeprecatedAudioApi(extension())) {
+    if (params->properties.volume)
+      return RespondNow(Error("|volume| property is deprecated, use |level|."));
+
+    if (params->properties.gain)
+      return RespondNow(Error("|gain| property is deprecated, use |level|."));
+
+    if (params->properties.is_muted) {
+      return RespondNow(
+          Error("|isMuted| property is deprecated, use |audio.setMute|."));
+    }
+  }
+
   bool level_set = !!params->properties.level;
   int level_value = level_set ? *params->properties.level : -1;
 
   int volume_value = params->properties.volume.get() ?
       *params->properties.volume : -1;
 
   int gain_value = params->properties.gain.get() ?
       *params->properties.gain : -1;
 
   // |volume_value| and |gain_value| are deprecated in favor of |level_value|;
@@ skipping 43 matching lines @@
 
   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