Remove the atomic operations from media::AudioFifo, making it truly thread-unsafe.

media/base/audio_fifo.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_fifo.h"
 
 #include "base/logging.h"
 
-using base::subtle::Atomic32;
-using base::subtle::NoBarrier_Store;
-
 namespace media {
 
 // Given current position in the FIFO, the maximum number of elements in the
 // FIFO and the size of the input; this method provides two output results:
 // |size| and |wrap_size|. These two results can then be utilized for memcopy
 // operations to and from the FIFO.
 // Under "normal" circumstances, |size| will be equal to |in_size| and
 // |wrap_size| will be zero. This case corresponding to the non-wrapping case
 // where we have not yet reached the "edge" of the FIFO. If |pos| + |in_size|
 // exceeds the total size of the FIFO, we must wrap around and start reusing
@@ skipping 23 matching lines @@
       max_frames_(frames),
       frames_pushed_(0),
       frames_consumed_(0),
       read_pos_(0),
       write_pos_(0) {}
 
 AudioFifo::~AudioFifo() {}
 
 int AudioFifo::frames() const {
   int delta = frames_pushed_ - frames_consumed_;
-  base::subtle::MemoryBarrier();
   return delta;
 }
 
 void AudioFifo::Push(const AudioBus* source) {
   DCHECK(source);
   DCHECK_EQ(source->channels(), audio_bus_->channels());
 
   // Ensure that there is space for the new data in the FIFO.
   const int source_size = source->frames();
   CHECK_LE(source_size + frames(), max_frames_);
@@ skipping 10 matching lines @@
     const float* src = source->channel(ch);
 
     // Append part of (or the complete) source to the FIFO.
     memcpy(&dest[write_pos_], &src[0], append_size * sizeof(src[0]));
     if (wrap_size > 0) {
       // Wrapping is needed: copy remaining part from the source to the FIFO.
       memcpy(&dest[0], &src[append_size], wrap_size * sizeof(src[0]));
     }
   }
 
-  // Ensure the data is *really* written before updating |frames_pushed_|.
-  base::subtle::MemoryBarrier();
-
-  Atomic32 new_frames_pushed = frames_pushed_ + source_size;
-  NoBarrier_Store(&frames_pushed_, new_frames_pushed);
-
+  frames_pushed_ += source_size;
   DCHECK_LE(frames(), max_frames());
   write_pos_ = UpdatePos(write_pos_, source_size, max_frames());
 }
 
 void AudioFifo::Consume(AudioBus* destination,
                         int start_frame,
                         int frames_to_consume) {
   DCHECK(destination);
   DCHECK_EQ(destination->channels(), audio_bus_->channels());
 
@@ skipping 19 matching lines @@
 
     // Copy a selected part of the FIFO to the destination.
     memcpy(&dest[start_frame], &src[read_pos_], consume_size * sizeof(src[0]));
     if (wrap_size > 0) {
       // Wrapping is needed: copy remaining part to the destination.
       memcpy(&dest[consume_size + start_frame], &src[0],
              wrap_size * sizeof(src[0]));
     }
   }
 
-  Atomic32 new_frames_consumed = frames_consumed_ + frames_to_consume;
-  NoBarrier_Store(&frames_consumed_, new_frames_consumed);
-
+  frames_consumed_ += frames_to_consume;
   read_pos_ = UpdatePos(read_pos_, frames_to_consume, max_frames());
 }
 
 void AudioFifo::Clear() {
   frames_pushed_ = 0;
   frames_consumed_ = 0;
   read_pos_ = 0;
   write_pos_ = 0;
 }
 
 }  // namespace media