Remove obsolete atomic debugging checks.

media/base/sinc_resampler.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.
 //
 // Initial input buffer layout, dividing into regions r0_ to r4_ (note: r0_, r3_
 // and r4_ will move after the first load):
 //
 // |----------------|-----------------------------------------|----------------|
 //
 //                                        request_frames_
@@ skipping 135 matching lines @@
       // Create input buffers with a 16-byte alignment for SSE optimizations.
       kernel_storage_(static_cast<float*>(
           base::AlignedAlloc(sizeof(float) * kKernelStorageSize, 16))),
       kernel_pre_sinc_storage_(static_cast<float*>(
           base::AlignedAlloc(sizeof(float) * kKernelStorageSize, 16))),
       kernel_window_storage_(static_cast<float*>(
           base::AlignedAlloc(sizeof(float) * kKernelStorageSize, 16))),
       input_buffer_(static_cast<float*>(
           base::AlignedAlloc(sizeof(float) * input_buffer_size_, 16))),
       r1_(input_buffer_.get()),
-      r2_(input_buffer_.get() + kKernelSize / 2),
-      not_currently_resampling_(1) {
+      r2_(input_buffer_.get() + kKernelSize / 2) {
   CHECK_GT(request_frames_, 0);
   Flush();
   CHECK_GT(block_size_, kKernelSize)
       << "block_size must be greater than kKernelSize!";
 
   memset(kernel_storage_.get(), 0,
          sizeof(*kernel_storage_.get()) * kKernelStorageSize);
   memset(kernel_pre_sinc_storage_.get(), 0,
          sizeof(*kernel_pre_sinc_storage_.get()) * kKernelStorageSize);
   memset(kernel_window_storage_.get(), 0,
          sizeof(*kernel_window_storage_.get()) * kKernelStorageSize);
 
   InitializeKernel();
 }
 
-SincResampler::~SincResampler() {
-  // TODO(dalecurtis): Remove debugging for http://crbug.com/295278
-  CHECK(!base::AtomicRefCountDec(&not_currently_resampling_));
-}
+SincResampler::~SincResampler() {}
 
 void SincResampler::UpdateRegions(bool second_load) {
   // Setup various region pointers in the buffer (see diagram above).  If we're
   // on the second load we need to slide r0_ to the right by kKernelSize / 2.
   r0_ = input_buffer_.get() + (second_load ? kKernelSize : kKernelSize / 2);
   r3_ = r0_ + request_frames_ - kKernelSize;
   r4_ = r0_ + request_frames_ - kKernelSize / 2;
   block_size_ = r4_ - r2_;
 
   // r1_ at the beginning of the buffer.
@@ skipping 62 matching lines @@
         kernel_storage_[idx] = sinc_scale_factor * window;
       } else {
         kernel_storage_[idx] =
             window * sin(sinc_scale_factor * pre_sinc) / pre_sinc;
       }
     }
   }
 }
 
 void SincResampler::Resample(int frames, float* destination) {
-  CHECK(!base::AtomicRefCountDec(&not_currently_resampling_));
-
   int remaining_frames = frames;
 
   // Step (1) -- Prime the input buffer at the start of the input stream.
   if (!buffer_primed_ && remaining_frames) {
     read_cb_.Run(request_frames_, r0_);
     buffer_primed_ = true;
   }
 
   // Step (2) -- Resample!  const what we can outside of the loop for speed.  It
   // actually has an impact on ARM performance.  See inner loop comment below.
@@ skipping 28 matching lines @@
       // Figure out how much to weight each kernel's "convolution".
       const double kernel_interpolation_factor =
           virtual_offset_idx - offset_idx;
       *destination++ = CONVOLVE_FUNC(
           input_ptr, k1, k2, kernel_interpolation_factor);
 
       // Advance the virtual index.
       virtual_source_idx_ += current_io_ratio;
       source_idx = virtual_source_idx_;
 
-      if (!--remaining_frames) {
-        base::AtomicRefCountInc(&not_currently_resampling_);
+      if (!--remaining_frames)
         return;
-      }
     }
 
     // Wrap back around to the start.
     DCHECK_GE(virtual_source_idx_, block_size_);
     virtual_source_idx_ -= block_size_;
 
     // Step (3) -- Copy r3_, r4_ to r1_, r2_.
     // This wraps the last input frames back to the start of the buffer.
     memcpy(r1_, r3_, sizeof(*input_buffer_.get()) * kKernelSize);
 
     // Step (4) -- Reinitialize regions if necessary.
     if (r0_ == r2_)
       UpdateRegions(true);
 
     // Step (5) -- Refresh the buffer with more input.
     read_cb_.Run(request_frames_, r0_);
   }
-
-  base::AtomicRefCountInc(&not_currently_resampling_);
 }
 
 #undef CONVOLVE_FUNC
 
 int SincResampler::ChunkSize() const {
   return block_size_ / io_sample_rate_ratio_;
 }
 
 void SincResampler::Flush() {
-  CHECK(base::AtomicRefCountIsOne(&not_currently_resampling_));
   virtual_source_idx_ = 0;
   buffer_primed_ = false;
   memset(input_buffer_.get(), 0,
          sizeof(*input_buffer_.get()) * input_buffer_size_);
   UpdateRegions(false);
 }
 
 float SincResampler::Convolve_C(const float* input_ptr, const float* k1,
                                 const float* k2,
                                 double kernel_interpolation_factor) {
@@ skipping 36 matching lines @@
       vmulq_f32(m_sums1, vmovq_n_f32(1.0 - kernel_interpolation_factor)),
       m_sums2, vmovq_n_f32(kernel_interpolation_factor));
 
   // Sum components together.
   float32x2_t m_half = vadd_f32(vget_high_f32(m_sums1), vget_low_f32(m_sums1));
   return vget_lane_f32(vpadd_f32(m_half, m_half), 0);
 }
 #endif
 
 }  // namespace media