Refactored DecoderBuffer to use unix_hacker_style naming.

media/webm/webm_cluster_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 "base/bind.h"
 #include "base/logging.h"
 #include "media/base/decrypt_config.h"
 #include "media/webm/cluster_builder.h"
@@ skipping 99 matching lines @@
       LOG(ERROR) << "Unexpected track number " << block_info[i].track_num;
       return false;
     }
 
     if (*offset >= buffers->size())
       return false;
 
     scoped_refptr<StreamParserBuffer> buffer = (*buffers)[(*offset)++];
 
 
-    EXPECT_EQ(buffer->GetTimestamp().InMilliseconds(), block_info[i].timestamp);
+    EXPECT_EQ(buffer->timestamp().InMilliseconds(), block_info[i].timestamp);
 
     if (!block_info[i].use_simple_block)
-      EXPECT_NE(buffer->GetDuration(), kNoTimestamp());
+      EXPECT_NE(buffer->duration(), kNoTimestamp());
 
-    if (buffer->GetDuration() != kNoTimestamp())
-      EXPECT_EQ(buffer->GetDuration().InMilliseconds(), block_info[i].duration);
+    if (buffer->duration() != kNoTimestamp())
+      EXPECT_EQ(buffer->duration().InMilliseconds(), block_info[i].duration);
   }
 
   return true;
 }
 
 static bool VerifyBuffers(const scoped_ptr<WebMClusterParser>& parser,
                           const BlockInfo* block_info,
                           int block_count) {
   typedef WebMClusterParser::TextTrackIterator TextTrackIterator;
   TextTrackIterator text_it = parser->CreateTextTrackIterator();
@@ skipping 31 matching lines @@
   while (block_info_ptr != block_info_end) {
     const BlockInfo& block_info = *block_info_ptr++;
 
     if (block_info.track_num != text_track_num)
       continue;
 
     EXPECT_FALSE(block_info.use_simple_block);
     EXPECT_FALSE(buffer_iter == buffer_end);
 
     const scoped_refptr<StreamParserBuffer> buffer = *buffer_iter++;
-    EXPECT_EQ(buffer->GetTimestamp().InMilliseconds(), block_info.timestamp);
-    EXPECT_EQ(buffer->GetDuration().InMilliseconds(), block_info.duration);
+    EXPECT_EQ(buffer->timestamp().InMilliseconds(), block_info.timestamp);
+    EXPECT_EQ(buffer->duration().InMilliseconds(), block_info.duration);
   }
 
   EXPECT_TRUE(buffer_iter == buffer_end);
   return true;
 }
 
 static bool VerifyEncryptedBuffer(
     scoped_refptr<StreamParserBuffer> buffer) {
-  EXPECT_TRUE(buffer->GetDecryptConfig());
+  EXPECT_TRUE(buffer->decrypt_config());
   EXPECT_EQ(static_cast<unsigned long>(DecryptConfig::kDecryptionKeySize),
-            buffer->GetDecryptConfig()->iv().length());
-  const uint8* data = buffer->GetData();
+            buffer->decrypt_config()->iv().length());
+  const uint8* data = buffer->data();
   return data[0] & kWebMFlagEncryptedFrame;
 }
 
 static void AppendToEnd(const WebMClusterParser::BufferQueue& src,
                         WebMClusterParser::BufferQueue* dest) {
   for (WebMClusterParser::BufferQueue::const_iterator itr = src.begin();
        itr != src.end(); ++itr) {
     dest->push_back(*itr);
   }
 }
@@ skipping 322 matching lines @@
                                       WebMTracksParser::TextTracks(),
                                       std::set<int64>(),
                                       std::string(),
                                       "video_key_id",
                                       LogCB()));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(-1, result);
 }
 
 }  // namespace media