Refactored DecoderBuffer to use unix_hacker_style naming.

media/filters/ffmpeg_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 <deque>
 #include <string>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 16 matching lines @@
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::SetArgPointee;
 using ::testing::StrictMock;
 using ::testing::WithArgs;
 using ::testing::_;
 
 namespace media {
 
-MATCHER(IsEndOfStreamBuffer,
+MATCHER(is_end_of_streamBuffer,

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

revert this -- looks like it got included in some sort of global
search-and-replace ;)

         std::string(negation ? "isn't" : "is") + " end of stream") {
-  return arg->IsEndOfStream();
+  return arg->is_end_of_stream();
 }
 
 static void EosOnReadDone(bool* got_eos_buffer,
                           DemuxerStream::Status status,
                           const scoped_refptr<DecoderBuffer>& buffer) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 
   EXPECT_EQ(status, DemuxerStream::kOk);
-  if (buffer->IsEndOfStream()) {
+  if (buffer->is_end_of_stream()) {
     *got_eos_buffer = true;
     return;
   }
 
-  EXPECT_TRUE(buffer->GetData());
-  EXPECT_GT(buffer->GetDataSize(), 0);
+  EXPECT_TRUE(buffer->get_data());
+  EXPECT_GT(buffer->get_data_size(), 0);
   *got_eos_buffer = false;
 };
 
 
 // Fixture class to facilitate writing tests.  Takes care of setting up the
 // FFmpeg, pipeline and filter host mocks.
 class FFmpegDemuxerTest : public testing::Test {
  protected:
   FFmpegDemuxerTest() {}
 
@@ skipping 38 matching lines @@
                   int size, int64 timestampInMicroseconds,
                   DemuxerStream::Status status,
                   const scoped_refptr<DecoderBuffer>& buffer) {
     std::string location_str;
     location.Write(true, false, &location_str);
     location_str += "\n";
     SCOPED_TRACE(location_str);
     EXPECT_EQ(status, DemuxerStream::kOk);
     OnReadDoneCalled(size, timestampInMicroseconds);
     EXPECT_TRUE(buffer.get() != NULL);
-    EXPECT_EQ(size, buffer->GetDataSize());
+    EXPECT_EQ(size, buffer->get_data_size());
     EXPECT_EQ(base::TimeDelta::FromMicroseconds(timestampInMicroseconds),
-              buffer->GetTimestamp());
+              buffer->get_timestamp());
 
     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
     message_loop_.PostTask(FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
   }
 
   DemuxerStream::ReadCB NewReadCB(const tracked_objects::Location& location,
                                   int size, int64 timestampInMicroseconds) {
     EXPECT_CALL(*this, OnReadDoneCalled(size, timestampInMicroseconds));
     return base::Bind(&FFmpegDemuxerTest::OnReadDone, base::Unretained(this),
                       location, size, timestampInMicroseconds);
@@ skipping 300 matching lines @@
   InitializeDemuxer();
 
   // Get our stream.
   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
   ASSERT_TRUE(audio);
 
   demuxer_->Stop(NewExpectedClosure());
 
   // Reads after being stopped are all EOS buffers.
   StrictMock<MockReadCB> callback;
-  EXPECT_CALL(callback, Run(DemuxerStream::kOk, IsEndOfStreamBuffer()));
+  EXPECT_CALL(callback, Run(DemuxerStream::kOk, is_end_of_streamBuffer()));
 
   // Attempt the read...
   audio->Read(base::Bind(&MockReadCB::Run, base::Unretained(&callback)));
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(FFmpegDemuxerTest, DisableAudioStream) {
   // We are doing the following things here:
   // 1. Initialize the demuxer with audio and video stream.
   // 2. Send a "disable audio stream" message to the demuxer.
@@ skipping 119 matching lines @@
 TEST_F(FFmpegDemuxerTest, MP4_ZeroStszEntry) {
 #if !defined(USE_PROPRIETARY_CODECS)
   return;
 #endif
   CreateDemuxer("bear-1280x720-zero-stsz-entry.mp4");
   InitializeDemuxer();
   ReadUntilEndOfStream();
 }
 
 }  // namespace media