Refactored DecoderBuffer to use unix_hacker_style naming.

media/mp4/mp4_stream_parser_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 <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
@@ skipping 57 matching lines @@
              << ", video=" << vc.IsValidConfig();
     configs_received_ = true;
     return true;
   }
 
   bool NewBuffersF(const StreamParser::BufferQueue& bufs) {
     DVLOG(2) << "NewBuffersF: " << bufs.size() << " buffers";
     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;
   }
 
   bool NewTextBuffersF(TextTrack* text_track,
                        const StreamParser::BufferQueue& buffers) {
     return true;
   }
 
   void KeyNeededF(const std::string& type,
@@ skipping 33 matching lines @@
         base::Bind(&MP4StreamParserTest::NewSegmentF, base::Unretained(this)),
         base::Bind(&MP4StreamParserTest::EndOfSegmentF,
                    base::Unretained(this)),
         LogCB());
   }
 
   bool ParseMP4File(const std::string& filename, int append_bytes) {
     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;
   }
 };
 
 TEST_F(MP4StreamParserTest, TestUnalignedAppend) {
   // Test small, non-segment-aligned appends (small enough to exercise
   // incremental append system)
   ParseMP4File("bear-1280x720-av_frag.mp4", 512);
 }
 
 TEST_F(MP4StreamParserTest, TestBytewiseAppend) {
   // Ensure no incremental errors occur when parsing
   ParseMP4File("bear-1280x720-av_frag.mp4", 1);
 }
 
 TEST_F(MP4StreamParserTest, TestMultiFragmentAppend) {
   // Large size ensures multiple fragments are appended in one call (size is
   // larger than this particular test file)
   ParseMP4File("bear-1280x720-av_frag.mp4", 768432);
 }
 
 TEST_F(MP4StreamParserTest, TestFlush) {
   // Flush while reading sample data, then start a new stream.
   InitializeParser();
 
   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));
 }
 
 TEST_F(MP4StreamParserTest, TestReinitialization) {
   InitializeParser();
 
   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));
 }
 
 TEST_F(MP4StreamParserTest, TestMPEG2_AAC_LC) {
   std::set<int> audio_object_types;
   audio_object_types.insert(kISO_13818_7_AAC_LC);
   parser_.reset(new MP4StreamParser(audio_object_types, false));
   ParseMP4File("bear-mpeg2-aac-only_frag.mp4", 512);
 }
 
 // Test that a moov box is not always required after Flush() is called.
 TEST_F(MP4StreamParserTest, TestNoMoovAfterFlush) {
   InitializeParser();
 
   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));
 }
 
 // TODO(strobe): Create and test media which uses CENC auxiliary info stored
 // inside a private box
 
 }  // namespace mp4
 }  // namespace media