Refactored DecoderBuffer to use unix_hacker_style naming.

media/filters/chunk_demuxer_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 <algorithm>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decoder_buffer.h"
@@ skipping 70 matching lines @@
   DCHECK(number >= 0 && number < GG_LONGLONG(0x00FFFFFFFFFFFFFF));
   buffer[0] = 0x01;
   int64 tmp = number;
   for (int i = 7; i > 0; i--) {
     buffer[i] = tmp & 0xff;
     tmp >>= 8;
   }
 }
 
 MATCHER_P(HasTimestamp, timestamp_in_ms, "") {
-  return arg.get() && !arg->IsEndOfStream() &&
-         arg->GetTimestamp().InMilliseconds() == timestamp_in_ms;
+  return arg.get() && !arg->is_end_of_stream() &&
+         arg->get_timestamp().InMilliseconds() == timestamp_in_ms;
 }
 
-MATCHER(IsEndOfStream, "") { return arg.get() && arg->IsEndOfStream(); }
+MATCHER(is_end_of_stream, "") { return arg.get() && arg->is_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->get_timestamp());
   *called = true;
 }
 
 static void OnReadDone_AbortExpected(
     bool* called, DemuxerStream::Status status,
     const scoped_refptr<DecoderBuffer>& buffer) {
   EXPECT_EQ(status, DemuxerStream::kAborted);
   EXPECT_EQ(NULL, buffer.get());
   *called = true;
 }
 
 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->is_end_of_stream());
   *called = true;
 }
 
 static void OnSeekDone_OKExpected(bool* called, PipelineStatus status) {
   EXPECT_EQ(status, PIPELINE_OK);
   *called = true;
 }
 
 class ChunkDemuxerTest : public testing::Test {
  protected:
@@ skipping 48 matching lines @@
     scoped_refptr<DecoderBuffer> video_content_encodings;
 
     ebml_header = ReadTestDataFile("webm_ebml_element");
 
     info = ReadTestDataFile("webm_info_element");
 
     int tracks_element_size = 0;
 
     if (has_audio) {
       audio_track_entry = ReadTestDataFile("webm_vorbis_track_entry");
-      tracks_element_size += audio_track_entry->GetDataSize();
+      tracks_element_size += audio_track_entry->get_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->get_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->get_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->get_data_size();
       }
     }
 
-    *size = ebml_header->GetDataSize() + info->GetDataSize() +
+    *size = ebml_header->get_data_size() + info->get_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->get_data(), ebml_header->get_data_size());
+    buf += ebml_header->get_data_size();
 
-    memcpy(buf, info->GetData(), info->GetDataSize());
-    buf += info->GetDataSize();
+    memcpy(buf, info->get_data(), info->get_data_size());
+    buf += info->get_data_size();
 
     memcpy(buf, kTracksHeader, kTracksHeaderSize);
     WriteInt64(buf + kTracksSizeOffset, tracks_element_size);
     buf += kTracksHeaderSize;
 
     // 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->get_data(),
+             audio_track_entry->get_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->get_data_size(),
+               audio_content_encodings->get_data(),
+               audio_content_encodings->get_data_size());
         WriteInt64(buf + kAudioTrackSizeOffset,
-                   audio_track_entry->GetDataSize() +
-                   audio_content_encodings->GetDataSize() -
+                   audio_track_entry->get_data_size() +
+                   audio_content_encodings->get_data_size() -
                    kAudioTrackEntryHeaderSize);
-        buf += audio_content_encodings->GetDataSize();
+        buf += audio_content_encodings->get_data_size();
       }
-      buf += audio_track_entry->GetDataSize();
+      buf += audio_track_entry->get_data_size();
     }
 
     if (has_video) {
-      memcpy(buf, video_track_entry->GetData(),
-             video_track_entry->GetDataSize());
+      memcpy(buf, video_track_entry->get_data(),
+             video_track_entry->get_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->get_data_size(),
+               video_content_encodings->get_data(),
+               video_content_encodings->get_data_size());
         WriteInt64(buf + kVideoTrackSizeOffset,
-                   video_track_entry->GetDataSize() +
-                   video_content_encodings->GetDataSize() -
+                   video_track_entry->get_data_size() +
+                   video_content_encodings->get_data_size() -
                    kVideoTrackEntryHeaderSize);
-        buf += video_content_encodings->GetDataSize();
+        buf += video_content_encodings->get_data_size();
       }
