Remove unnecessary lock in AOC; use atomic ref count instead.

media/audio/audio_output_controller.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/audio/audio_output_controller.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 16 matching lines @@
     EventHandler* handler,
     const AudioParameters& params,
     const std::string& output_device_id,
     SyncReader* sync_reader)
     : audio_manager_(audio_manager),
       params_(params),
       handler_(handler),
       output_device_id_(output_device_id),
       stream_(NULL),
       diverting_to_stream_(NULL),
+      should_duplicate_(0),
       volume_(1.0),
       state_(kEmpty),
       sync_reader_(sync_reader),
       message_loop_(audio_manager->GetTaskRunner()),
       power_monitor_(
           params.sample_rate(),
           TimeDelta::FromMilliseconds(kPowerMeasurementTimeConstantMillis)),
       on_more_io_data_called_(0),
       ignore_errors_during_stop_close_(false) {
   DCHECK(audio_manager);
@@ skipping 218 matching lines @@
   if (base::AtomicRefCountIsZero(&on_more_io_data_called_))
     base::AtomicRefCountInc(&on_more_io_data_called_);
 
   sync_reader_->Read(dest);
 
   const int frames = dest->frames();
   delay += AudioTimestampHelper::FramesToTime(frames, params_.sample_rate());
 
   sync_reader_->RequestMoreData(delay, delay_timestamp, prior_frames_skipped);
 
-  bool need_to_duplicate = false;
-  {
-    base::AutoLock lock(duplication_targets_lock_);
-    need_to_duplicate = !duplication_targets_.empty();
-  }
-  if (need_to_duplicate) {
+  if (base::AtomicRefCountIsOne(&should_duplicate_)) {
     const base::TimeTicks reference_time = delay_timestamp + delay;
     std::unique_ptr<AudioBus> copy(AudioBus::Create(params_));

[miu, 2017/05/18 03:06:29]

BTW--The call to AudioBus::Create() here could also be a source of problems
since the memory allocator might acquire a global lock. Unfortunately, aside
from creating a pool of AudioBus's ahead-of-time, I don't see another way around
this. AFAIK, this has never caused a problem, though...

     dest->CopyTo(copy.get());
     message_loop_->PostTask(
         FROM_HERE,
         base::BindOnce(
             &AudioOutputController::BroadcastDataToDuplicationTargets, this,
             std::move(copy), reference_time));
   }
 
   if (will_monitor_audio_levels())
     power_monitor_.Scan(*dest, frames);
@@ skipping 143 matching lines @@
   // back to NULL.
   OnDeviceChange();
   DCHECK(!diverting_to_stream_);
 }
 
 void AudioOutputController::DoStartDuplicating(AudioPushSink* to_stream) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   if (state_ == kClosed)
     return;
 
-  base::AutoLock lock(duplication_targets_lock_);
+  if (duplication_targets_.empty())
+    base::AtomicRefCountInc(&should_duplicate_);
+
   duplication_targets_.insert(to_stream);
 }
 
 void AudioOutputController::DoStopDuplicating(AudioPushSink* to_stream) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   to_stream->Close();
 
-  base::AutoLock lock(duplication_targets_lock_);
   duplication_targets_.erase(to_stream);
+  if (duplication_targets_.empty()) {
+    const bool is_nonzero = base::AtomicRefCountDec(&should_duplicate_);
+    DCHECK(!is_nonzero);
+  }
 }
 
 std::pair<float, bool> AudioOutputController::ReadCurrentPowerAndClip() {
   DCHECK(will_monitor_audio_levels());
   return power_monitor_.ReadCurrentPowerAndClip();
 }
 
 void AudioOutputController::WedgeCheck() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // If we should be playing and we haven't, that's a wedge.
   if (state_ == kPlaying) {
     UMA_HISTOGRAM_BOOLEAN("Media.AudioOutputControllerPlaybackStartupSuccess",
                           base::AtomicRefCountIsOne(&on_more_io_data_called_));
   }
 }
 
 }  // namespace media