Add lock to fix race in AudioRendererMixerInput.

media/base/audio_renderer_mixer_input.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 "media/base/audio_renderer_mixer_input.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 14 matching lines @@
       remove_mixer_cb_(remove_mixer_cb),
       get_hardware_params_cb_(get_hardware_params_cb),
       device_id_(device_id),
       security_origin_(security_origin),
       mixer_(nullptr),
       callback_(nullptr),
       error_cb_(base::Bind(&AudioRendererMixerInput::OnRenderError,
                            base::Unretained(this))) {}
 
 AudioRendererMixerInput::~AudioRendererMixerInput() {
+  DCHECK(!started_);
   DCHECK(!mixer_);
 }
 
 void AudioRendererMixerInput::Initialize(
     const AudioParameters& params,
     AudioRendererSink::RenderCallback* callback) {
+  DCHECK(!started_);
   DCHECK(!mixer_);
   DCHECK(callback);
 
   params_ = params;
   callback_ = callback;
 }
 
 void AudioRendererMixerInput::Start() {
   DCHECK(!started_);
   DCHECK(!mixer_);
@@ skipping 48 matching lines @@
 
 void AudioRendererMixerInput::Pause() {
   if (!playing_ || !mixer_)
     return;
 
   mixer_->RemoveMixerInput(params_, this);
   playing_ = false;
 }
 
 bool AudioRendererMixerInput::SetVolume(double volume) {
+  base::AutoLock auto_lock(volume_lock_);
   volume_ = volume;
   return true;
 }
 
 OutputDevice* AudioRendererMixerInput::GetOutputDevice() {
   return this;
 }
 
 void AudioRendererMixerInput::SwitchOutputDevice(
     const std::string& device_id,
@@ skipping 64 matching lines @@
                                        params_.GetMicrosecondsPerFrame());
 
   int frames_filled = callback_->Render(audio_bus, frames_delayed, 0);
 
   // AudioConverter expects unfilled frames to be zeroed.
   if (frames_filled < audio_bus->frames()) {
     audio_bus->ZeroFramesPartial(
         frames_filled, audio_bus->frames() - frames_filled);
   }
 
-  return frames_filled > 0 ? volume_ : 0;
+  // We're reading |volume_| from the audio device thread and must avoid racing
+  // with the main/media thread calls to SetVolume(). This is the only method
+  // called on the audio device thread. For other methods, thread safety
+  // should be enforced by the caller. See the lock in AudioRendererMixer.

[o1ka, 2016/03/16 14:31:18]

It's not quite clear to me how the lock in AudioRendererMixer is related here?
And can we add a header comment about caller responsibility for thread safety?

[chcunningham, 2016/03/17 17:59:45]

Woops! AudioRendererMixer should have been WebAudioSourceProviderImpl. I've
simplified this comment and added a more detailed comment in the header. 

+  {
+    base::AutoLock auto_lock(volume_lock_);
+    return frames_filled > 0 ? volume_ : 0;
+  }
 }
 
 void AudioRendererMixerInput::OnRenderError() {
   callback_->OnRenderError();
 }
 
 }  // namespace media