Refactor WritableBuffer interface for more useful ptr management.

media/base/data_buffer_unittest.cc

Index: media/base/data_buffer_unittest.cc
===================================================================
--- media/base/data_buffer_unittest.cc	(revision 20532)
+++ media/base/data_buffer_unittest.cc	(working copy)
@@ -8,28 +8,21 @@
 
 using media::DataBuffer;
 
-TEST(DataBufferTest, Basic) {
-  const char kData[] = "hello";
-  const size_t kDataSize = arraysize(kData);
-  const char kNewData[] = "chromium";
-  const size_t kNewDataSize = arraysize(kNewData);
+TEST(DataBufferTest, StreamSampleImpl) {
   const base::TimeDelta kTimestampA = base::TimeDelta::FromMicroseconds(1337);
   const base::TimeDelta kDurationA = base::TimeDelta::FromMicroseconds(1667);
   const base::TimeDelta kTimestampB = base::TimeDelta::FromMicroseconds(1234);
   const base::TimeDelta kDurationB = base::TimeDelta::FromMicroseconds(5678);
 
-  // Create our buffer and copy some data into it.
   // Create a DataBuffer.
-  scoped_refptr<DataBuffer> buffer = new DataBuffer();
+  scoped_refptr<DataBuffer> buffer = new DataBuffer(0);
   ASSERT_TRUE(buffer);
 
-  // Test StreamSample implementation.
   buffer->SetTimestamp(kTimestampA);
   buffer->SetDuration(kDurationA);
   EXPECT_TRUE(kTimestampA == buffer->GetTimestamp());
   EXPECT_TRUE(kDurationA == buffer->GetDuration());
   EXPECT_TRUE(buffer->IsEndOfStream());
-  EXPECT_FALSE(buffer->GetData());
   EXPECT_FALSE(buffer->IsDiscontinuous());
   buffer->SetTimestamp(kTimestampB);
   buffer->SetDuration(kDurationB);
@@ -40,25 +33,47 @@
   EXPECT_TRUE(buffer->IsDiscontinuous());
   buffer->SetDiscontinuous(false);
   EXPECT_FALSE(buffer->IsDiscontinuous());
+}
 
-  // Test WritableBuffer implementation.
+TEST(DataBufferTest, Ctors) {
+  const size_t kTestSize = 10;
+
+  scoped_refptr<DataBuffer> buffer = new DataBuffer(0);
   EXPECT_FALSE(buffer->GetData());
-  uint8* data = buffer->GetWritableData(kDataSize);
+
+  scoped_refptr<DataBuffer> buffer2 = new DataBuffer(kTestSize);
+  EXPECT_EQ(0u, buffer2->GetDataSize());
+  EXPECT_EQ(kTestSize, buffer2->GetBufferSize());
+}
+
+TEST(DataBufferTest, WritableBufferImpl) {
+  const char kData[] = "hello";
+  const size_t kDataSize = arraysize(kData);
+  const char kNewData[] = "chromium";
+  const size_t kNewDataSize = arraysize(kNewData);
+
+  // Create a DataBuffer.
+  scoped_refptr<DataBuffer> buffer = new DataBuffer(kDataSize);
+  ASSERT_TRUE(buffer);
+
+  uint8* data = buffer->GetWritableData();
   ASSERT_TRUE(data);
-  ASSERT_EQ(buffer->GetDataSize(), kDataSize);
+  ASSERT_EQ(kDataSize, buffer->GetBufferSize());
   memcpy(data, kData, kDataSize);
+  buffer->SetDataSize(kDataSize);
   const uint8* read_only_data = buffer->GetData();
   ASSERT_EQ(data, read_only_data);
   ASSERT_EQ(0, memcmp(read_only_data, kData, kDataSize));
   EXPECT_FALSE(buffer->IsEndOfStream());
 
-  data = buffer->GetWritableData(kNewDataSize + 10);
+  scoped_refptr<DataBuffer> buffer2 = new DataBuffer(kNewDataSize + 10);
+  data = buffer2->GetWritableData();
   ASSERT_TRUE(data);
-  ASSERT_EQ(buffer->GetDataSize(), kNewDataSize + 10);
+  ASSERT_EQ(kNewDataSize + 10, buffer2->GetBufferSize());
   memcpy(data, kNewData, kNewDataSize);
-  read_only_data = buffer->GetData();
-  buffer->SetDataSize(kNewDataSize);
-  EXPECT_EQ(buffer->GetDataSize(), kNewDataSize);
+  buffer2->SetDataSize(kNewDataSize);
+  read_only_data = buffer2->GetData();
+  EXPECT_EQ(kNewDataSize, buffer2->GetDataSize());
   ASSERT_EQ(data, read_only_data);
   EXPECT_EQ(0, memcmp(read_only_data, kNewData, kNewDataSize));
 }