Refactored DecoderBuffer to use unix_hacker_style naming.

media/base/decoder_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/strings/string_util.h"
 #include "media/base/decoder_buffer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 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->get_data());
+  EXPECT_EQ(0, buffer->get_data_size());
+  EXPECT_FALSE(buffer->is_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->get_data_size());
 }
 
-TEST(DecoderBufferTest, CreateEOSBuffer) {
-  scoped_refptr<DecoderBuffer> buffer(DecoderBuffer::CreateEOSBuffer());
-  EXPECT_TRUE(buffer->IsEndOfStream());
+TEST(DecoderBufferTest, create_eos_buffer) {
+  scoped_refptr<DecoderBuffer> buffer(DecoderBuffer::create_eos_buffer());
+  EXPECT_TRUE(buffer->is_end_of_stream());
 }
 
-TEST(DecoderBufferTest, CopyFrom) {
+TEST(DecoderBufferTest, copy_from) {

[scherkus (not reviewing), 2013/06/20 21:26:59]

ditto

   const uint8 kData[] = "hello";
   const int kDataSize = arraysize(kData);
-  scoped_refptr<DecoderBuffer> buffer2(DecoderBuffer::CopyFrom(
+  scoped_refptr<DecoderBuffer> buffer2(DecoderBuffer::copy_from(
       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());
-  scoped_refptr<DecoderBuffer> buffer3(DecoderBuffer::CopyFrom(
+  EXPECT_NE(kData, buffer2->get_data());
+  EXPECT_EQ(buffer2->get_data_size(), kDataSize);
+  EXPECT_EQ(0, memcmp(buffer2->get_data(), kData, kDataSize));
+  EXPECT_FALSE(buffer2->is_end_of_stream());
+  scoped_refptr<DecoderBuffer> buffer3(DecoderBuffer::copy_from(
       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->get_data());
+  EXPECT_EQ(buffer3->get_data_size(), kDataSize);
+  EXPECT_EQ(0, memcmp(buffer3->get_data(), kData, kDataSize));
+  EXPECT_NE(kData, buffer3->get_side_data());
+  EXPECT_EQ(buffer3->get_side_data_size(), kDataSize);
+  EXPECT_EQ(0, memcmp(buffer3->get_side_data(), kData, kDataSize));
+  EXPECT_FALSE(buffer3->is_end_of_stream());
 }
 
 #if !defined(OS_ANDROID)
 TEST(DecoderBufferTest, PaddingAlignment) {
   const uint8 kData[] = "hello";
   const int kDataSize = arraysize(kData);
-  scoped_refptr<DecoderBuffer> buffer2(DecoderBuffer::CopyFrom(
+  scoped_refptr<DecoderBuffer> buffer2(DecoderBuffer::copy_from(
       reinterpret_cast<const uint8*>(&kData), kDataSize));
   ASSERT_TRUE(buffer2.get());
 
   // Padding data should always be zeroed.
   for(int i = 0; i < DecoderBuffer::kPaddingSize; i++)
-    EXPECT_EQ((buffer2->GetData() + kDataSize)[i], 0);
+    EXPECT_EQ((buffer2->get_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->get_writable_data() + kDataSize, kFillChar,
       DecoderBuffer::kPaddingSize);
   for(int i = 0; i < DecoderBuffer::kPaddingSize; i++)
-    EXPECT_EQ((buffer2->GetData() + kDataSize)[i], kFillChar);
+    EXPECT_EQ((buffer2->get_data() + kDataSize)[i], kFillChar);
 
   EXPECT_EQ(0u, reinterpret_cast<uintptr_t>(
-      buffer2->GetData()) & (DecoderBuffer::kAlignmentSize - 1));
+      buffer2->get_data()) & (DecoderBuffer::kAlignmentSize - 1));
 }
 #endif
 
 TEST(DecoderBufferTest, ReadingWriting) {
   const char kData[] = "hello";
   const int kDataSize = arraysize(kData);
 
   scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(kDataSize));
   ASSERT_TRUE(buffer.get());
 
-  uint8* data = buffer->GetWritableData();
+  uint8* data = buffer->get_writable_data();
   ASSERT_TRUE(data);
-  ASSERT_EQ(kDataSize, buffer->GetDataSize());
+  ASSERT_EQ(kDataSize, buffer->get_data_size());
   memcpy(data, kData, kDataSize);
-  const uint8* read_only_data = buffer->GetData();
+  const uint8* read_only_data = buffer->get_data();
   ASSERT_EQ(data, read_only_data);
   ASSERT_EQ(0, memcmp(read_only_data, kData, kDataSize));
-  EXPECT_FALSE(buffer->IsEndOfStream());
+  EXPECT_FALSE(buffer->is_end_of_stream());
 }
 
-TEST(DecoderBufferTest, GetDecryptConfig) {
+TEST(DecoderBufferTest, get_decrypt_config) {
   scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(0));
-  EXPECT_FALSE(buffer->GetDecryptConfig());
+  EXPECT_FALSE(buffer->get_decrypt_config());
 }
 
 }  // namespace media