Plugin Power Saver: Mute throttled plugins.

content/renderer/pepper/ppb_audio_impl.cc

 // Copyright (c) 2012 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 "content/renderer/pepper/ppb_audio_impl.h"
 
 #include "base/logging.h"
 #include "content/renderer/pepper/pepper_platform_audio_output.h"
 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
 #include "content/renderer/pepper/plugin_instance_throttler_impl.h"
@@ skipping 12 matching lines @@
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_Audio_API;
 using ppapi::thunk::PPB_AudioConfig_API;
 using ppapi::TrackedCallback;
 
 namespace content {
 
 // PPB_Audio_Impl --------------------------------------------------------------
 
 PPB_Audio_Impl::PPB_Audio_Impl(PP_Instance instance)
-    : Resource(ppapi::OBJECT_IS_IMPL, instance), audio_(NULL) {}
+    : Resource(ppapi::OBJECT_IS_IMPL, instance),
+      audio_(NULL),
+      playback_throttled_(false) {
+  PepperPluginInstanceImpl* plugin_instance =
+      static_cast<PepperPluginInstanceImpl*>(
+          PepperPluginInstance::Get(pp_instance()));
+  if (plugin_instance && plugin_instance->throttler()) {
+    plugin_instance->throttler()->AddObserver(this);
+  }
+}
 
 PPB_Audio_Impl::~PPB_Audio_Impl() {
+  PepperPluginInstanceImpl* instance = static_cast<PepperPluginInstanceImpl*>(
+      PepperPluginInstance::Get(pp_instance()));
+  if (instance && instance->throttler()) {
+    instance->throttler()->RemoveObserver(this);
+  }
+
   // Calling ShutDown() makes sure StreamCreated cannot be called anymore and
   // releases the audio data associated with the pointer. Note however, that
   // until ShutDown returns, StreamCreated may still be called. This will be
   // OK since we'll just immediately clean up the data it stored later in this
   // destructor.
   if (audio_) {
     audio_->ShutDown();
     audio_ = NULL;
   }
 }
 
 PPB_Audio_API* PPB_Audio_Impl::AsPPB_Audio_API() { return this; }
 
 PP_Resource PPB_Audio_Impl::GetCurrentConfig() {
   // AddRef on behalf of caller, while keeping a ref for ourselves.
   PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(config_);
   return config_;
 }
 
 PP_Bool PPB_Audio_Impl::StartPlayback() {
   if (!audio_)
     return PP_FALSE;
   if (playing())
     return PP_TRUE;
+
+  // If plugin is in power saver mode, defer audio IPC communication.
+  PepperPluginInstanceImpl* instance = static_cast<PepperPluginInstanceImpl*>(
+      PepperPluginInstance::Get(pp_instance()));
+  if (instance && instance->throttler() &&
+      instance->throttler()->power_saver_enabled()) {
+    instance->throttler()->NotifyAudioThrottled();
+    playback_throttled_ = true;
+    return PP_TRUE;
+  }
+
   SetStartPlaybackState();
   return PP_FromBool(audio_->StartPlayback());
 }
 
 PP_Bool PPB_Audio_Impl::StopPlayback() {
   if (!audio_)
     return PP_FALSE;
+
+  if (playback_throttled_) {
+    // If a start playback request is still deferred, we must fulfill it first
+    // to shut down the audio thread correctly.
+    StartDeferredPlayback();
+  }
+
   if (!playing())
     return PP_TRUE;
   if (!audio_->StopPlayback())
     return PP_FALSE;
   SetStopPlaybackState();
+
   return PP_TRUE;
 }
 
 int32_t PPB_Audio_Impl::Open(PP_Resource config,
                              scoped_refptr<TrackedCallback> create_callback) {
   // Validate the config and keep a reference to it.
   EnterResourceNoLock<PPB_AudioConfig_API> enter(config, true);
   if (enter.failed())
     return PP_ERROR_FAILED;
   config_ = config;
 
   PepperPluginInstanceImpl* instance = static_cast<PepperPluginInstanceImpl*>(
       PepperPluginInstance::Get(pp_instance()));
   if (!instance)
     return PP_ERROR_FAILED;
 
-  // Prevent any throttling since we are playing audio. This stopgap prevents
-  // video from appearing 'frozen' while the audio track plays.
-  if (instance->throttler() && instance->throttler()->power_saver_enabled()) {
-    instance->throttler()->MarkPluginEssential(
-        PluginInstanceThrottler::UNTHROTTLE_METHOD_BY_AUDIO);
-  }
-
   // When the stream is created, we'll get called back on StreamCreated().
   DCHECK(!audio_);
   audio_ = PepperPlatformAudioOutput::Create(
       static_cast<int>(enter.object()->GetSampleRate()),
       static_cast<int>(enter.object()->GetSampleFrameCount()),
       instance->GetRenderView()->GetRoutingID(),
       instance->render_frame()->GetRoutingID(),
       this);
   if (!audio_)
     return PP_ERROR_FAILED;
@@ skipping 20 matching lines @@
     base::SyncSocket::Handle socket_handle) {
   EnterResourceNoLock<PPB_AudioConfig_API> enter(config_, true);
   SetStreamInfo(pp_instance(),
                 shared_memory_handle,
                 shared_memory_size,
                 socket_handle,
                 enter.object()->GetSampleRate(),
                 enter.object()->GetSampleFrameCount());
 }
 
+void PPB_Audio_Impl::OnThrottleStateChange() {
+  PepperPluginInstanceImpl* instance = static_cast<PepperPluginInstanceImpl*>(
+      PepperPluginInstance::Get(pp_instance()));
+  if (playback_throttled_ && instance && instance->throttler() &&
+      !instance->throttler()->power_saver_enabled()) {
+    // If we have become unthrottled, and we have a pending playback, start it.
+    StartDeferredPlayback();
+  }
+}
+
+void PPB_Audio_Impl::StartDeferredPlayback() {
+  DCHECK(playback_throttled_);
+  playback_throttled_ = false;
+
+  SetStartPlaybackState();
+  audio_->StartPlayback();
+}
+
 }  // namespace content