TBR: dmichael

Refactored DecoderBuffer to use unix_hacker_style naming.

DecoderBuffer went from having pure virtual methods to having
concrete implementations.  However, the style of the method name
remained in UpperCamelCase.  This patch renames the methods to fit
with the unix_hacker_style that is used for concrete implementations.

BUG=251986

Review URL: https://chromiumcodereview.appspot.com/17408005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@212375 0039d316-1c4b-4281-b951-d872f2087c98

44 files changed, 365 insertions, 381 deletions

diff --git a/media/audio/win/audio_low_latency_output_win_unittest.cc b/media/audio/win/audio_low_latency_output_win_unittest.cc
index acbe653..8c3e366 100644
--- a/media/audio/win/audio_low_latency_output_win_unittest.cc
+++ b/media/audio/win/audio_low_latency_output_win_unittest.cc
@@ -134,7 +134,7 @@ class ReadFromFileAudioSource : public AudioOutputStream::AudioSourceCallback {
     int frames = max_size / (audio_bus->channels() * kBitsPerSample / 8);
     if (max_size) {
       audio_bus->FromInterleaved(
-          file_->GetData() + pos_, frames, kBitsPerSample / 8);
+          file_->data() + pos_, frames, kBitsPerSample / 8);
       pos_ += max_size;
     }
     return frames;
@@ -149,7 +149,7 @@ class ReadFromFileAudioSource : public AudioOutputStream::AudioSourceCallback {
 
   virtual void OnError(AudioOutputStream* stream) {}
 
-  int file_size() { return file_->GetDataSize(); }
+  int file_size() { return file_->data_size(); }
 
  private:
   scoped_refptr<DecoderBuffer> file_;
diff --git a/media/base/android/media_source_player_unittest.cc b/media/base/android/media_source_player_unittest.cc
index 65318bc..3146640 100644
--- a/media/base/android/media_source_player_unittest.cc
+++ b/media/base/android/media_source_player_unittest.cc
@@ -109,8 +109,8 @@ class MediaSourcePlayerTest : public testing::Test {
     params.duration_ms = kDefaultDurationInMs;
     scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile("vorbis-extradata");
     params.audio_extra_data = std::vector<uint8>(
-        buffer->GetData(),
-        buffer->GetData() + buffer->GetDataSize());
+        buffer->data(),
+        buffer->data() + buffer->data_size());
     Start(params);
   }
 
@@ -137,7 +137,7 @@ class MediaSourcePlayerTest : public testing::Test {
     ack_params.access_units[0].status = DemuxerStream::kOk;
     scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile("vorbis-packet-0");
     ack_params.access_units[0].data = std::vector<uint8>(
-        buffer->GetData(), buffer->GetData() + buffer->GetDataSize());
+        buffer->data(), buffer->data() + buffer->data_size());
     // Vorbis needs 4 extra bytes padding on Android to decode properly. Check
     // NuMediaExtractor.cpp in Android source code.
     uint8 padding[4] = { 0xff , 0xff , 0xff , 0xff };
@@ -155,7 +155,7 @@ class MediaSourcePlayerTest : public testing::Test {
     scoped_refptr<DecoderBuffer> buffer =
         ReadTestDataFile("vp8-I-frame-320x240");
     ack_params.access_units[0].data = std::vector<uint8>(
-        buffer->GetData(), buffer->GetData() + buffer->GetDataSize());
+        buffer->data(), buffer->data() + buffer->data_size());
     return ack_params;
   }
 
@@ -361,8 +361,8 @@ TEST_F(MediaSourcePlayerTest, DecoderJobsCannotStartWithoutAudio) {
   params.is_audio_encrypted = false;
   scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile("vorbis-extradata");
   params.audio_extra_data = std::vector<uint8>(
-      buffer->GetData(),
-      buffer->GetData() + buffer->GetDataSize());
+      buffer->data(),
+      buffer->data() + buffer->data_size());
   params.video_codec = kCodecVP8;
   params.video_size = gfx::Size(320, 240);
   params.is_video_encrypted = false;
diff --git a/media/base/decoder_buffer.cc b/media/base/decoder_buffer.cc
index d3acc26..9eaa128 100644
--- a/media/base/decoder_buffer.cc
+++ b/media/base/decoder_buffer.cc
@@ -70,67 +70,8 @@ scoped_refptr<DecoderBuffer> DecoderBuffer::CreateEOSBuffer() {
   return make_scoped_refptr(new DecoderBuffer(NULL, 0, NULL, 0));
 }
 
