Plugin Power Saver: Mute throttled plugins.

ppapi/shared_impl/ppb_audio_shared.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 "ppapi/shared_impl/ppb_audio_shared.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "ppapi/nacl_irt/public/irt_ppapi.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
@@ skipping 32 matching lines @@
     callback_(sample_buffer, buffer_size_in_bytes, latency, user_data);
   } else if (callback_1_0_) {
     callback_1_0_(sample_buffer, buffer_size_in_bytes, user_data);
   } else {
     NOTREACHED();
   }
 }
 
 PPB_Audio_Shared::PPB_Audio_Shared()
     : playing_(false),
+      muted_for_power_saver_(false),
       shared_memory_size_(0),
+      nacl_thread_id_(0),
       nacl_thread_active_(false),
       user_data_(NULL),
       client_buffer_size_bytes_(0),
       bytes_per_second_(0),
       buffer_index_(0) {
 }
 
 PPB_Audio_Shared::~PPB_Audio_Shared() {
   // Shut down the socket to escape any hanging |Receive|s.
   if (socket_.get())
@@ skipping 126 matching lines @@
   g_nacl_mode = true;
 }
 
 // static
 void PPB_Audio_Shared::SetThreadFunctions(
     const struct PP_ThreadFunctions* functions) {
   DCHECK(g_nacl_mode);
   g_thread_functions = *functions;
 }
 
+void PPB_Audio_Shared::SetMutedForPowerSaver(bool muted_for_power_saver) {
+  base::AutoLock lock(mute_lock_);
+  muted_for_power_saver_ = muted_for_power_saver;
+}
+
+bool PPB_Audio_Shared::IsMutedForPowerSaver() {
+  base::AutoLock lock(mute_lock_);
+  return muted_for_power_saver_;
+}
+
 // static
 void PPB_Audio_Shared::CallRun(void* self) {
   PPB_Audio_Shared* audio = static_cast<PPB_Audio_Shared*>(self);
   audio->Run();
 }
 
 void PPB_Audio_Shared::Run() {
   int pending_data = 0;
   while (sizeof(pending_data) ==
          socket_->Receive(&pending_data, sizeof(pending_data))) {
     // |buffer_index_| must track the number of Receive() calls.  See the Send()
     // call below for why this is important.
     ++buffer_index_;
     if (pending_data < 0)
       break;
 
     {
       TRACE_EVENT0("audio", "PPB_Audio_Shared::FireRenderCallback");
       PP_TimeDelta latency =
           static_cast<double>(pending_data) / bytes_per_second_;
       callback_.Run(
           client_buffer_.get(), client_buffer_size_bytes_, latency, user_data_);
     }
 
+    if (IsMutedForPowerSaver()) {

[tommycli, 2015/01/28 20:41:24]

This doesn't actually work!

As far as I can tell, there are actually two instances of PPB_Audio_Shared, and
the muted_for_power_saver_ variable is not shared between them.

Is the other one the "proxy" object that lives in a whole different process?

+      memset(client_buffer_.get(), 0, client_buffer_size_bytes_);
+    }
+
     // Deinterleave the audio data into the shared memory as floats.
     audio_bus_->FromInterleaved(client_buffer_.get(),
                                 audio_bus_->frames(),
                                 kBitsPerAudioOutputSample / 8);
 
     // Let the other end know which buffer we just filled.  The buffer index is
     // used to ensure the other end is getting the buffer it expects.  For more
     // details on how this works see AudioSyncReader::WaitUntilDataIsReady().
     size_t bytes_sent = socket_->Send(&buffer_index_, sizeof(buffer_index_));
     if (bytes_sent != sizeof(buffer_index_))
       break;
   }
 }
 
 }  // namespace ppapi