Remove AudioBuffer::set_duration(), instead base on frames.

media/base/audio_splicer_unittest.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 "base/memory/scoped_ptr.h"
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_splicer.h"
 #include "media/base/audio_timestamp_helper.h"
 #include "media/base/buffers.h"
@@ skipping 25 matching lines @@
 
   scoped_refptr<AudioBuffer> GetNextInputBuffer(float value, int frame_size) {
     scoped_refptr<AudioBuffer> buffer = MakeAudioBuffer<float>(
         kSampleFormat,
         kChannelLayout,
         kChannels,
         kDefaultSampleRate,
         value,
         0.0f,
         frame_size,
-        input_timestamp_helper_.GetTimestamp(),
-        input_timestamp_helper_.GetFrameDuration(frame_size));
+        input_timestamp_helper_.GetTimestamp());
     input_timestamp_helper_.AddFrames(frame_size);
     return buffer;
   }
 
   float GetValue(const scoped_refptr<AudioBuffer>& buffer) {
     return reinterpret_cast<const float*>(buffer->channel_data()[0])[0];
   }
 
   bool VerifyData(const scoped_refptr<AudioBuffer>& buffer, float value) {
     int frames = buffer->frame_count();
@@ skipping 74 matching lines @@
     // is not modified in unexpected ways.
     scoped_refptr<AudioBuffer> buffer_copy =
         input->end_of_stream()
             ? AudioBuffer::CreateEOSBuffer()
             : AudioBuffer::CopyFrom(kSampleFormat,
                                     input->channel_layout(),
                                     input->channel_count(),
                                     input->sample_rate(),
                                     input->frame_count(),
                                     &input->channel_data()[0],
-                                    input->timestamp(),
-                                    input->duration());
+                                    input->timestamp());
     return splicer_.AddInput(buffer_copy);
   }
 
   base::TimeDelta max_crossfade_duration() {
     return splicer_.max_crossfade_duration_;
   }
 
  protected:
   AudioSplicer splicer_;
   AudioTimestampHelper input_timestamp_helper_;
@@ skipping 87 matching lines @@
   // Verify that the first input buffer passed through unmodified.
   VerifyNextBuffer(input_1);
 
   // Verify the contents of the gap buffer.
   scoped_refptr<AudioBuffer> output_2 = splicer_.GetNextBuffer();
   base::TimeDelta gap_timestamp =
       input_1->timestamp() + input_1->duration();
   base::TimeDelta gap_duration = input_2->timestamp() - gap_timestamp;
   EXPECT_GT(gap_duration, base::TimeDelta());
   EXPECT_EQ(gap_timestamp, output_2->timestamp());
-  EXPECT_EQ(gap_duration, output_2->duration());
+  EXPECT_NEAR(
+      gap_duration.InMicroseconds(), output_2->duration().InMicroseconds(), 1);
   EXPECT_EQ(kGapSize, output_2->frame_count());
   EXPECT_TRUE(VerifyData(output_2, 0.0f));
 
   // Verify that the second input buffer passed through unmodified.
   VerifyNextBuffer(input_2);
   EXPECT_FALSE(splicer_.HasNextBuffer());
 }
 
 // Test that an error is signalled when the gap between input buffers is
 // too large.
@@ skipping 175 matching lines @@
   ASSERT_TRUE(splicer_.HasNextBuffer());
 
   // Add one more buffer to make sure it's passed through untouched.
   scoped_refptr<AudioBuffer> extra_post_splice_buffer =
       GetNextInputBuffer(0.5f, kBufferSize);
   EXPECT_TRUE(AddInput(extra_post_splice_buffer));
 
   VerifyPreSpliceOutput(overlapped_buffer,
                         overlapping_buffer,
                         221,
-                        base::TimeDelta::FromMicroseconds(5012));
+                        base::TimeDelta::FromMicroseconds(5011));
 
   // Due to rounding the crossfade size may vary by up to a frame.
   const int kExpectedCrossfadeSize = 220;
   EXPECT_NEAR(kExpectedCrossfadeSize, kCrossfadeSize, 1);
 
   VerifyCrossfadeOutput(overlapped_buffer,
                         NULL,
                         overlapping_buffer,
                         0,
                         kExpectedCrossfadeSize,
@@ skipping 154 matching lines @@
 // |1111111111|22222222222222|
 // +----------+--------------+
 TEST_F(AudioSplicerTest, IncorrectlyMarkedSplice) {
   const int kBufferSize =
       input_timestamp_helper_.GetFramesToTarget(max_crossfade_duration()) * 2;
 
   scoped_refptr<AudioBuffer> first_buffer =
       GetNextInputBuffer(1.0f, kBufferSize);
   // Fuzz the duration slightly so that the buffer overlaps the splice timestamp
   // by a microsecond, which is not enough to crossfade.
-  first_buffer->set_duration(first_buffer->duration() +
-                             base::TimeDelta::FromMicroseconds(1));
-  splicer_.SetSpliceTimestamp(input_timestamp_helper_.GetTimestamp());
+  const base::TimeDelta kSpliceTimestamp =
+      input_timestamp_helper_.GetTimestamp() -
+      base::TimeDelta::FromMicroseconds(1);
+  splicer_.SetSpliceTimestamp(kSpliceTimestamp);
   scoped_refptr<AudioBuffer> second_buffer =
       GetNextInputBuffer(0.0f, kBufferSize);
+  second_buffer->set_timestamp(kSpliceTimestamp);
 
   // The splicer should be internally queuing input since |first_buffer| is part
   // of the supposed splice.
   EXPECT_TRUE(AddInput(first_buffer));
   EXPECT_FALSE(splicer_.HasNextBuffer());
 
   // |second_buffer| should complete the supposed splice, so ensure output is
   // now available.
   splicer_.SetSpliceTimestamp(kNoTimestamp());
   EXPECT_TRUE(AddInput(second_buffer));
@@ skipping 38 matching lines @@
   // |second_buffer| will complete the supposed splice.
   splicer_.SetSpliceTimestamp(kNoTimestamp());
   EXPECT_TRUE(AddInput(second_buffer));
 
   VerifyNextBuffer(gap_buffer);
   VerifyNextBuffer(second_buffer);
   EXPECT_FALSE(splicer_.HasNextBuffer());
 }
 
 }  // namespace media