Removed PushSource::Packet. SeekableBuffer.current_time() fixed to return

media/base/seekable_buffer_unittest.cc

 // Copyright (c) 2010 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/logging.h"
 #include "base/scoped_ptr.h"
 #include "base/time.h"
 #include "media/base/data_buffer.h"
 #include "media/base/seekable_buffer.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 273 matching lines @@
   EXPECT_EQ(0u, buffer_.Read(write_buffer_, 1));
   EXPECT_TRUE(buffer_.Seek(0));
   EXPECT_FALSE(buffer_.Seek(-1));
   EXPECT_FALSE(buffer_.Seek(1));
   EXPECT_EQ(0u, buffer_.forward_bytes());
   EXPECT_EQ(0u, buffer_.backward_bytes());
 }
 
 
 TEST_F(SeekableBufferTest, GetTime) {
+  const base::TimeDelta kInvalidTimestamp =
+      media::StreamSample::kInvalidTimestamp;
+
   const struct {
     int64 first_time_useconds;
     int64 duration_useconds;
     size_t consume_bytes;
     int64 expected_time;
   } tests[] = {
     // Timestamps of 0 are treated as garbage.
-    { 0, 1000000, 0, 0 },
-    { 0, 4000000, 0, 0 },
-    { 0, 8000000, 0, 0 },
-    { 0, 1000000, 4, 0 },
-    { 0, 4000000, 4, 0 },
-    { 0, 8000000, 4, 0 },
-    { 0, 1000000, kWriteSize, 0 },
-    { 0, 4000000, kWriteSize, 0 },
-    { 0, 8000000, kWriteSize, 0 },
+    { 0, 1000000, 0, kInvalidTimestamp.ToInternalValue() },
+    { 0, 4000000, 0, kInvalidTimestamp.ToInternalValue() },
+    { 0, 8000000, 0, kInvalidTimestamp.ToInternalValue() },
+    { 0, 1000000, 4, kInvalidTimestamp.ToInternalValue() },
+    { 0, 4000000, 4, kInvalidTimestamp.ToInternalValue() },
+    { 0, 8000000, 4, kInvalidTimestamp.ToInternalValue() },
+    { 0, 1000000, kWriteSize, kInvalidTimestamp.ToInternalValue() },
+    { 0, 4000000, kWriteSize, kInvalidTimestamp.ToInternalValue() },
+    { 0, 8000000, kWriteSize, kInvalidTimestamp.ToInternalValue() },
     { 5, 1000000, 0, 5 },
     { 5, 4000000, 0, 5 },
     { 5, 8000000, 0, 5 },
     { 5, 1000000, kWriteSize / 2, 500005 },
     { 5, 4000000, kWriteSize / 2, 2000005 },
     { 5, 8000000, kWriteSize / 2, 4000005 },
     { 5, 1000000, kWriteSize, 1000005 },
     { 5, 4000000, kWriteSize, 4000005 },
     { 5, 8000000, kWriteSize, 8000005 },
   };
 
+  // current_time() must initially return kInvalidTimestamp.
+  EXPECT_EQ(kInvalidTimestamp.ToInternalValue(),
+            buffer_.current_time().ToInternalValue());
+
   scoped_refptr<media::DataBuffer> buffer = new media::DataBuffer(kWriteSize);
   memcpy(buffer->GetWritableData(), data_, kWriteSize);
   buffer->SetDataSize(kWriteSize);
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     buffer->SetTimestamp(base::TimeDelta::FromMicroseconds(
         tests[i].first_time_useconds));
     buffer->SetDuration(base::TimeDelta::FromMicroseconds(
         tests[i].duration_useconds));
     buffer_.Append(buffer.get());
     EXPECT_TRUE(buffer_.Seek(tests[i].consume_bytes));
 
     int64 actual = buffer_.current_time().ToInternalValue();
 
     EXPECT_EQ(tests[i].expected_time, actual) << "With test = { start:"
         << tests[i].first_time_useconds << ", duration:"
         << tests[i].duration_useconds << ", consumed:"
         << tests[i].consume_bytes << "}\n";
 
     buffer_.Clear();
   }
 }
 
 }  // namespace