-      buf += video_track_entry->GetDataSize();
+      buf += video_track_entry->get_data_size();
     }
   }
 
   ChunkDemuxer::Status AddId() {
     return AddId(kSourceId, true, true);
   }
 
   ChunkDemuxer::Status AddId(const std::string& source_id,
                              bool has_audio, bool has_video) {
     std::vector<std::string> codecs;
@@ skipping 166 matching lines @@
 
     EXPECT_CALL(*this, DemuxerOpened());
     demuxer_->Initialize(
         &host_, CreateInitDoneCB(base::TimeDelta::FromMilliseconds(2744),
                                  PIPELINE_OK));
 
     if (AddId(kSourceId, true, true) != ChunkDemuxer::kOk)
       return false;
 
     // Append the whole bear1 file.
-    AppendData(bear1->GetData(), bear1->GetDataSize());
+    AppendData(bear1->get_data(), bear1->get_data_size());
     CheckExpectedRanges(kSourceId, "{ [0,2737) }");
 
     // Append initialization segment for bear2.
     // Note: Offsets here and below are derived from
     // media/test/data/bear-640x360-manifest.js and
     // 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->get_data(), 4340);
 
     // Append a media segment that goes from [0.527000, 1.014000).
-    AppendData(bear2->GetData() + 55290, 18785);
+    AppendData(bear2->get_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->get_data(), 4370);
+    AppendData(bear1->get_data() + 72737, 28183);
     CheckExpectedRanges(kSourceId, "{ [0,2737) }");
 
     demuxer_->EndOfStream(PIPELINE_OK);
     return true;
   }
 
   void ShutdownDemuxer() {
     if (demuxer_)
       demuxer_->Shutdown();
   }
@@ skipping 206 matching lines @@
                                    DemuxerStream::Status* status,
                                    base::TimeDelta* last_timestamp) {
     DemuxerStream* stream = demuxer_->GetStream(type);
     scoped_refptr<DecoderBuffer> buffer;
 
     *last_timestamp = kNoTimestamp();
     do {
       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->is_end_of_stream())
+        *last_timestamp = buffer->get_timestamp();
+    } while (*status == DemuxerStream::kOk && !buffer->is_end_of_stream());
   }
 
   void ExpectEndOfStream(DemuxerStream::Type type) {
-    EXPECT_CALL(*this, ReadDone(DemuxerStream::kOk, IsEndOfStream()));
+    EXPECT_CALL(*this, ReadDone(DemuxerStream::kOk, is_end_of_stream()));
     demuxer_->GetStream(type)->Read(base::Bind(
         &ChunkDemuxerTest::ReadDone, base::Unretained(this)));
     message_loop_.RunUntilIdle();
   }
 
   void ExpectRead(DemuxerStream::Type type, int64 timestamp_in_ms) {
     EXPECT_CALL(*this, ReadDone(DemuxerStream::kOk,
                                 HasTimestamp(timestamp_in_ms)));
     demuxer_->GetStream(type)->Read(base::Bind(
         &ChunkDemuxerTest::ReadDone, base::Unretained(this)));
@@ skipping 33 matching lines @@
                      bool has_audio, bool has_video) {
     EXPECT_CALL(*this, DemuxerOpened());
     demuxer_->Initialize(
         &host_, CreateInitDoneCB(duration, PIPELINE_OK));
 
     if (AddId(kSourceId, has_audio, has_video) != ChunkDemuxer::kOk)
       return false;
 
     // 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->get_data(), buffer->get_data_size(), 512);
 
     // Verify that the timestamps on the first few packets match what we
     // expect.
     for (size_t i = 0;
          (timestamps[i].audio_time_ms != kSkip ||
           timestamps[i].video_time_ms != kSkip);
          i++) {
       bool audio_read_done = false;
       bool video_read_done = false;
 
@@ skipping 407 matching lines @@
     EXPECT_EQ(expected, audio_read_done_);
     EXPECT_EQ(expected, video_read_done_);
   }
 
  private:
   static void OnEndOfStreamReadDone(
       bool* called,
       DemuxerStream::Status status,
       const scoped_refptr<DecoderBuffer>& buffer) {
     EXPECT_EQ(status, DemuxerStream::kOk);
-    EXPECT_TRUE(buffer->IsEndOfStream());
+    EXPECT_TRUE(buffer->is_end_of_stream());
     *called = true;
   }
 
   Demuxer* demuxer_;
   bool audio_read_done_;
   bool video_read_done_;
 
   DISALLOW_COPY_AND_ASSIGN(EndOfStreamHelper);
 };
 
@@ skipping 1371 matching lines @@
   EXPECT_FALSE(audio_read_done);
   EXPECT_FALSE(video_read_done);
 
   demuxer_->EndOfStream(PIPELINE_OK);
 
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 }
 
 }  // namespace media