-base::TimeDelta DecoderBuffer::GetTimestamp() const {
-  DCHECK(!IsEndOfStream());
-  return timestamp_;
-}
-
-void DecoderBuffer::SetTimestamp(const base::TimeDelta& timestamp) {
-  DCHECK(!IsEndOfStream());
-  timestamp_ = timestamp;
-}
-
-base::TimeDelta DecoderBuffer::GetDuration() const {
-  DCHECK(!IsEndOfStream());
-  return duration_;
-}
-
-void DecoderBuffer::SetDuration(const base::TimeDelta& duration) {
-  DCHECK(!IsEndOfStream());
-  duration_ = duration;
-}
-
-const uint8* DecoderBuffer::GetData() const {
-  DCHECK(!IsEndOfStream());
-  return data_.get();
-}
-
-uint8* DecoderBuffer::GetWritableData() const {
-  DCHECK(!IsEndOfStream());
-  return data_.get();
-}
-
-int DecoderBuffer::GetDataSize() const {
-  DCHECK(!IsEndOfStream());
-  return size_;
-}
-
-const uint8* DecoderBuffer::GetSideData() const {
-  DCHECK(!IsEndOfStream());
-  return side_data_.get();
-}
-
-int DecoderBuffer::GetSideDataSize() const {
-  DCHECK(!IsEndOfStream());
-  return side_data_size_;
-}
-
-const DecryptConfig* DecoderBuffer::GetDecryptConfig() const {
-  DCHECK(!IsEndOfStream());
-  return decrypt_config_.get();
-}
-
-void DecoderBuffer::SetDecryptConfig(scoped_ptr<DecryptConfig> decrypt_config) {
-  DCHECK(!IsEndOfStream());
-  decrypt_config_ = decrypt_config.Pass();
-}
-
-bool DecoderBuffer::IsEndOfStream() const {
-  return data_ == NULL;
-}
-
 std::string DecoderBuffer::AsHumanReadableString() {
-  if (IsEndOfStream()) {
+  if (end_of_stream()) {
     return "end of stream";
   }
 
diff --git a/media/base/decoder_buffer.h b/media/base/decoder_buffer.h
index 22c0544..6cf519f 100644
--- a/media/base/decoder_buffer.h
+++ b/media/base/decoder_buffer.h
@@ -7,17 +7,17 @@
 
 #include <string>
 
+#include "base/logging.h"
 #include "base/memory/aligned_memory.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
+#include "media/base/decrypt_config.h"
 #include "media/base/media_export.h"
 
 namespace media {
 
-class DecryptConfig;
-
 // A specialized buffer for interfacing with audio / video decoders.
 //
 // Specifically ensures that data is aligned and padded as necessary by the
@@ -26,7 +26,7 @@ class DecryptConfig;
 //
 // Also includes decoder specific functionality for decryption.
 //
-// NOTE: It is illegal to call any method when IsEndOfStream() is true.
+// NOTE: It is illegal to call any method when end_of_stream() is true.
 class MEDIA_EXPORT DecoderBuffer
     : public base::RefCountedThreadSafe<DecoderBuffer> {
  public:
@@ -56,29 +56,69 @@ class MEDIA_EXPORT DecoderBuffer
 
   // Create a DecoderBuffer indicating we've reached end of stream.
   //
-  // Calling any method other than IsEndOfStream() on the resulting buffer
+  // Calling any method other than end_of_stream() on the resulting buffer
   // is disallowed.
   static scoped_refptr<DecoderBuffer> CreateEOSBuffer();
 
-  base::TimeDelta GetTimestamp() const;
-  void SetTimestamp(const base::TimeDelta& timestamp);
-
-  base::TimeDelta GetDuration() const;
-  void SetDuration(const base::TimeDelta& duration);
-
-  const uint8* GetData() const;
-  uint8* GetWritableData() const;
-
-  int GetDataSize() const;
-
-  const uint8* GetSideData() const;
-  int GetSideDataSize() const;
-
-  const DecryptConfig* GetDecryptConfig() const;
-  void SetDecryptConfig(scoped_ptr<DecryptConfig> decrypt_config);
+  base::TimeDelta timestamp() const {
+    DCHECK(!end_of_stream());
+    return timestamp_;
+  }
+
+  void set_timestamp(const base::TimeDelta& timestamp) {
+    DCHECK(!end_of_stream());
+    timestamp_ = timestamp;
+  }
+
+  base::TimeDelta duration() const {
+    DCHECK(!end_of_stream());
+    return duration_;
+  }
+
+  void set_duration(const base::TimeDelta& duration) {
+    DCHECK(!end_of_stream());
+    duration_ = duration;
+  }
+
+  const uint8* data() const {
+    DCHECK(!end_of_stream());
+    return data_.get();
+  }
+
+  uint8* writable_data() const {
+    DCHECK(!end_of_stream());
+    return data_.get();
+  }
+
+  int data_size() const {
+    DCHECK(!end_of_stream());
+    return size_;
+  }
+
+  const uint8* side_data() const {
+    DCHECK(!end_of_stream());
+    return side_data_.get();
+  }
+
+  int side_data_size() const {
+    DCHECK(!end_of_stream());
+    return side_data_size_;
+  }
+
+  const DecryptConfig* decrypt_config() const {
+    DCHECK(!end_of_stream());
+    return decrypt_config_.get();
+  }
+
+  void set_decrypt_config(scoped_ptr<DecryptConfig> decrypt_config) {
+    DCHECK(!end_of_stream());
+    decrypt_config_ = decrypt_config.Pass();
+  }
 
   // If there's no data in this buffer, it represents end of stream.
-  bool IsEndOfStream() const;
+  bool end_of_stream() const {
+    return data_ == NULL;
+  }
 
   // Returns a human-readable string describing |*this|.
   std::string AsHumanReadableString();
diff --git a/media/base/decoder_buffer_queue.cc b/media/base/decoder_buffer_queue.cc
index 8d317c0..d0486cb 100644
--- a/media/base/decoder_buffer_queue.cc
+++ b/media/base/decoder_buffer_queue.cc
@@ -17,31 +17,31 @@ DecoderBufferQueue::DecoderBufferQueue()
 DecoderBufferQueue::~DecoderBufferQueue() {}
 
 void DecoderBufferQueue::Push(const scoped_refptr<DecoderBuffer>& buffer) {
-  CHECK(!buffer->IsEndOfStream());
+  CHECK(!buffer->end_of_stream());
 
   queue_.push_back(buffer);
 
   // TODO(scherkus): FFmpeg returns some packets with no timestamp after
   // seeking. Fix and turn this into CHECK(). See http://crbug.com/162192
-  if (buffer->GetTimestamp() == kNoTimestamp()) {
+  if (buffer->timestamp() == kNoTimestamp()) {
     DVLOG(1) << "Buffer has no timestamp";
     return;
   }
 
   if (earliest_valid_timestamp_ == kNoTimestamp()) {
-    earliest_valid_timestamp_ = buffer->GetTimestamp();
+    earliest_valid_timestamp_ = buffer->timestamp();
   }
 
-  if (buffer->GetTimestamp() < earliest_valid_timestamp_) {
+  if (buffer->timestamp() < earliest_valid_timestamp_) {
     DVLOG(1)
         << "Out of order timestamps: "
-        << buffer->GetTimestamp().InMicroseconds()
+        << buffer->timestamp().InMicroseconds()
         << " vs. "
         << earliest_valid_timestamp_.InMicroseconds();
     return;
   }
 
-  earliest_valid_timestamp_ = buffer->GetTimestamp();
+  earliest_valid_timestamp_ = buffer->timestamp();
   in_order_queue_.push_back(buffer);
 }
 
@@ -71,8 +71,8 @@ base::TimeDelta DecoderBufferQueue::Duration() {
   if (in_order_queue_.size() < 2)
     return base::TimeDelta();
 
-  base::TimeDelta start = in_order_queue_.front()->GetTimestamp();
-  base::TimeDelta end = in_order_queue_.back()->GetTimestamp();
+  base::TimeDelta start = in_order_queue_.front()->timestamp();
+  base::TimeDelta end = in_order_queue_.back()->timestamp();
   return end - start;
 }
 
diff --git a/media/base/decoder_buffer_queue_unittest.cc b/media/base/decoder_buffer_queue_unittest.cc
index 243e465..32e62db 100644
--- a/media/base/decoder_buffer_queue_unittest.cc
+++ b/media/base/decoder_buffer_queue_unittest.cc
@@ -20,8 +20,8 @@ static base::TimeDelta ToTimeDelta(int seconds) {
 // Negative numbers will be converted to kNoTimestamp();
 static scoped_refptr<DecoderBuffer> CreateBuffer(int timestamp) {
   scoped_refptr<DecoderBuffer> buffer = new DecoderBuffer(0);
-  buffer->SetTimestamp(ToTimeDelta(timestamp));
-  buffer->SetDuration(ToTimeDelta(0));
+  buffer->set_timestamp(ToTimeDelta(timestamp));
+  buffer->set_duration(ToTimeDelta(0));
   return buffer;
 }
 
diff --git a/media/base/decoder_buffer_unittest.cc b/media/base/decoder_buffer_unittest.cc
index 42551a4..c5a03b7 100644
--- a/media/base/decoder_buffer_unittest.cc
+++ b/media/base/decoder_buffer_unittest.cc
@@ -10,19 +10,19 @@ namespace media {
 
 TEST(DecoderBufferTest, Constructors) {
   scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(0));
-  EXPECT_TRUE(buffer->GetData());
-  EXPECT_EQ(0, buffer->GetDataSize());
-  EXPECT_FALSE(buffer->IsEndOfStream());
+  EXPECT_TRUE(buffer->data());
+  EXPECT_EQ(0, buffer->data_size());
+  EXPECT_FALSE(buffer->end_of_stream());
 
   const int kTestSize = 10;
   scoped_refptr<DecoderBuffer> buffer3(new DecoderBuffer(kTestSize));
   ASSERT_TRUE(buffer3.get());
-  EXPECT_EQ(kTestSize, buffer3->GetDataSize());
+  EXPECT_EQ(kTestSize, buffer3->data_size());
 }
 
 TEST(DecoderBufferTest, CreateEOSBuffer) {
   scoped_refptr<DecoderBuffer> buffer(DecoderBuffer::CreateEOSBuffer());
-  EXPECT_TRUE(buffer->IsEndOfStream());
+  EXPECT_TRUE(buffer->end_of_stream());
 }
 
 TEST(DecoderBufferTest, CopyFrom) {
@@ -31,21 +31,21 @@ TEST(DecoderBufferTest, CopyFrom) {
   scoped_refptr<DecoderBuffer> buffer2(DecoderBuffer::CopyFrom(
       reinterpret_cast<const uint8*>(&kData), kDataSize));
   ASSERT_TRUE(buffer2.get());
-  EXPECT_NE(kData, buffer2->GetData());
-  EXPECT_EQ(buffer2->GetDataSize(), kDataSize);
-  EXPECT_EQ(0, memcmp(buffer2->GetData(), kData, kDataSize));
-  EXPECT_FALSE(buffer2->IsEndOfStream());
+  EXPECT_NE(kData, buffer2->data());
+  EXPECT_EQ(buffer2->data_size(), kDataSize);
+  EXPECT_EQ(0, memcmp(buffer2->data(), kData, kDataSize));
+  EXPECT_FALSE(buffer2->end_of_stream());
   scoped_refptr<DecoderBuffer> buffer3(DecoderBuffer::CopyFrom(
       reinterpret_cast<const uint8*>(&kData), kDataSize,
       reinterpret_cast<const uint8*>(&kData), kDataSize));
   ASSERT_TRUE(buffer3.get());
-  EXPECT_NE(kData, buffer3->GetData());
-  EXPECT_EQ(buffer3->GetDataSize(), kDataSize);
-  EXPECT_EQ(0, memcmp(buffer3->GetData(), kData, kDataSize));
-  EXPECT_NE(kData, buffer3->GetSideData());
-  EXPECT_EQ(buffer3->GetSideDataSize(), kDataSize);
-  EXPECT_EQ(0, memcmp(buffer3->GetSideData(), kData, kDataSize));
-  EXPECT_FALSE(buffer3->IsEndOfStream());
+  EXPECT_NE(kData, buffer3->data());
+  EXPECT_EQ(buffer3->data_size(), kDataSize);
+  EXPECT_EQ(0, memcmp(buffer3->data(), kData, kDataSize));
+  EXPECT_NE(kData, buffer3->side_data());
+  EXPECT_EQ(buffer3->side_data_size(), kDataSize);
+  EXPECT_EQ(0, memcmp(buffer3->side_data(), kData, kDataSize));
+  EXPECT_FALSE(buffer3->end_of_stream());
 }
 
 #if !defined(OS_ANDROID)
@@ -58,20 +58,20 @@ TEST(DecoderBufferTest, PaddingAlignment) {
 
   // Padding data should always be zeroed.
   for(int i = 0; i < DecoderBuffer::kPaddingSize; i++)
-    EXPECT_EQ((buffer2->GetData() + kDataSize)[i], 0);
+    EXPECT_EQ((buffer2->data() + kDataSize)[i], 0);
 
   // If the data is padded correctly we should be able to read and write past
   // the end of the data by DecoderBuffer::kPaddingSize bytes without crashing
   // or Valgrind/ASAN throwing errors.
   const uint8 kFillChar = 0xFF;
   memset(
-      buffer2->GetWritableData() + kDataSize, kFillChar,
+      buffer2->writable_data() + kDataSize, kFillChar,
       DecoderBuffer::kPaddingSize);
   for(int i = 0; i < DecoderBuffer::kPaddingSize; i++)
-    EXPECT_EQ((buffer2->GetData() + kDataSize)[i], kFillChar);
+    EXPECT_EQ((buffer2->data() + kDataSize)[i], kFillChar);
 
   EXPECT_EQ(0u, reinterpret_cast<uintptr_t>(
-      buffer2->GetData()) & (DecoderBuffer::kAlignmentSize - 1));
+      buffer2->data()) & (DecoderBuffer::kAlignmentSize - 1));
 }
 #endif
 
@@ -82,19 +82,19 @@ TEST(DecoderBufferTest, ReadingWriting) {
   scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(kDataSize));
   ASSERT_TRUE(buffer.get());
 
-  uint8* data = buffer->GetWritableData();
+  uint8* data = buffer->writable_data();
   ASSERT_TRUE(data);
-  ASSERT_EQ(kDataSize, buffer->GetDataSize());
+  ASSERT_EQ(kDataSize, buffer->data_size());
   memcpy(data, kData, kDataSize);
-  const uint8* read_only_data = buffer->GetData();
+  const uint8* read_only_data = buffer->data();
   ASSERT_EQ(data, read_only_data);
   ASSERT_EQ(0, memcmp(read_only_data, kData, kDataSize));
-  EXPECT_FALSE(buffer->IsEndOfStream());
+  EXPECT_FALSE(buffer->end_of_stream());
 }
 
 TEST(DecoderBufferTest, GetDecryptConfig) {
   scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(0));
-  EXPECT_FALSE(buffer->GetDecryptConfig());
+  EXPECT_FALSE(buffer->decrypt_config());
 }
 
 }  // namespace media
diff --git a/media/base/stream_parser_buffer.cc b/media/base/stream_parser_buffer.cc
index f1dd6fd..bb46ef5 100644
--- a/media/base/stream_parser_buffer.cc
+++ b/media/base/stream_parser_buffer.cc
@@ -29,7 +29,7 @@ scoped_refptr<StreamParserBuffer> StreamParserBuffer::CopyFrom(
 
 base::TimeDelta StreamParserBuffer::GetDecodeTimestamp() const {
   if (decode_timestamp_ == kNoTimestamp())
-    return GetTimestamp();
+    return timestamp();
   return decode_timestamp_;
 }
 
@@ -48,7 +48,7 @@ StreamParserBuffer::StreamParserBuffer(const uint8* data, int data_size,
   // duration to force clients to set them? Today they end up being zero which
   // is both a common and valid value and could lead to bugs.
   if (data) {
-    SetDuration(kNoTimestamp());
+    set_duration(kNoTimestamp());
   }
 }
 
diff --git a/media/base/test_data_util.cc b/media/base/test_data_util.cc
index 9c62c57..55e82fc86 100644
--- a/media/base/test_data_util.cc
+++ b/media/base/test_data_util.cc
@@ -16,8 +16,7 @@ base::FilePath GetTestDataFilePath(const std::string& name) {
   CHECK(PathService::Get(base::DIR_SOURCE_ROOT, &file_path));
 
   file_path = file_path.Append(FILE_PATH_LITERAL("media"))
-      .Append(FILE_PATH_LITERAL("test"))
-      .Append(FILE_PATH_LITERAL("data"))
+      .Append(FILE_PATH_LITERAL("test")).Append(FILE_PATH_LITERAL("data"))
       .AppendASCII(name);
   return file_path;
 }
@@ -27,8 +26,7 @@ scoped_refptr<DecoderBuffer> ReadTestDataFile(const std::string& name) {
   CHECK(PathService::Get(base::DIR_SOURCE_ROOT, &file_path));
 
   file_path = file_path.Append(FILE_PATH_LITERAL("media"))
-      .Append(FILE_PATH_LITERAL("test"))
-      .Append(FILE_PATH_LITERAL("data"))
+      .Append(FILE_PATH_LITERAL("test")).Append(FILE_PATH_LITERAL("data"))
       .AppendASCII(name);
 
   int64 tmp = 0;
@@ -38,9 +36,10 @@ scoped_refptr<DecoderBuffer> ReadTestDataFile(const std::string& name) {
   int file_size = static_cast<int>(tmp);
 
   scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(file_size));
-  CHECK_EQ(file_size, file_util::ReadFile(
-      file_path, reinterpret_cast<char*>(buffer->GetWritableData()), file_size))
-      << "Failed to read '" << name << "'";
+  CHECK_EQ(file_size,
+           file_util::ReadFile(
+               file_path, reinterpret_cast<char*>(buffer->writable_data()),
+               file_size)) << "Failed to read '" << name << "'";
 
   return buffer;
 }
diff --git a/media/base/test_helpers.cc b/media/base/test_helpers.cc
index db96be4..43c5cfa 100644
--- a/media/base/test_helpers.cc
+++ b/media/base/test_helpers.cc
@@ -258,8 +258,8 @@ scoped_refptr<DecoderBuffer> CreateFakeVideoBufferForTest(
   scoped_refptr<DecoderBuffer> buffer = DecoderBuffer::CopyFrom(
       static_cast<const uint8*>(pickle.data()),
       static_cast<int>(pickle.size()));
-  buffer->SetTimestamp(timestamp);
-  buffer->SetDuration(duration);
+  buffer->set_timestamp(timestamp);
+  buffer->set_duration(duration);
 
   return buffer;
 }
@@ -268,8 +268,8 @@ bool VerifyFakeVideoBufferForTest(
     const scoped_refptr<DecoderBuffer>& buffer,
     const VideoDecoderConfig& config) {
   // Check if the input |buffer| matches the |config|.
-  PickleIterator pickle(Pickle(reinterpret_cast<const char*>(buffer->GetData()),
-                               buffer->GetDataSize()));
+  PickleIterator pickle(Pickle(reinterpret_cast<const char*>(buffer->data()),
+                               buffer->data_size()));
   std::string header;
   int width = 0;
   int height = 0;
diff --git a/media/crypto/aes_decryptor.cc b/media/crypto/aes_decryptor.cc
index 2e54435..a45b687 100644
--- a/media/crypto/aes_decryptor.cc
+++ b/media/crypto/aes_decryptor.cc
@@ -47,8 +47,8 @@ static void CopySubsamples(const std::vector<SubsampleEntry>& subsamples,
 // data if decryption succeeded or NULL if decryption failed.
 static scoped_refptr<DecoderBuffer> DecryptData(const DecoderBuffer& input,
                                                 crypto::SymmetricKey* key) {
-  CHECK(input.GetDataSize());
-  CHECK(input.GetDecryptConfig());
+  CHECK(input.data_size());
+  CHECK(input.decrypt_config());
   CHECK(key);
 
   crypto::Encryptor encryptor;
@@ -57,19 +57,19 @@ static scoped_refptr<DecoderBuffer> DecryptData(const DecoderBuffer& input,
     return NULL;
   }
 
-  DCHECK_EQ(input.GetDecryptConfig()->iv().size(),
+  DCHECK_EQ(input.decrypt_config()->iv().size(),
             static_cast<size_t>(DecryptConfig::kDecryptionKeySize));
-  if (!encryptor.SetCounter(input.GetDecryptConfig()->iv())) {
+  if (!encryptor.SetCounter(input.decrypt_config()->iv())) {
     DVLOG(1) << "Could not set counter block.";
     return NULL;
   }
 
-  const int data_offset = input.GetDecryptConfig()->data_offset();
+  const int data_offset = input.decrypt_config()->data_offset();
   const char* sample =
-      reinterpret_cast<const char*>(input.GetData() + data_offset);
-  int sample_size = input.GetDataSize() - data_offset;
+      reinterpret_cast<const char*>(input.data() + data_offset);
+  int sample_size = input.data_size() - data_offset;
 
-  if (input.GetDecryptConfig()->subsamples().empty()) {
+  if (input.decrypt_config()->subsamples().empty()) {
     std::string decrypted_text;
     base::StringPiece encrypted_text(sample, sample_size);
     if (!encryptor.Decrypt(encrypted_text, &decrypted_text)) {
@@ -84,7 +84,7 @@ static scoped_refptr<DecoderBuffer> DecryptData(const DecoderBuffer& input,
   }
 
   const std::vector<SubsampleEntry>& subsamples =
-      input.GetDecryptConfig()->subsamples();
+      input.decrypt_config()->subsamples();
 
   int total_clear_size = 0;
   int total_encrypted_size = 0;
@@ -120,7 +120,7 @@ static scoped_refptr<DecoderBuffer> DecryptData(const DecoderBuffer& input,
       reinterpret_cast<const uint8*>(sample), sample_size);
   CopySubsamples(subsamples, kDstContainsClearBytes,
                  reinterpret_cast<const uint8*>(decrypted_text.data()),
-                 output->GetWritableData());
+                 output->writable_data());
   return output;
 }
 
@@ -228,16 +228,16 @@ void AesDecryptor::RegisterNewKeyCB(StreamType stream_type,
 void AesDecryptor::Decrypt(StreamType stream_type,
                            const scoped_refptr<DecoderBuffer>& encrypted,
                            const DecryptCB& decrypt_cb) {
-  CHECK(encrypted->GetDecryptConfig());
+  CHECK(encrypted->decrypt_config());
 
   scoped_refptr<DecoderBuffer> decrypted;
   // An empty iv string signals that the frame is unencrypted.
-  if (encrypted->GetDecryptConfig()->iv().empty()) {
-    int data_offset = encrypted->GetDecryptConfig()->data_offset();
-    decrypted = DecoderBuffer::CopyFrom(encrypted->GetData() + data_offset,
-                                        encrypted->GetDataSize() - data_offset);
+  if (encrypted->decrypt_config()->iv().empty()) {
+    int data_offset = encrypted->decrypt_config()->data_offset();
+    decrypted = DecoderBuffer::CopyFrom(encrypted->data() + data_offset,
+                                        encrypted->data_size() - data_offset);
   } else {
-    const std::string& key_id = encrypted->GetDecryptConfig()->key_id();
+    const std::string& key_id = encrypted->decrypt_config()->key_id();
     DecryptionKey* key = GetKey(key_id);
     if (!key) {
       DVLOG(1) << "Could not find a matching key for the given key ID.";
@@ -254,8 +254,8 @@ void AesDecryptor::Decrypt(StreamType stream_type,
     }
   }
 
-  decrypted->SetTimestamp(encrypted->GetTimestamp());
-  decrypted->SetDuration(encrypted->GetDuration());
+  decrypted->set_timestamp(encrypted->timestamp());
+  decrypted->set_duration(encrypted->duration());
   decrypt_cb.Run(kSuccess, decrypted);
 }
 
diff --git a/media/crypto/aes_decryptor_unittest.cc b/media/crypto/aes_decryptor_unittest.cc
index 82b9243..85f864a 100644
--- a/media/crypto/aes_decryptor_unittest.cc
+++ b/media/crypto/aes_decryptor_unittest.cc
@@ -200,7 +200,7 @@ static scoped_refptr<DecoderBuffer> CreateWebMEncryptedBuffer(
     data_offset += kWebMIvSize;
   }
 
-  encrypted_buffer->SetDecryptConfig(
+  encrypted_buffer->set_decrypt_config(
       scoped_ptr<DecryptConfig>(new DecryptConfig(
           std::string(reinterpret_cast<const char*>(key_id), key_id_size),
           counter_block_str,
@@ -218,7 +218,7 @@ static scoped_refptr<DecoderBuffer> CreateSubsampleEncryptedBuffer(
   scoped_refptr<DecoderBuffer> encrypted_buffer =
       DecoderBuffer::CopyFrom(data, data_size);
   CHECK(encrypted_buffer.get());
-  encrypted_buffer->SetDecryptConfig(
+  encrypted_buffer->set_decrypt_config(
       scoped_ptr<DecryptConfig>(new DecryptConfig(
           std::string(reinterpret_cast<const char*>(key_id), key_id_size),
           std::string(reinterpret_cast<const char*>(iv), iv_size),
@@ -274,8 +274,8 @@ class AesDecryptorTest : public testing::Test {
 
     decryptor_.Decrypt(Decryptor::kVideo, encrypted, decrypt_cb_);
     ASSERT_TRUE(decrypted.get());
-    ASSERT_EQ(plain_text_size, decrypted->GetDataSize());
-    EXPECT_EQ(0, memcmp(plain_text, decrypted->GetData(), plain_text_size));
+    ASSERT_EQ(plain_text_size, decrypted->data_size());
+    EXPECT_EQ(0, memcmp(plain_text, decrypted->data(), plain_text_size));
   }
 
   void DecryptAndExpectDataMismatch(
@@ -287,8 +287,8 @@ class AesDecryptorTest : public testing::Test {
 
     decryptor_.Decrypt(Decryptor::kVideo, encrypted, decrypt_cb_);
     ASSERT_TRUE(decrypted.get());
-    ASSERT_EQ(plain_text_size, decrypted->GetDataSize());
-    EXPECT_NE(0, memcmp(plain_text, decrypted->GetData(), plain_text_size));
+    ASSERT_EQ(plain_text_size, decrypted->data_size());
+    EXPECT_NE(0, memcmp(plain_text, decrypted->data(), plain_text_size));
   }
 
   void DecryptAndExpectSizeDataMismatch(
@@ -300,8 +300,8 @@ class AesDecryptorTest : public testing::Test {
 
     decryptor_.Decrypt(Decryptor::kVideo, encrypted, decrypt_cb_);
     ASSERT_TRUE(decrypted.get());
-    EXPECT_NE(plain_text_size, decrypted->GetDataSize());
-    EXPECT_NE(0, memcmp(plain_text, decrypted->GetData(), plain_text_size));
+    EXPECT_NE(plain_text_size, decrypted->data_size());
+    EXPECT_NE(0, memcmp(plain_text, decrypted->data(), plain_text_size));
   }
 
   void DecryptAndExpectToFail(const scoped_refptr<DecoderBuffer>& encrypted) {
diff --git a/media/filters/audio_file_reader_unittest.cc b/media/filters/audio_file_reader_unittest.cc
index df0298a..7ce37ff 100644
--- a/media/filters/audio_file_reader_unittest.cc
+++ b/media/filters/audio_file_reader_unittest.cc
@@ -23,7 +23,7 @@ class AudioFileReaderTest : public testing::Test {
   void Initialize(const char* filename) {
     data_ = ReadTestDataFile(filename);
     protocol_.reset(new InMemoryUrlProtocol(
-        data_->GetData(), data_->GetDataSize(), false));
+        data_->data(), data_->data_size(), false));
     reader_.reset(new AudioFileReader(protocol_.get()));
   }
 
diff --git a/media/filters/chunk_demuxer.cc b/media/filters/chunk_demuxer.cc
index be5d45c..3a33903 100644
--- a/media/filters/chunk_demuxer.cc
+++ b/media/filters/chunk_demuxer.cc
@@ -280,7 +280,7 @@ void SourceState::AdjustBufferTimestamps(
        itr != buffers.end(); ++itr) {
     (*itr)->SetDecodeTimestamp(
         (*itr)->GetDecodeTimestamp() + timestamp_offset_);
-    (*itr)->SetTimestamp((*itr)->GetTimestamp() + timestamp_offset_);
+    (*itr)->set_timestamp((*itr)->timestamp() + timestamp_offset_);
   }
 }
 
@@ -385,7 +385,7 @@ bool SourceState::OnBuffers(DemuxerStream::Type type,
 
   if (!stream->Append(buffers))
     return false;
-  increase_duration_cb_.Run(buffers.back()->GetTimestamp(), stream);
+  increase_duration_cb_.Run(buffers.back()->timestamp(), stream);
   return true;
 }
 
@@ -1206,13 +1206,13 @@ bool ChunkDemuxer::OnTextBuffers(
   for (StreamParser::BufferQueue::const_iterator itr = buffers.begin();
        itr != buffers.end(); ++itr) {
     const StreamParserBuffer* const buffer = itr->get();
-    const TimeDelta start = buffer->GetTimestamp();
-    const TimeDelta end = start + buffer->GetDuration();
+    const TimeDelta start = buffer->timestamp();
+    const TimeDelta end = start + buffer->duration();
 
     std::string id, settings, content;
 
-    WebMWebVTTParser::Parse(buffer->GetData(),
-                            buffer->GetDataSize(),
+    WebMWebVTTParser::Parse(buffer->data(),
+                            buffer->data_size(),
                             &id, &settings, &content);
 
     text_track->addWebVTTCue(start, end, id, content, settings);
diff --git a/media/filters/chunk_demuxer_unittest.cc b/media/filters/chunk_demuxer_unittest.cc
index d2e56fc..b735b56 100644
--- a/media/filters/chunk_demuxer_unittest.cc
+++ b/media/filters/chunk_demuxer_unittest.cc
@@ -89,18 +89,18 @@ static void WriteInt64(uint8* buffer, int64 number) {
 }
 
 MATCHER_P(HasTimestamp, timestamp_in_ms, "") {
-  return arg.get() && !arg->IsEndOfStream() &&
-         arg->GetTimestamp().InMilliseconds() == timestamp_in_ms;
+  return arg.get() && !arg->end_of_stream() &&
+         arg->timestamp().InMilliseconds() == timestamp_in_ms;
 }
 
-MATCHER(IsEndOfStream, "") { return arg.get() && arg->IsEndOfStream(); }
+MATCHER(IsEndOfStream, "") { return arg.get() && arg->end_of_stream(); }
 
 static void OnReadDone(const base::TimeDelta& expected_time,
                        bool* called,
                        DemuxerStream::Status status,
                        const scoped_refptr<DecoderBuffer>& buffer) {
   EXPECT_EQ(status, DemuxerStream::kOk);
-  EXPECT_EQ(expected_time, buffer->GetTimestamp());
+  EXPECT_EQ(expected_time, buffer->timestamp());
   *called = true;
 }
 
@@ -116,7 +116,7 @@ static void OnReadDone_EOSExpected(bool* called,
                                    DemuxerStream::Status status,
                                    const scoped_refptr<DecoderBuffer>& buffer) {
   EXPECT_EQ(status, DemuxerStream::kOk);
-  EXPECT_TRUE(buffer->IsEndOfStream());
+  EXPECT_TRUE(buffer->end_of_stream());
   *called = true;
 }
 
@@ -185,33 +185,33 @@ class ChunkDemuxerTest : public testing::Test {
 
     if (has_audio) {
       audio_track_entry = ReadTestDataFile("webm_vorbis_track_entry");
-      tracks_element_size += audio_track_entry->GetDataSize();
+      tracks_element_size += audio_track_entry->data_size();
       if (is_audio_encrypted) {
         audio_content_encodings = ReadTestDataFile("webm_content_encodings");
-        tracks_element_size += audio_content_encodings->GetDataSize();
+        tracks_element_size += audio_content_encodings->data_size();
       }
     }
 
     if (has_video) {
       video_track_entry = ReadTestDataFile("webm_vp8_track_entry");
-      tracks_element_size += video_track_entry->GetDataSize();
+      tracks_element_size += video_track_entry->data_size();
       if (is_video_encrypted) {
         video_content_encodings = ReadTestDataFile("webm_content_encodings");
-        tracks_element_size += video_content_encodings->GetDataSize();
+        tracks_element_size += video_content_encodings->data_size();
       }
     }
 
-    *size = ebml_header->GetDataSize() + info->GetDataSize() +
+    *size = ebml_header->data_size() + info->data_size() +
         kTracksHeaderSize + tracks_element_size;
 
     buffer->reset(new uint8[*size]);
 
     uint8* buf = buffer->get();
-    memcpy(buf, ebml_header->GetData(), ebml_header->GetDataSize());
-    buf += ebml_header->GetDataSize();
+    memcpy(buf, ebml_header->data(), ebml_header->data_size());
+    buf += ebml_header->data_size();
 
-    memcpy(buf, info->GetData(), info->GetDataSize());
-    buf += info->GetDataSize();
+    memcpy(buf, info->data(), info->data_size());
+    buf += info->data_size();
 
     memcpy(buf, kTracksHeader, kTracksHeaderSize);
     WriteInt64(buf + kTracksSizeOffset, tracks_element_size);
@@ -220,35 +220,35 @@ class ChunkDemuxerTest : public testing::Test {
     // TODO(xhwang): Simplify this! Probably have test data files that contain
     // ContentEncodings directly instead of trying to create one at run-time.
     if (has_audio) {
-      memcpy(buf, audio_track_entry->GetData(),
-             audio_track_entry->GetDataSize());
+      memcpy(buf, audio_track_entry->data(),
+             audio_track_entry->data_size());
       if (is_audio_encrypted) {
-        memcpy(buf + audio_track_entry->GetDataSize(),
-               audio_content_encodings->GetData(),
-               audio_content_encodings->GetDataSize());
+        memcpy(buf + audio_track_entry->data_size(),
+               audio_content_encodings->data(),
+               audio_content_encodings->data_size());
         WriteInt64(buf + kAudioTrackSizeOffset,
-                   audio_track_entry->GetDataSize() +
-                   audio_content_encodings->GetDataSize() -
+                   audio_track_entry->data_size() +
+                   audio_content_encodings->data_size() -
                    kAudioTrackEntryHeaderSize);
-        buf += audio_content_encodings->GetDataSize();
+        buf += audio_content_encodings->data_size();
       }
-      buf += audio_track_entry->GetDataSize();
+      buf += audio_track_entry->data_size();
     }
 
     if (has_video) {
-      memcpy(buf, video_track_entry->GetData(),
-             video_track_entry->GetDataSize());
+      memcpy(buf, video_track_entry->data(),
+             video_track_entry->data_size());
       if (is_video_encrypted) {
-        memcpy(buf + video_track_entry->GetDataSize(),
-               video_content_encodings->GetData(),
-               video_content_encodings->GetDataSize());
+        memcpy(buf + video_track_entry->data_size(),
+               video_content_encodings->data(),
+               video_content_encodings->data_size());
         WriteInt64(buf + kVideoTrackSizeOffset,
-                   video_track_entry->GetDataSize() +
-                   video_content_encodings->GetDataSize() -
+                   video_track_entry->data_size() +
+                   video_content_encodings->data_size() -
                    kVideoTrackEntryHeaderSize);
-        buf += video_content_encodings->GetDataSize();
+        buf += video_content_encodings->data_size();
       }
-      buf += video_track_entry->GetDataSize();
+      buf += video_track_entry->data_size();
     }
   }
 
@@ -460,7 +460,7 @@ class ChunkDemuxerTest : public testing::Test {
       return false;
 
     // Append the whole bear1 file.
-    AppendData(bear1->GetData(), bear1->GetDataSize());
+    AppendData(bear1->data(), bear1->data_size());
     CheckExpectedRanges(kSourceId, "{ [0,2737) }");
 
     // Append initialization segment for bear2.
@@ -469,16 +469,16 @@ class ChunkDemuxerTest : public testing::Test {
     // media/test/data/bear-320x240-manifest.js which were
     // generated from media/test/data/bear-640x360.webm and
     // media/test/data/bear-320x240.webm respectively.
-    AppendData(bear2->GetData(), 4340);
+    AppendData(bear2->data(), 4340);
 
     // Append a media segment that goes from [0.527000, 1.014000).
-    AppendData(bear2->GetData() + 55290, 18785);
+    AppendData(bear2->data() + 55290, 18785);
     CheckExpectedRanges(kSourceId, "{ [0,1028) [1201,2737) }");
 
     // Append initialization segment for bear1 & fill gap with [779-1197)
     // segment.
-    AppendData(bear1->GetData(), 4370);
-    AppendData(bear1->GetData() + 72737, 28183);
+    AppendData(bear1->data(), 4370);
+    AppendData(bear1->data() + 72737, 28183);
     CheckExpectedRanges(kSourceId, "{ [0,2737) }");
 
     EndOfStream(PIPELINE_OK);
@@ -706,9 +706,9 @@ class ChunkDemuxerTest : public testing::Test {
       stream->Read(base::Bind(&ChunkDemuxerTest::StoreStatusAndBuffer,
                               base::Unretained(this), status, &buffer));
       base::MessageLoop::current()->RunUntilIdle();
-      if (*status == DemuxerStream::kOk && !buffer->IsEndOfStream())
-        *last_timestamp = buffer->GetTimestamp();
-    } while (*status == DemuxerStream::kOk && !buffer->IsEndOfStream());
+      if (*status == DemuxerStream::kOk && !buffer->end_of_stream())
+        *last_timestamp = buffer->timestamp();
+    } while (*status == DemuxerStream::kOk && !buffer->end_of_stream());
   }
 
   void ExpectEndOfStream(DemuxerStream::Type type) {
@@ -766,7 +766,7 @@ class ChunkDemuxerTest : public testing::Test {
 
     // Read a WebM file into memory and send the data to the demuxer.
     scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(filename);
-    AppendDataInPieces(buffer->GetData(), buffer->GetDataSize(), 512);
+    AppendDataInPieces(buffer->data(), buffer->data_size(), 512);
 
     // Verify that the timestamps on the first few packets match what we
     // expect.
@@ -1205,7 +1205,7 @@ class EndOfStreamHelper {
       DemuxerStream::Status status,
       const scoped_refptr<DecoderBuffer>& buffer) {
     EXPECT_EQ(status, DemuxerStream::kOk);
-    EXPECT_TRUE(buffer->IsEndOfStream());
+    EXPECT_TRUE(buffer->end_of_stream());
     *called = true;
   }
 
diff --git a/media/filters/decrypting_audio_decoder.cc b/media/filters/decrypting_audio_decoder.cc
index 45d846e..f516674 100644
--- a/media/filters/decrypting_audio_decoder.cc
+++ b/media/filters/decrypting_audio_decoder.cc
@@ -310,8 +310,8 @@ void DecryptingAudioDecoder::DecryptAndDecodeBuffer(
   // Initialize the |next_output_timestamp_| to be the timestamp of the first
   // non-EOS buffer.
   if (timestamp_helper_->base_timestamp() == kNoTimestamp() &&
-      !buffer->IsEndOfStream()) {
-    timestamp_helper_->SetBaseTimestamp(buffer->GetTimestamp());
+      !buffer->end_of_stream()) {
+    timestamp_helper_->SetBaseTimestamp(buffer->timestamp());
   }
 
   pending_buffer_to_decode_ = buffer;
@@ -324,8 +324,8 @@ void DecryptingAudioDecoder::DecodePendingBuffer() {
   DCHECK_EQ(state_, kPendingDecode) << state_;
 
   int buffer_size = 0;
-  if (!pending_buffer_to_decode_->IsEndOfStream()) {
-    buffer_size = pending_buffer_to_decode_->GetDataSize();
+  if (!pending_buffer_to_decode_->end_of_stream()) {
+    buffer_size = pending_buffer_to_decode_->data_size();
   }
 
   decryptor_->DecryptAndDecodeAudio(
@@ -392,7 +392,7 @@ void DecryptingAudioDecoder::DeliverFrame(
 
   if (status == Decryptor::kNeedMoreData) {
     DVLOG(2) << "DeliverFrame() - kNeedMoreData";
-    if (scoped_pending_buffer_to_decode->IsEndOfStream()) {
+    if (scoped_pending_buffer_to_decode->end_of_stream()) {
       state_ = kDecodeFinished;
       base::ResetAndReturn(&read_cb_).Run(kOk, AudioBuffer::CreateEOSBuffer());
       return;
diff --git a/media/filters/decrypting_audio_decoder_unittest.cc b/media/filters/decrypting_audio_decoder_unittest.cc
index 5af737c..fb97b91 100644
--- a/media/filters/decrypting_audio_decoder_unittest.cc
+++ b/media/filters/decrypting_audio_decoder_unittest.cc
@@ -36,7 +36,7 @@ static const uint8 kFakeIv[DecryptConfig::kDecryptionKeySize] = { 0 };
 static scoped_refptr<DecoderBuffer> CreateFakeEncryptedBuffer() {
   const int buffer_size = 16;  // Need a non-empty buffer;
   scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(buffer_size));
-  buffer->SetDecryptConfig(scoped_ptr<DecryptConfig>(new DecryptConfig(
+  buffer->set_decrypt_config(scoped_ptr<DecryptConfig>(new DecryptConfig(
       std::string(reinterpret_cast<const char*>(kFakeKeyId),
                   arraysize(kFakeKeyId)),
       std::string(reinterpret_cast<const char*>(kFakeIv), arraysize(kFakeIv)),
diff --git a/media/filters/decrypting_demuxer_stream.cc b/media/filters/decrypting_demuxer_stream.cc
index b3485c9..1f183ce 100644
--- a/media/filters/decrypting_demuxer_stream.cc
+++ b/media/filters/decrypting_demuxer_stream.cc
@@ -188,7 +188,7 @@ void DecryptingDemuxerStream::DecryptBuffer(
     return;
   }
 
-  if (buffer->IsEndOfStream()) {
+  if (buffer->end_of_stream()) {
     DVLOG(2) << "DoDecryptBuffer() - EOS buffer.";
     state_ = kIdle;
     base::ResetAndReturn(&read_cb_).Run(status, buffer);
diff --git a/media/filters/decrypting_demuxer_stream_unittest.cc b/media/filters/decrypting_demuxer_stream_unittest.cc
index 5ff7eb7..e971aa6 100644
--- a/media/filters/decrypting_demuxer_stream_unittest.cc
+++ b/media/filters/decrypting_demuxer_stream_unittest.cc
@@ -31,7 +31,7 @@ static const uint8 kFakeIv[DecryptConfig::kDecryptionKeySize] = { 0 };
 // Create a fake non-empty encrypted buffer.
 static scoped_refptr<DecoderBuffer> CreateFakeEncryptedBuffer() {
   scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(kFakeBufferSize));
-  buffer->SetDecryptConfig(scoped_ptr<DecryptConfig>(new DecryptConfig(
+  buffer->set_decrypt_config(scoped_ptr<DecryptConfig>(new DecryptConfig(
       std::string(reinterpret_cast<const char*>(kFakeKeyId),
                   arraysize(kFakeKeyId)),
       std::string(reinterpret_cast<const char*>(kFakeIv), arraysize(kFakeIv)),
@@ -58,7 +58,7 @@ ACTION_P2(ResetAndRunCallback, callback, param) {
 }
 
 MATCHER(IsEndOfStream, "end of stream") {
-  return (arg->IsEndOfStream());
+  return arg->end_of_stream();
 }
 
 }  // namespace
@@ -129,7 +129,7 @@ class DecryptingDemuxerStreamTest : public testing::Test {
       const scoped_refptr<DecoderBuffer>& decrypted_buffer) {
     if (status != DemuxerStream::kOk)
       EXPECT_CALL(*this, BufferReady(status, IsNull()));
-    else if (decrypted_buffer->IsEndOfStream())
+    else if (decrypted_buffer->end_of_stream())
       EXPECT_CALL(*this, BufferReady(status, IsEndOfStream()));
     else
       EXPECT_CALL(*this, BufferReady(status, decrypted_buffer));
diff --git a/media/filters/decrypting_video_decoder.cc b/media/filters/decrypting_video_decoder.cc
index 1e1425e..3606c99 100644
--- a/media/filters/decrypting_video_decoder.cc
+++ b/media/filters/decrypting_video_decoder.cc
@@ -214,8 +214,8 @@ void DecryptingVideoDecoder::DecodePendingBuffer() {
       "eme", "DecryptingVideoDecoder::DecodePendingBuffer", ++trace_id_);
 
   int buffer_size = 0;
-  if (!pending_buffer_to_decode_->IsEndOfStream()) {
-    buffer_size = pending_buffer_to_decode_->GetDataSize();
+  if (!pending_buffer_to_decode_->end_of_stream()) {
+    buffer_size = pending_buffer_to_decode_->data_size();
   }
 
   decryptor_->DecryptAndDecodeVideo(
@@ -279,7 +279,7 @@ void DecryptingVideoDecoder::DeliverFrame(
 
   if (status == Decryptor::kNeedMoreData) {
     DVLOG(2) << "DeliverFrame() - kNeedMoreData";
-    if (scoped_pending_buffer_to_decode->IsEndOfStream()) {
+    if (scoped_pending_buffer_to_decode->end_of_stream()) {
       state_ = kDecodeFinished;
       base::ResetAndReturn(&read_cb_).Run(
           kOk, media::VideoFrame::CreateEmptyFrame());
diff --git a/media/filters/decrypting_video_decoder_unittest.cc b/media/filters/decrypting_video_decoder_unittest.cc
index 017ea3e..f1bbf8d 100644
--- a/media/filters/decrypting_video_decoder_unittest.cc
+++ b/media/filters/decrypting_video_decoder_unittest.cc
@@ -33,7 +33,7 @@ static const uint8 kFakeIv[DecryptConfig::kDecryptionKeySize] = { 0 };
 static scoped_refptr<DecoderBuffer> CreateFakeEncryptedBuffer() {
   const int buffer_size = 16;  // Need a non-empty buffer;
   scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(buffer_size));
-  buffer->SetDecryptConfig(scoped_ptr<DecryptConfig>(new DecryptConfig(
+  buffer->set_decrypt_config(scoped_ptr<DecryptConfig>(new DecryptConfig(
       std::string(reinterpret_cast<const char*>(kFakeKeyId),
                   arraysize(kFakeKeyId)),
       std::string(reinterpret_cast<const char*>(kFakeIv), arraysize(kFakeIv)),
diff --git a/media/filters/fake_demuxer_stream.cc b/media/filters/fake_demuxer_stream.cc
index e64ecbd..200b287 100644
--- a/media/filters/fake_demuxer_stream.cc
+++ b/media/filters/fake_demuxer_stream.cc
@@ -142,6 +142,8 @@ void FakeDemuxerStream::DoRead() {
       video_decoder_config_, current_timestamp_, duration_);
 
   // TODO(xhwang): Output out-of-order buffers if needed.
+  buffer->set_timestamp(current_timestamp_);
+  buffer->set_duration(duration_);
   current_timestamp_ += duration_;
 
   num_buffers_left_in_current_config_--;
diff --git a/media/filters/fake_demuxer_stream_unittest.cc b/media/filters/fake_demuxer_stream_unittest.cc
index d232bd1..553a2f0 100644
--- a/media/filters/fake_demuxer_stream_unittest.cc
+++ b/media/filters/fake_demuxer_stream_unittest.cc
@@ -62,7 +62,7 @@ class FakeDemuxerStreamTest : public testing::Test {
         EXPECT_FALSE(read_pending_);
         EXPECT_EQ(DemuxerStream::kOk, status_);
         ASSERT_TRUE(buffer_.get());
-        EXPECT_FALSE(buffer_->IsEndOfStream());
+        EXPECT_FALSE(buffer_->end_of_stream());
         break;
 
       case ABORTED:
@@ -81,7 +81,7 @@ class FakeDemuxerStreamTest : public testing::Test {
         EXPECT_FALSE(read_pending_);
         EXPECT_EQ(DemuxerStream::kOk, status_);
         ASSERT_TRUE(buffer_.get());
-        EXPECT_TRUE(buffer_->IsEndOfStream());
+        EXPECT_TRUE(buffer_->end_of_stream());
         break;
 
       case PENDING:
diff --git a/media/filters/fake_video_decoder.cc b/media/filters/fake_video_decoder.cc
index 7f7173c..fb59ba1 100644
--- a/media/filters/fake_video_decoder.cc
+++ b/media/filters/fake_video_decoder.cc
@@ -54,19 +54,19 @@ void FakeVideoDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
   DCHECK(reset_cb_.IsNull());
   DCHECK_LE(decoded_frames_.size(), static_cast<size_t>(decoding_delay_));
 
-  int buffer_size = buffer->IsEndOfStream() ? 0 : buffer->GetDataSize();
+  int buffer_size = buffer->end_of_stream() ? 0 : buffer->data_size();
   read_cb_.SetCallback(BindToCurrentLoop(base::Bind(
       &FakeVideoDecoder::OnFrameDecoded, weak_this_, buffer_size, read_cb)));
 
-  if (buffer->IsEndOfStream() && decoded_frames_.empty()) {
+  if (buffer->end_of_stream() && decoded_frames_.empty()) {
     read_cb_.RunOrHold(kOk, VideoFrame::CreateEmptyFrame());
     return;
   }
 
-  if (!buffer->IsEndOfStream()) {
+  if (!buffer->end_of_stream()) {
     DCHECK(VerifyFakeVideoBufferForTest(buffer, current_config_));
     scoped_refptr<VideoFrame> video_frame = VideoFrame::CreateColorFrame(
-        current_config_.coded_size(), 0, 0, 0, buffer->GetTimestamp());
+        current_config_.coded_size(), 0, 0, 0, buffer->timestamp());
     decoded_frames_.push_back(video_frame);
 
     if (decoded_frames_.size() <= static_cast<size_t>(decoding_delay_)) {
diff --git a/media/filters/ffmpeg_audio_decoder.cc b/media/filters/ffmpeg_audio_decoder.cc
index 8f5156d..3d68b79 100644
--- a/media/filters/ffmpeg_audio_decoder.cc
+++ b/media/filters/ffmpeg_audio_decoder.cc
@@ -29,13 +29,14 @@ struct QueuedAudioBuffer {
 };
 
 // Returns true if the decode result was end of stream.
-static inline bool IsEndOfStream(int result, int decoded_size,
+static inline bool IsEndOfStream(int result,
+                                 int decoded_size,
                                  const scoped_refptr<DecoderBuffer>& input) {
   // Three conditions to meet to declare end of stream for this decoder:
   // 1. FFmpeg didn't read anything.
   // 2. FFmpeg didn't output anything.
   // 3. An end of stream buffer is received.
-  return result == 0 && decoded_size == 0 && input->IsEndOfStream();
+  return result == 0 && decoded_size == 0 && input->end_of_stream();
 }
 
 FFmpegAudioDecoder::FFmpegAudioDecoder(
@@ -184,7 +185,7 @@ void FFmpegAudioDecoder::BufferReady(
 
   // Make sure we are notified if http://crbug.com/49709 returns.  Issue also
   // occurs with some damaged files.
-  if (!input->IsEndOfStream() && input->GetTimestamp() == kNoTimestamp() &&
+  if (!input->end_of_stream() && input->timestamp() == kNoTimestamp() &&
       output_timestamp_helper_->base_timestamp() == kNoTimestamp()) {
     DVLOG(1) << "Received a buffer without timestamps!";
     base::ResetAndReturn(&read_cb_).Run(kDecodeError, NULL);
@@ -192,27 +193,27 @@ void FFmpegAudioDecoder::BufferReady(
   }
 
   bool is_vorbis = codec_context_->codec_id == AV_CODEC_ID_VORBIS;
-  if (!input->IsEndOfStream()) {
+  if (!input->end_of_stream()) {
     if (last_input_timestamp_ == kNoTimestamp()) {
-      if (is_vorbis && (input->GetTimestamp() < base::TimeDelta())) {
+      if (is_vorbis && (input->timestamp() < base::TimeDelta())) {
         // Dropping frames for negative timestamps as outlined in section A.2
         // in the Vorbis spec. http://xiph.org/vorbis/doc/Vorbis_I_spec.html
         output_frames_to_drop_ = floor(
-            0.5 + -input->GetTimestamp().InSecondsF() * samples_per_second_);
+            0.5 + -input->timestamp().InSecondsF() * samples_per_second_);
       } else {
-        last_input_timestamp_ = input->GetTimestamp();
+        last_input_timestamp_ = input->timestamp();
       }
-    } else if (input->GetTimestamp() != kNoTimestamp()) {
-      if (input->GetTimestamp() < last_input_timestamp_) {
-        base::TimeDelta diff = input->GetTimestamp() - last_input_timestamp_;
+    } else if (input->timestamp() != kNoTimestamp()) {
+      if (input->timestamp() < last_input_timestamp_) {
+        base::TimeDelta diff = input->timestamp() - last_input_timestamp_;
         DVLOG(1) << "Input timestamps are not monotonically increasing! "
-                 << " ts " << input->GetTimestamp().InMicroseconds() << " us"
+                 << " ts " << input->timestamp().InMicroseconds() << " us"
                  << " diff " << diff.InMicroseconds() << " us";
         base::ResetAndReturn(&read_cb_).Run(kDecodeError, NULL);
         return;
       }
 
-      last_input_timestamp_ = input->GetTimestamp();
+      last_input_timestamp_ = input->timestamp();
     }
   }
 
@@ -317,12 +318,12 @@ void FFmpegAudioDecoder::RunDecodeLoop(
     bool skip_eos_append) {
   AVPacket packet;
   av_init_packet(&packet);
-  if (input->IsEndOfStream()) {
+  if (input->end_of_stream()) {
     packet.data = NULL;
     packet.size = 0;
   } else {
-    packet.data = const_cast<uint8*>(input->GetData());
-    packet.size = input->GetDataSize();
+    packet.data = const_cast<uint8*>(input->data());
+    packet.size = input->data_size();
   }
 
   // Each audio packet may contain several frames, so we must call the decoder
@@ -338,16 +339,16 @@ void FFmpegAudioDecoder::RunDecodeLoop(
         codec_context_, av_frame_, &frame_decoded, &packet);
 
     if (result < 0) {
-      DCHECK(!input->IsEndOfStream())
+      DCHECK(!input->end_of_stream())
           << "End of stream buffer produced an error! "
           << "This is quite possibly a bug in the audio decoder not handling "
           << "end of stream AVPackets correctly.";
 
       DLOG(ERROR)
           << "Error decoding an audio frame with timestamp: "
-          << input->GetTimestamp().InMicroseconds() << " us, duration: "
-          << input->GetDuration().InMicroseconds() << " us, packet size: "
-          << input->GetDataSize() << " bytes";
+          << input->timestamp().InMicroseconds() << " us, duration: "
+          << input->duration().InMicroseconds() << " us, packet size: "
+          << input->data_size() << " bytes";
 
       // TODO(dalecurtis): We should return a kDecodeError here instead:
       // http://crbug.com/145276
@@ -360,15 +361,15 @@ void FFmpegAudioDecoder::RunDecodeLoop(
     packet.data += result;
 
     if (output_timestamp_helper_->base_timestamp() == kNoTimestamp() &&
-        !input->IsEndOfStream()) {
-      DCHECK(input->GetTimestamp() != kNoTimestamp());
+        !input->end_of_stream()) {
+      DCHECK(input->timestamp() != kNoTimestamp());
       if (output_frames_to_drop_ > 0) {
         // Currently Vorbis is the only codec that causes us to drop samples.
         // If we have to drop samples it always means the timeline starts at 0.
         DCHECK_EQ(codec_context_->codec_id, AV_CODEC_ID_VORBIS);
         output_timestamp_helper_->SetBaseTimestamp(base::TimeDelta());
       } else {
-        output_timestamp_helper_->SetBaseTimestamp(input->GetTimestamp());
+        output_timestamp_helper_->SetBaseTimestamp(input->timestamp());
       }
     }
 
diff --git a/media/filters/ffmpeg_audio_decoder_unittest.cc b/media/filters/ffmpeg_audio_decoder_unittest.cc
index 3112819..c19bbab 100644
--- a/media/filters/ffmpeg_audio_decoder_unittest.cc
+++ b/media/filters/ffmpeg_audio_decoder_unittest.cc
@@ -41,12 +41,12 @@ class FFmpegAudioDecoderTest : public testing::Test {
           ReadTestDataFile(base::StringPrintf("vorbis-packet-%d", i));
 
       if (i < 3) {
-        buffer->SetTimestamp(base::TimeDelta());
+        buffer->set_timestamp(base::TimeDelta());
       } else {
-        buffer->SetTimestamp(base::TimeDelta::FromMicroseconds(2902));
+        buffer->set_timestamp(base::TimeDelta::FromMicroseconds(2902));
       }
 
-      buffer->SetDuration(base::TimeDelta());
+      buffer->set_duration(base::TimeDelta());
       encoded_audio_.push_back(buffer);
     }
 
@@ -61,8 +61,8 @@ class FFmpegAudioDecoderTest : public testing::Test {
                               kSampleFormatPlanarF32,
                               CHANNEL_LAYOUT_STEREO,
                               44100,
-                              vorbis_extradata_->GetData(),
-                              vorbis_extradata_->GetDataSize(),
+                              vorbis_extradata_->data(),
+                              vorbis_extradata_->data_size(),
                               false);  // Not encrypted.
     demuxer_->set_audio_decoder_config(config);
     decoder_->Initialize(demuxer_.get(),
diff --git a/media/filters/ffmpeg_demuxer.cc b/media/filters/ffmpeg_demuxer.cc
index 87a2c2d..451ca65 100644
--- a/media/filters/ffmpeg_demuxer.cc
+++ b/media/filters/ffmpeg_demuxer.cc
@@ -137,20 +137,20 @@ void FFmpegDemuxerStream::EnqueuePacket(ScopedAVPacket packet) {
         encryption_key_id_.size()));
     if (!config)
       LOG(ERROR) << "Creation of DecryptConfig failed.";
-    buffer->SetDecryptConfig(config.Pass());
+    buffer->set_decrypt_config(config.Pass());
   }
 
-  buffer->SetTimestamp(ConvertStreamTimestamp(
+  buffer->set_timestamp(ConvertStreamTimestamp(
       stream_->time_base, packet->pts));
-  buffer->SetDuration(ConvertStreamTimestamp(
+  buffer->set_duration(ConvertStreamTimestamp(
       stream_->time_base, packet->duration));
-  if (buffer->GetTimestamp() != kNoTimestamp() &&
+  if (buffer->timestamp() != kNoTimestamp() &&
       last_packet_timestamp_ != kNoTimestamp() &&
-      last_packet_timestamp_ < buffer->GetTimestamp()) {
-    buffered_ranges_.Add(last_packet_timestamp_, buffer->GetTimestamp());
+      last_packet_timestamp_ < buffer->timestamp()) {
+    buffered_ranges_.Add(last_packet_timestamp_, buffer->timestamp());
     demuxer_->NotifyBufferingChanged();
   }
-  last_packet_timestamp_ = buffer->GetTimestamp();
+  last_packet_timestamp_ = buffer->timestamp();
 
   buffer_queue_.Push(buffer);
   SatisfyPendingRead();
diff --git a/media/filters/ffmpeg_demuxer_unittest.cc b/media/filters/ffmpeg_demuxer_unittest.cc
index 163ad98..1860c90 100644
--- a/media/filters/ffmpeg_demuxer_unittest.cc
+++ b/media/filters/ffmpeg_demuxer_unittest.cc
@@ -36,7 +36,7 @@ namespace media {
 
 MATCHER(IsEndOfStreamBuffer,
         std::string(negation ? "isn't" : "is") + " end of stream") {
-  return arg->IsEndOfStream();
+  return arg->end_of_stream();
 }
 
 static void EosOnReadDone(bool* got_eos_buffer,
@@ -46,13 +46,13 @@ static void EosOnReadDone(bool* got_eos_buffer,
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 
   EXPECT_EQ(status, DemuxerStream::kOk);
-  if (buffer->IsEndOfStream()) {
+  if (buffer->end_of_stream()) {
     *got_eos_buffer = true;
     return;
   }
 
-  EXPECT_TRUE(buffer->GetData());
-  EXPECT_GT(buffer->GetDataSize(), 0);
+  EXPECT_TRUE(buffer->data());
+  EXPECT_GT(buffer->data_size(), 0);
   *got_eos_buffer = false;
 };
 
@@ -111,9 +111,9 @@ class FFmpegDemuxerTest : public testing::Test {
     EXPECT_EQ(status, DemuxerStream::kOk);
     OnReadDoneCalled(size, timestampInMicroseconds);
     EXPECT_TRUE(buffer.get() != NULL);
-    EXPECT_EQ(size, buffer->GetDataSize());
+    EXPECT_EQ(size, buffer->data_size());
     EXPECT_EQ(base::TimeDelta::FromMicroseconds(timestampInMicroseconds),
-              buffer->GetTimestamp());
+              buffer->timestamp());
 
     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
     message_loop_.PostTask(FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
diff --git a/media/filters/ffmpeg_glue_unittest.cc b/media/filters/ffmpeg_glue_unittest.cc
index 18d56f9..605b319 100644
--- a/media/filters/ffmpeg_glue_unittest.cc
+++ b/media/filters/ffmpeg_glue_unittest.cc
@@ -78,7 +78,7 @@ class FFmpegGlueDestructionTest : public ::testing::Test {
   void Initialize(const char* filename) {
     data_ = ReadTestDataFile(filename);
     protocol_.reset(new InMemoryUrlProtocol(
-        data_->GetData(), data_->GetDataSize(), false));
+        data_->data(), data_->data_size(), false));
     glue_.reset(new FFmpegGlue(protocol_.get()));
     CHECK(glue_->format_context());
     CHECK(glue_->format_context()->pb);
diff --git a/media/filters/ffmpeg_video_decoder.cc b/media/filters/ffmpeg_video_decoder.cc
index 54c6cc1..82891db 100644
--- a/media/filters/ffmpeg_video_decoder.cc
+++ b/media/filters/ffmpeg_video_decoder.cc
@@ -246,7 +246,7 @@ void FFmpegVideoDecoder::DecodeBuffer(
   // These are the possible state transitions.
   //
   // kNormal -> kFlushCodec:
-  //     When buffer->IsEndOfStream() is first true.
+  //     When buffer->end_of_stream() is first true.
   // kNormal -> kError:
   //     A decoding error occurs and decoding needs to stop.
   // kFlushCodec -> kDecodeFinished:
@@ -257,7 +257,7 @@ void FFmpegVideoDecoder::DecodeBuffer(
   //     Any time Reset() is called.
 
   // Transition to kFlushCodec on the first end of stream buffer.
-  if (state_ == kNormal && buffer->IsEndOfStream()) {
+  if (state_ == kNormal && buffer->end_of_stream()) {
     state_ = kFlushCodec;
   }
 
@@ -270,7 +270,7 @@ void FFmpegVideoDecoder::DecodeBuffer(
 
   if (!video_frame.get()) {
     if (state_ == kFlushCodec) {
-      DCHECK(buffer->IsEndOfStream());
+      DCHECK(buffer->end_of_stream());
       state_ = kDecodeFinished;
       base::ResetAndReturn(&read_cb_).Run(kOk, VideoFrame::CreateEmptyFrame());
       return;
@@ -295,15 +295,15 @@ bool FFmpegVideoDecoder::FFmpegDecode(
   // Due to FFmpeg API changes we no longer have const read-only pointers.
   AVPacket packet;
   av_init_packet(&packet);
-  if (buffer->IsEndOfStream()) {
+  if (buffer->end_of_stream()) {
     packet.data = NULL;
     packet.size = 0;
   } else {
-    packet.data = const_cast<uint8*>(buffer->GetData());
-    packet.size = buffer->GetDataSize();
+    packet.data = const_cast<uint8*>(buffer->data());
+    packet.size = buffer->data_size();
 
     // Let FFmpeg handle presentation timestamp reordering.
-    codec_context_->reordered_opaque = buffer->GetTimestamp().InMicroseconds();
+    codec_context_->reordered_opaque = buffer->timestamp().InMicroseconds();
 
     // This is for codecs not using get_buffer to initialize
     // |av_frame_->reordered_opaque|
diff --git a/media/filters/gpu_video_decoder.cc b/media/filters/gpu_video_decoder.cc
index dbb1e9b..349ebeb 100644
--- a/media/filters/gpu_video_decoder.cc
+++ b/media/filters/gpu_video_decoder.cc
@@ -352,7 +352,7 @@ void GpuVideoDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
     case kNormal:
       break;
     case kDrainingDecoder:
-      DCHECK(buffer->IsEndOfStream());
+      DCHECK(buffer->end_of_stream());
       // Do nothing.  Will be satisfied either by a PictureReady or
       // NotifyFlushDone below.
       return;
@@ -361,7 +361,7 @@ void GpuVideoDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
       return;
   }
 
-  if (buffer->IsEndOfStream()) {
+  if (buffer->end_of_stream()) {
     if (state_ == kNormal) {
       state_ = kDrainingDecoder;
       vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
@@ -370,14 +370,14 @@ void GpuVideoDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
     return;
   }
 
-  size_t size = buffer->GetDataSize();
+  size_t size = buffer->data_size();
   SHMBuffer* shm_buffer = GetSHM(size);
   if (!shm_buffer) {
     base::ResetAndReturn(&pending_read_cb_).Run(kDecodeError, NULL);
     return;
   }
 
-  memcpy(shm_buffer->shm->memory(), buffer->GetData(), size);
+  memcpy(shm_buffer->shm->memory(), buffer->data(), size);
   BitstreamBuffer bitstream_buffer(
       next_bitstream_buffer_id_, shm_buffer->shm->handle(), size);
   // Mask against 30 bits, to avoid (undefined) wraparound on signed integer.
@@ -406,7 +406,7 @@ bool GpuVideoDecoder::CanMoreDecodeWorkBeDone() {
 void GpuVideoDecoder::RecordBufferData(const BitstreamBuffer& bitstream_buffer,
                                        const DecoderBuffer& buffer) {
   input_buffer_data_.push_front(BufferData(bitstream_buffer.id(),
-                                           buffer.GetTimestamp(),
+                                           buffer.timestamp(),
                                            config_.visible_rect(),
                                            config_.natural_size()));
   // Why this value?  Because why not.  avformat.h:MAX_REORDER_DELAY is 16, but
diff --git a/media/filters/opus_audio_decoder.cc b/media/filters/opus_audio_decoder.cc
index f8afbdd..115799a 100644
--- a/media/filters/opus_audio_decoder.cc
+++ b/media/filters/opus_audio_decoder.cc
@@ -36,7 +36,7 @@ static inline bool IsEndOfStream(int decoded_size,
   // Two conditions to meet to declare end of stream for this decoder:
   // 1. Opus didn't output anything.
   // 2. An end of stream buffer is received.
-  return decoded_size == 0 && input->IsEndOfStream();
+  return decoded_size == 0 && input->end_of_stream();
 }
 
 // The Opus specification is part of IETF RFC 6716:
@@ -356,14 +356,14 @@ void OpusAudioDecoder::BufferReady(
 
   // Libopus does not buffer output. Decoding is complete when an end of stream
   // input buffer is received.
-  if (input->IsEndOfStream()) {
+  if (input->end_of_stream()) {
     base::ResetAndReturn(&read_cb_).Run(kOk, AudioBuffer::CreateEOSBuffer());
     return;
   }
 
   // Make sure we are notified if http://crbug.com/49709 returns.  Issue also
   // occurs with some damaged files.
-  if (input->GetTimestamp() == kNoTimestamp() &&
+  if (input->timestamp() == kNoTimestamp() &&
       output_timestamp_helper_->base_timestamp() == kNoTimestamp()) {
     DVLOG(1) << "Received a buffer without timestamps!";
     base::ResetAndReturn(&read_cb_).Run(kDecodeError, NULL);
@@ -371,17 +371,17 @@ void OpusAudioDecoder::BufferReady(
   }
 
   if (last_input_timestamp_ != kNoTimestamp() &&
-      input->GetTimestamp() != kNoTimestamp() &&
-      input->GetTimestamp() < last_input_timestamp_) {
-    base::TimeDelta diff = input->GetTimestamp() - last_input_timestamp_;
+      input->timestamp() != kNoTimestamp() &&
+      input->timestamp() < last_input_timestamp_) {
+    base::TimeDelta diff = input->timestamp() - last_input_timestamp_;
     DVLOG(1) << "Input timestamps are not monotonically increasing! "
-              << " ts " << input->GetTimestamp().InMicroseconds() << " us"
+              << " ts " << input->timestamp().InMicroseconds() << " us"
               << " diff " << diff.InMicroseconds() << " us";
     base::ResetAndReturn(&read_cb_).Run(kDecodeError, NULL);
     return;
   }
 
-  last_input_timestamp_ = input->GetTimestamp();
+  last_input_timestamp_ = input->timestamp();
 
   scoped_refptr<AudioBuffer> output_buffer;
 
@@ -514,16 +514,16 @@ void OpusAudioDecoder::ResetTimestampState() {
 bool OpusAudioDecoder::Decode(const scoped_refptr<DecoderBuffer>& input,
                               scoped_refptr<AudioBuffer>* output_buffer) {
   int samples_decoded = opus_multistream_decode(opus_decoder_,
-                                                input->GetData(),
-                                                input->GetDataSize(),
+                                                input->data(),
+                                                input->data_size(),
                                                 &output_buffer_[0],
                                                 kMaxOpusOutputPacketSizeSamples,
                                                 0);
   if (samples_decoded < 0) {
     LOG(ERROR) << "opus_multistream_decode failed for"
-               << " timestamp: " << input->GetTimestamp().InMicroseconds()
-               << " us, duration: " << input->GetDuration().InMicroseconds()
-               << " us, packet size: " << input->GetDataSize() << " bytes with"
+               << " timestamp: " << input->timestamp().InMicroseconds()
+               << " us, duration: " << input->duration().InMicroseconds()
+               << " us, packet size: " << input->data_size() << " bytes with"
                << " status: " << opus_strerror(samples_decoded);
     return false;
   }
@@ -534,9 +534,9 @@ bool OpusAudioDecoder::Decode(const scoped_refptr<DecoderBuffer>& input,
   DCHECK_LE(decoded_audio_size, kMaxOpusOutputPacketSizeBytes);
 
   if (output_timestamp_helper_->base_timestamp() == kNoTimestamp() &&
-      !input->IsEndOfStream()) {
-    DCHECK(input->GetTimestamp() != kNoTimestamp());
-    output_timestamp_helper_->SetBaseTimestamp(input->GetTimestamp());
+      !input->end_of_stream()) {
+    DCHECK(input->timestamp() != kNoTimestamp());
+    output_timestamp_helper_->SetBaseTimestamp(input->timestamp());
   }
 
   if (decoded_audio_size > 0 && output_bytes_to_drop_ > 0) {
diff --git a/media/filters/pipeline_integration_test.cc b/media/filters/pipeline_integration_test.cc
index 9ccfed3..59e714f 100644
--- a/media/filters/pipeline_integration_test.cc
+++ b/media/filters/pipeline_integration_test.cc
@@ -221,10 +221,10 @@ class MockMediaSource {
     file_data_ = ReadTestDataFile(filename);
 
     if (initial_append_size_ == kAppendWholeFile)
-      initial_append_size_ = file_data_->GetDataSize();
+      initial_append_size_ = file_data_->data_size();
 
     DCHECK_GT(initial_append_size_, 0);
-    DCHECK_LE(initial_append_size_, file_data_->GetDataSize());
+    DCHECK_LE(initial_append_size_, file_data_->data_size());
   }
 
   virtual ~MockMediaSource() {}
@@ -241,7 +241,7 @@ class MockMediaSource {
     chunk_demuxer_->Abort(kSourceId);
 
     DCHECK_GE(new_position, 0);
-    DCHECK_LT(new_position, file_data_->GetDataSize());
+    DCHECK_LT(new_position, file_data_->data_size());
     current_position_ = new_position;
 
     AppendData(seek_append_size);
@@ -249,10 +249,10 @@ class MockMediaSource {
 
   void AppendData(int size) {
     DCHECK(chunk_demuxer_);
-    DCHECK_LT(current_position_, file_data_->GetDataSize());
-    DCHECK_LE(current_position_ + size, file_data_->GetDataSize());
+    DCHECK_LT(current_position_, file_data_->data_size());
+    DCHECK_LE(current_position_ + size, file_data_->data_size());
     chunk_demuxer_->AppendData(
-        kSourceId, file_data_->GetData() + current_position_, size);
+        kSourceId, file_data_->data() + current_position_, size);
     current_position_ += size;
   }
 
@@ -500,7 +500,7 @@ TEST_F(PipelineIntegrationTest, MediaSource_ConfigChange_WebM) {
       ReadTestDataFile("bear-640x360.webm");
 
   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
-                      second_file->GetData(), second_file->GetDataSize());
+                      second_file->data(), second_file->data_size());
 
   source.EndOfStream();
 
@@ -526,7 +526,7 @@ TEST_F(PipelineIntegrationTest, MediaSource_ConfigChange_Encrypted_WebM) {
       ReadTestDataFile("bear-640x360-av_enc-av.webm");
 
   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
-                      second_file->GetData(), second_file->GetDataSize());
+                      second_file->data(), second_file->data_size());
 
   source.EndOfStream();
 
@@ -554,7 +554,7 @@ TEST_F(PipelineIntegrationTest,
       ReadTestDataFile("bear-640x360-av_enc-av.webm");
 
   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
-                      second_file->GetData(), second_file->GetDataSize());
+                      second_file->data(), second_file->data_size());
 
   source.EndOfStream();
 
@@ -585,7 +585,7 @@ TEST_F(PipelineIntegrationTest,
       ReadTestDataFile("bear-640x360.webm");
 
   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
-                      second_file->GetData(), second_file->GetDataSize());
+                      second_file->data(), second_file->data_size());
 
   source.EndOfStream();
 
@@ -610,7 +610,7 @@ TEST_F(PipelineIntegrationTest, MediaSource_ConfigChange_MP4) {
       ReadTestDataFile("bear-1280x720-av_frag.mp4");
 
   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
-                      second_file->GetData(), second_file->GetDataSize());
+                      second_file->data(), second_file->data_size());
 
   source.EndOfStream();
 
@@ -637,7 +637,7 @@ TEST_F(PipelineIntegrationTest,
       ReadTestDataFile("bear-1280x720-v_frag-cenc.mp4");
 
   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
-                      second_file->GetData(), second_file->GetDataSize());
+                      second_file->data(), second_file->data_size());
 
   source.EndOfStream();
 
@@ -666,7 +666,7 @@ TEST_F(PipelineIntegrationTest,
       ReadTestDataFile("bear-1280x720-v_frag-cenc.mp4");
 
   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
-                      second_file->GetData(), second_file->GetDataSize());
+                      second_file->data(), second_file->data_size());
 
   source.EndOfStream();
 
@@ -697,7 +697,7 @@ TEST_F(PipelineIntegrationTest,
       ReadTestDataFile("bear-1280x720-av_frag.mp4");
 
   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
-                      second_file->GetData(), second_file->GetDataSize());
+                      second_file->data(), second_file->data_size());
 
   source.EndOfStream();
 
diff --git a/media/filters/source_buffer_stream.cc b/media/filters/source_buffer_stream.cc
index de67c8a5..2b96b36 100644
--- a/media/filters/source_buffer_stream.cc
+++ b/media/filters/source_buffer_stream.cc
@@ -1345,7 +1345,7 @@ void SourceBufferRange::AppendBuffersToEnd(const BufferQueue& new_buffers) {
        itr != new_buffers.end(); ++itr) {
     DCHECK((*itr)->GetDecodeTimestamp() != kNoTimestamp());
     buffers_.push_back(*itr);
-    size_in_bytes_ += (*itr)->GetDataSize();
+    size_in_bytes_ += (*itr)->data_size();
 
     if ((*itr)->IsKeyframe()) {
       keyframe_map_.insert(
@@ -1502,7 +1502,7 @@ int SourceBufferRange::DeleteGOPFromFront(BufferQueue* deleted_buffers) {
   // Delete buffers from the beginning of the buffered range up until (but not
   // including) the next keyframe.
   for (int i = 0; i < end_index; i++) {
-    int bytes_deleted = buffers_.front()->GetDataSize();
+    int bytes_deleted = buffers_.front()->data_size();
     size_in_bytes_ -= bytes_deleted;
     total_bytes_deleted += bytes_deleted;
     deleted_buffers->push_back(buffers_.front());
@@ -1542,7 +1542,7 @@ int SourceBufferRange::DeleteGOPFromBack(BufferQueue* deleted_buffers) {
 
   int total_bytes_deleted = 0;
   while (buffers_.size() != goal_size) {
-    int bytes_deleted = buffers_.back()->GetDataSize();
+    int bytes_deleted = buffers_.back()->data_size();
     size_in_bytes_ -= bytes_deleted;
     total_bytes_deleted += bytes_deleted;
     // We're removing buffers from the back, so push each removed buffer to the
@@ -1586,7 +1586,7 @@ void SourceBufferRange::FreeBufferRange(
     const BufferQueue::iterator& ending_point) {
   for (BufferQueue::iterator itr = starting_point;
        itr != ending_point; ++itr) {
-    size_in_bytes_ -= (*itr)->GetDataSize();
+    size_in_bytes_ -= (*itr)->data_size();
     DCHECK_GE(size_in_bytes_, 0);
   }
   buffers_.erase(starting_point, ending_point);
@@ -1729,7 +1729,7 @@ base::TimeDelta SourceBufferRange::GetEndTimestamp() const {
 
 base::TimeDelta SourceBufferRange::GetBufferedEndTimestamp() const {
   DCHECK(!buffers_.empty());
-  base::TimeDelta duration = buffers_.back()->GetDuration();
+  base::TimeDelta duration = buffers_.back()->duration();
   if (duration == kNoTimestamp() || duration == base::TimeDelta())
     duration = GetApproximateDuration();
   return GetEndTimestamp() + duration;
diff --git a/media/filters/source_buffer_stream_unittest.cc b/media/filters/source_buffer_stream_unittest.cc
index be0cd75..fbfe658 100644
--- a/media/filters/source_buffer_stream_unittest.cc
+++ b/media/filters/source_buffer_stream_unittest.cc
@@ -176,8 +176,8 @@ class SourceBufferStreamTest : public testing::Test {
         EXPECT_TRUE(buffer->IsKeyframe());
 
       if (expected_data) {
-        const uint8* actual_data = buffer->GetData();
-        const int actual_size = buffer->GetDataSize();
+        const uint8* actual_data = buffer->data();
+        const int actual_size = buffer->data_size();
         EXPECT_EQ(expected_size, actual_size);
         for (int i = 0; i < std::min(actual_size, expected_size); i++) {
           EXPECT_EQ(expected_data[i], actual_data[i]);
@@ -273,7 +273,7 @@ class SourceBufferStreamTest : public testing::Test {
       } else {
         presentation_timestamp = timestamp - frame_duration_;
       }
-      buffer->SetTimestamp(presentation_timestamp);
+      buffer->set_timestamp(presentation_timestamp);
 
       queue.push_back(buffer);
     }
@@ -1975,18 +1975,18 @@ TEST_F(SourceBufferStreamTest, PresentationTimestampIndependence) {
     ASSERT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kSuccess);
 
     if (buffer->IsKeyframe()) {
-      EXPECT_EQ(buffer->GetTimestamp(), buffer->GetDecodeTimestamp());
+      EXPECT_EQ(buffer->timestamp(), buffer->GetDecodeTimestamp());
       last_keyframe_idx = i;
-      last_keyframe_presentation_timestamp = buffer->GetTimestamp();
+      last_keyframe_presentation_timestamp = buffer->timestamp();
     } else if (i == last_keyframe_idx + 1) {
       ASSERT_NE(last_keyframe_idx, -1);
-      last_p_frame_presentation_timestamp = buffer->GetTimestamp();
+      last_p_frame_presentation_timestamp = buffer->timestamp();
       EXPECT_LT(last_keyframe_presentation_timestamp,
                 last_p_frame_presentation_timestamp);
     } else {
-      EXPECT_GT(buffer->GetTimestamp(), last_keyframe_presentation_timestamp);
-      EXPECT_LT(buffer->GetTimestamp(), last_p_frame_presentation_timestamp);
-      EXPECT_LT(buffer->GetTimestamp(), buffer->GetDecodeTimestamp());
+      EXPECT_GT(buffer->timestamp(), last_keyframe_presentation_timestamp);
+      EXPECT_LT(buffer->timestamp(), last_p_frame_presentation_timestamp);
+      EXPECT_LT(buffer->timestamp(), buffer->GetDecodeTimestamp());
     }
   }
 }
diff --git a/media/filters/video_frame_stream.cc b/media/filters/video_frame_stream.cc
index 3d04106..3802776 100644
--- a/media/filters/video_frame_stream.cc
+++ b/media/filters/video_frame_stream.cc
@@ -205,7 +205,7 @@ void VideoFrameStream::Decode(const scoped_refptr<DecoderBuffer>& buffer) {
   DCHECK(stop_cb_.is_null());
   DCHECK(buffer);
 
-  int buffer_size = buffer->IsEndOfStream() ? 0 : buffer->GetDataSize();
+  int buffer_size = buffer->end_of_stream() ? 0 : buffer->data_size();
   decoder_->Decode(buffer, base::Bind(&VideoFrameStream::OnFrameReady,
                                       weak_this_, buffer_size));
 }
diff --git a/media/filters/video_frame_stream_unittest.cc b/media/filters/video_frame_stream_unittest.cc
index 3a2e726..62647b1 100644
--- a/media/filters/video_frame_stream_unittest.cc
+++ b/media/filters/video_frame_stream_unittest.cc
@@ -88,9 +88,9 @@ class VideoFrameStreamTest : public testing::TestWithParam<bool> {
                const Decryptor::DecryptCB& decrypt_cb) {
     DCHECK_EQ(stream_type, Decryptor::kVideo);
     scoped_refptr<DecoderBuffer> decrypted = DecoderBuffer::CopyFrom(
-        encrypted->GetData(), encrypted->GetDataSize());
-    decrypted->SetTimestamp(encrypted->GetTimestamp());
-    decrypted->SetDuration(encrypted->GetDuration());
+        encrypted->data(), encrypted->data_size());
+    decrypted->set_timestamp(encrypted->timestamp());
+    decrypted->set_duration(encrypted->duration());
     decrypt_cb.Run(Decryptor::kSuccess, decrypted);
   }
 
diff --git a/media/filters/vpx_video_decoder.cc b/media/filters/vpx_video_decoder.cc
index 7b8f011..9880eda 100644
--- a/media/filters/vpx_video_decoder.cc
+++ b/media/filters/vpx_video_decoder.cc
@@ -222,7 +222,7 @@ void VpxVideoDecoder::DecodeBuffer(const scoped_refptr<DecoderBuffer>& buffer) {
   DCHECK(buffer);
 
   // Transition to kDecodeFinished on the first end of stream buffer.
-  if (state_ == kNormal && buffer->IsEndOfStream()) {
+  if (state_ == kNormal && buffer->end_of_stream()) {
     state_ = kDecodeFinished;
     base::ResetAndReturn(&read_cb_).Run(kOk, VideoFrame::CreateEmptyFrame());
     return;
@@ -235,6 +235,7 @@ void VpxVideoDecoder::DecodeBuffer(const scoped_refptr<DecoderBuffer>& buffer) {
     return;
   }
 
+  // If we didn't get a frame we need more data.
   if (!video_frame.get()) {
     base::ResetAndReturn(&read_cb_).Run(kNotEnoughData, NULL);
     return;
@@ -246,14 +247,14 @@ void VpxVideoDecoder::DecodeBuffer(const scoped_refptr<DecoderBuffer>& buffer) {
 bool VpxVideoDecoder::VpxDecode(const scoped_refptr<DecoderBuffer>& buffer,
                                 scoped_refptr<VideoFrame>* video_frame) {
   DCHECK(video_frame);
-  DCHECK(!buffer->IsEndOfStream());
+  DCHECK(!buffer->end_of_stream());
 
   // Pass |buffer| to libvpx.
-  int64 timestamp = buffer->GetTimestamp().InMicroseconds();
+  int64 timestamp = buffer->timestamp().InMicroseconds();
   void* user_priv = reinterpret_cast<void*>(&timestamp);
   vpx_codec_err_t status = vpx_codec_decode(vpx_codec_,
-                                            buffer->GetData(),
-                                            buffer->GetDataSize(),
+                                            buffer->data(),
+                                            buffer->data_size(),
                                             user_priv,
                                             0);
   if (status != VPX_CODEC_OK) {
@@ -275,18 +276,18 @@ bool VpxVideoDecoder::VpxDecode(const scoped_refptr<DecoderBuffer>& buffer,
   }
 
   const vpx_image_t* vpx_image_alpha = NULL;
-  if (vpx_codec_alpha_ && buffer->GetSideDataSize() >= 8) {
+  if (vpx_codec_alpha_ && buffer->side_data_size() >= 8) {
     // Pass alpha data to libvpx.
-    int64 timestamp_alpha = buffer->GetTimestamp().InMicroseconds();
+    int64 timestamp_alpha = buffer->timestamp().InMicroseconds();
     void* user_priv_alpha = reinterpret_cast<void*>(&timestamp_alpha);
 
     // First 8 bytes of side data is side_data_id in big endian.
     const uint64 side_data_id = base::NetToHost64(
-        *(reinterpret_cast<const uint64*>(buffer->GetSideData())));
+        *(reinterpret_cast<const uint64*>(buffer->side_data())));
     if (side_data_id == 1) {
       status = vpx_codec_decode(vpx_codec_alpha_,
-                                buffer->GetSideData() + 8,
-                                buffer->GetSideDataSize() - 8,
+                                buffer->side_data() + 8,
+                                buffer->side_data_size() - 8,
                                 user_priv_alpha,
                                 0);
 
diff --git a/media/mp4/mp4_stream_parser.cc b/media/mp4/mp4_stream_parser.cc
index 3d85509..56b340a 100644
--- a/media/mp4/mp4_stream_parser.cc
+++ b/media/mp4/mp4_stream_parser.cc
@@ -509,10 +509,10 @@ bool MP4StreamParser::EnqueueSample(BufferQueue* audio_buffers,
                                  runs_->is_keyframe());
 
   if (decrypt_config)
-    stream_buf->SetDecryptConfig(decrypt_config.Pass());
+    stream_buf->set_decrypt_config(decrypt_config.Pass());
 
-  stream_buf->SetDuration(runs_->duration());
-  stream_buf->SetTimestamp(runs_->cts());
+  stream_buf->set_duration(runs_->duration());
+  stream_buf->set_timestamp(runs_->cts());
   stream_buf->SetDecodeTimestamp(runs_->dts());
 
   DVLOG(3) << "Pushing frame: aud=" << audio
diff --git a/media/mp4/mp4_stream_parser_unittest.cc b/media/mp4/mp4_stream_parser_unittest.cc
index c271a80..07697a5 100644
--- a/media/mp4/mp4_stream_parser_unittest.cc
+++ b/media/mp4/mp4_stream_parser_unittest.cc
@@ -75,9 +75,9 @@ class MP4StreamParserTest : public testing::Test {
     for (StreamParser::BufferQueue::const_iterator buf = bufs.begin();
          buf != bufs.end(); buf++) {
       DVLOG(3) << "  n=" << buf - bufs.begin()
-               << ", size=" << (*buf)->GetDataSize()
-               << ", dur=" << (*buf)->GetDuration().InMilliseconds();
-      EXPECT_GE((*buf)->GetTimestamp(), segment_start_);
+               << ", size=" << (*buf)->data_size()
+               << ", dur=" << (*buf)->duration().InMilliseconds();
+      EXPECT_GE((*buf)->timestamp(), segment_start_);
     }
     return true;
   }
@@ -131,8 +131,8 @@ class MP4StreamParserTest : public testing::Test {
     InitializeParser();
 
     scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(filename);
-    EXPECT_TRUE(AppendDataInPieces(buffer->GetData(),
-                                   buffer->GetDataSize(),
+    EXPECT_TRUE(AppendDataInPieces(buffer->data(),
+                                   buffer->data_size(),
                                    append_bytes));
     return true;
   }
@@ -161,10 +161,10 @@ TEST_F(MP4StreamParserTest, TestFlush) {
 
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-1280x720-av_frag.mp4");
-  EXPECT_TRUE(AppendDataInPieces(buffer->GetData(), 65536, 512));
+  EXPECT_TRUE(AppendDataInPieces(buffer->data(), 65536, 512));
   parser_->Flush();
-  EXPECT_TRUE(AppendDataInPieces(buffer->GetData(),
-                                 buffer->GetDataSize(),
+  EXPECT_TRUE(AppendDataInPieces(buffer->data(),
+                                 buffer->data_size(),
                                  512));
 }
 
@@ -173,11 +173,11 @@ TEST_F(MP4StreamParserTest, TestReinitialization) {
 
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-1280x720-av_frag.mp4");
-  EXPECT_TRUE(AppendDataInPieces(buffer->GetData(),
-                                 buffer->GetDataSize(),
+  EXPECT_TRUE(AppendDataInPieces(buffer->data(),
+                                 buffer->data_size(),
                                  512));
-  EXPECT_TRUE(AppendDataInPieces(buffer->GetData(),
-                                 buffer->GetDataSize(),
+  EXPECT_TRUE(AppendDataInPieces(buffer->data(),
+                                 buffer->data_size(),
                                  512));
 }
 
@@ -194,14 +194,14 @@ TEST_F(MP4StreamParserTest, TestNoMoovAfterFlush) {
 
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-1280x720-av_frag.mp4");
-  EXPECT_TRUE(AppendDataInPieces(buffer->GetData(),
-                                 buffer->GetDataSize(),
+  EXPECT_TRUE(AppendDataInPieces(buffer->data(),
+                                 buffer->data_size(),
                                  512));
   parser_->Flush();
 
   const int kFirstMoofOffset = 1307;
-  EXPECT_TRUE(AppendDataInPieces(buffer->GetData() + kFirstMoofOffset,
-                                 buffer->GetDataSize() - kFirstMoofOffset,
+  EXPECT_TRUE(AppendDataInPieces(buffer->data() + kFirstMoofOffset,
+                                 buffer->data_size() - kFirstMoofOffset,
                                  512));
 }
 
diff --git a/media/tools/demuxer_bench/demuxer_bench.cc b/media/tools/demuxer_bench/demuxer_bench.cc
index 436becc..b828fd8 100644
--- a/media/tools/demuxer_bench/demuxer_bench.cc
+++ b/media/tools/demuxer_bench/demuxer_bench.cc
@@ -144,8 +144,8 @@ void StreamReader::OnReadDone(
     const scoped_refptr<media::DecoderBuffer>& buffer) {
   CHECK_EQ(status, media::DemuxerStream::kOk);
   CHECK(buffer.get());
-  *end_of_stream = buffer->IsEndOfStream();
-  *timestamp = *end_of_stream ? media::kNoTimestamp() : buffer->GetTimestamp();
+  *end_of_stream = buffer->end_of_stream();
+  *timestamp = *end_of_stream ? media::kNoTimestamp() : buffer->timestamp();
   message_loop->PostTask(FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }
 
diff --git a/media/tools/seek_tester/seek_tester.cc b/media/tools/seek_tester/seek_tester.cc
index 073558f..4826a51 100644
--- a/media/tools/seek_tester/seek_tester.cc
+++ b/media/tools/seek_tester/seek_tester.cc
@@ -46,10 +46,10 @@ void TimestampExtractor(uint64* timestamp_ms,
                         media::DemuxerStream::Status status,
                         const scoped_refptr<media::DecoderBuffer>& buffer) {
   CHECK_EQ(status, media::DemuxerStream::kOk);
-  if (buffer->GetTimestamp() == media::kNoTimestamp())
+  if (buffer->timestamp() == media::kNoTimestamp())
     *timestamp_ms = -1;
   else
-    *timestamp_ms = buffer->GetTimestamp().InMillisecondsF();
+    *timestamp_ms = buffer->timestamp().InMillisecondsF();
   loop->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
 }
 
diff --git a/media/webm/webm_cluster_parser.cc b/media/webm/webm_cluster_parser.cc
index 41e193f..f83a365 100644
--- a/media/webm/webm_cluster_parser.cc
+++ b/media/webm/webm_cluster_parser.cc
@@ -336,15 +336,15 @@ bool WebMClusterParser::OnBlock(bool is_simple_block, int track_num,
         encryption_key_id.size()));
     if (!config)
       return false;
-    buffer->SetDecryptConfig(config.Pass());
+    buffer->set_decrypt_config(config.Pass());
   }
 
-  buffer->SetTimestamp(timestamp);
+  buffer->set_timestamp(timestamp);
   if (cluster_start_time_ == kNoTimestamp())
     cluster_start_time_ = timestamp;
 
   if (block_duration >= 0) {
-    buffer->SetDuration(base::TimeDelta::FromMicroseconds(
+    buffer->set_duration(base::TimeDelta::FromMicroseconds(
         block_duration * timecode_multiplier_));
   }
 
@@ -361,10 +361,10 @@ WebMClusterParser::Track::~Track() {}
 bool WebMClusterParser::Track::AddBuffer(
     const scoped_refptr<StreamParserBuffer>& buffer) {
   DVLOG(2) << "AddBuffer() : " << track_num_
-           << " ts " << buffer->GetTimestamp().InSecondsF()
-           << " dur " << buffer->GetDuration().InSecondsF()
+           << " ts " << buffer->timestamp().InSecondsF()
+           << " dur " << buffer->duration().InSecondsF()
            << " kf " << buffer->IsKeyframe()
-           << " size " << buffer->GetDataSize();
+           << " size " << buffer->data_size();
 
   buffers_.push_back(buffer);
   return true;
diff --git a/media/webm/webm_cluster_parser_unittest.cc b/media/webm/webm_cluster_parser_unittest.cc
index cea97e5..0e8b7b2 100644
--- a/media/webm/webm_cluster_parser_unittest.cc
+++ b/media/webm/webm_cluster_parser_unittest.cc
@@ -117,13 +117,13 @@ static bool VerifyBuffers(const WebMClusterParser::BufferQueue& audio_buffers,
     scoped_refptr<StreamParserBuffer> buffer = (*buffers)[(*offset)++];
 
 
-    EXPECT_EQ(buffer->GetTimestamp().InMilliseconds(), block_info[i].timestamp);
+    EXPECT_EQ(buffer->timestamp().InMilliseconds(), block_info[i].timestamp);
 
     if (!block_info[i].use_simple_block)
-      EXPECT_NE(buffer->GetDuration(), kNoTimestamp());
+      EXPECT_NE(buffer->duration(), kNoTimestamp());
 
-    if (buffer->GetDuration() != kNoTimestamp())
-      EXPECT_EQ(buffer->GetDuration().InMilliseconds(), block_info[i].duration);
+    if (buffer->duration() != kNoTimestamp())
+      EXPECT_EQ(buffer->duration().InMilliseconds(), block_info[i].duration);
   }
 
   return true;
@@ -175,8 +175,8 @@ static bool VerifyTextBuffers(
     EXPECT_FALSE(buffer_iter == buffer_end);
 
     const scoped_refptr<StreamParserBuffer> buffer = *buffer_iter++;
-    EXPECT_EQ(buffer->GetTimestamp().InMilliseconds(), block_info.timestamp);
-    EXPECT_EQ(buffer->GetDuration().InMilliseconds(), block_info.duration);
+    EXPECT_EQ(buffer->timestamp().InMilliseconds(), block_info.timestamp);
+    EXPECT_EQ(buffer->duration().InMilliseconds(), block_info.duration);
   }
 
   EXPECT_TRUE(buffer_iter == buffer_end);
@@ -185,10 +185,10 @@ static bool VerifyTextBuffers(
 
 static bool VerifyEncryptedBuffer(
     scoped_refptr<StreamParserBuffer> buffer) {
-  EXPECT_TRUE(buffer->GetDecryptConfig());
+  EXPECT_TRUE(buffer->decrypt_config());
   EXPECT_EQ(static_cast<unsigned long>(DecryptConfig::kDecryptionKeySize),
-            buffer->GetDecryptConfig()->iv().length());
-  const uint8* data = buffer->GetData();
+            buffer->decrypt_config()->iv().length());
+  const uint8* data = buffer->data();
   return data[0] & kWebMFlagEncryptedFrame;
 }