Refactored DataBuffer to use unix_hacker style methods.

media/base/seekable_buffer_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/logging.h"
 #include "base/memory/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 215 matching lines @@
   const int kSeekSize = kWriteSize / 3;
 
   scoped_refptr<DataBuffer> buffer = DataBuffer::CopyFrom(data_, kWriteSize);
 
   const uint8* data;
   int size;
   EXPECT_FALSE(buffer_.GetCurrentChunk(&data, &size));
 
   buffer_.Append(buffer.get());
   EXPECT_TRUE(buffer_.GetCurrentChunk(&data, &size));
-  EXPECT_EQ(data, buffer->GetData());
-  EXPECT_EQ(size, buffer->GetDataSize());
+  EXPECT_EQ(data, buffer->data());
+  EXPECT_EQ(size, buffer->data_size());
 
   buffer_.Seek(kSeekSize);
   EXPECT_TRUE(buffer_.GetCurrentChunk(&data, &size));
-  EXPECT_EQ(data, buffer->GetData() + kSeekSize);
-  EXPECT_EQ(size, buffer->GetDataSize() - kSeekSize);
+  EXPECT_EQ(data, buffer->data() + kSeekSize);
+  EXPECT_EQ(size, buffer->data_size() - kSeekSize);
 }
 
 TEST_F(SeekableBufferTest, SeekForward) {
   int write_position = 0;
   int read_position = 0;
   while (read_position < kDataSize) {
     for (int i = 0; i < 10 && write_position < kDataSize; ++i) {
       // Write a random amount of data.
       int write_size = GetRandomInt(kBufferSize);
       write_size = std::min(write_size, kDataSize - write_position);
@@ skipping 71 matching lines @@
     { 5, 8000000, kWriteSize, 8000005 },
   };
 
   // current_time() must initially return kNoTimestamp().
   EXPECT_EQ(kNoTimestamp().ToInternalValue(),
             buffer_.current_time().ToInternalValue());
 
   scoped_refptr<DataBuffer> buffer = DataBuffer::CopyFrom(data_, kWriteSize);
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    buffer->SetTimestamp(base::TimeDelta::FromMicroseconds(
+    buffer->set_timestamp(base::TimeDelta::FromMicroseconds(
         tests[i].first_time_useconds));
-    buffer->SetDuration(base::TimeDelta::FromMicroseconds(
+    buffer->set_duration(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 media