Remove two static initializers (media/base/{buffers,media_log}.cc)

media/filters/ffmpeg_audio_decoder.cc

 // Copyright (c) 2011 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 "media/filters/ffmpeg_audio_decoder.h"
 
 #include "base/bind.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/data_buffer.h"
 #include "media/base/demuxer.h"
@@ skipping 13 matching lines @@
 static bool ProducedAudioSamples(int decoded_size) {
   return decoded_size > 0;
 }
 
 // Returns true if the decode result was a timestamp packet and not actual audio
 // data.
 static bool IsTimestampMarkerPacket(int result, Buffer* input) {
   // We can get a positive result but no decoded data.  This is ok because this
   // this can be a marker packet that only contains timestamp.
   return result > 0 && !input->IsEndOfStream() &&
-      input->GetTimestamp() != kNoTimestamp &&
-      input->GetDuration() != kNoTimestamp;
+      input->GetTimestamp() != kNoTimestamp() &&
+      input->GetDuration() != kNoTimestamp();
 }
 
 // Returns true if the decode result was end of stream.
 static bool IsEndOfStream(int result, int decoded_size, Buffer* input) {
   // Three conditions to meet to declare end of stream for this decoder:
   // 1. FFmpeg didn't read anything.
   // 2. FFmpeg didn't output anything.
   // 3. An end of stream buffer is received.
   return result == 0 && decoded_size == 0 && input->IsEndOfStream();
 }
@@ skipping 98 matching lines @@
   // Success!
   bits_per_channel_ = config.bits_per_channel();
   channel_layout_ = config.channel_layout();
   samples_per_second_ = config.samples_per_second();
 
   callback.Run();
 }
 
 void FFmpegAudioDecoder::DoFlush(const base::Closure& callback) {
   avcodec_flush_buffers(codec_context_);
-  estimated_next_timestamp_ = kNoTimestamp;
+  estimated_next_timestamp_ = kNoTimestamp();
   callback.Run();
 }
 
 void FFmpegAudioDecoder::DoRead(const ReadCB& callback) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(!callback.is_null());
   CHECK(read_cb_.is_null()) << "Overlapping decodes are not supported.";
 
   read_cb_ = callback;
   ReadFromDemuxerStream();
 }
 
 void FFmpegAudioDecoder::DoDecodeBuffer(const scoped_refptr<Buffer>& input) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(!read_cb_.is_null());
 
   // FFmpeg tends to seek Ogg audio streams in the middle of nowhere, giving us
   // a whole bunch of AV_NOPTS_VALUE packets.  Discard them until we find
   // something valid.  Refer to http://crbug.com/49709
-  if (input->GetTimestamp() == kNoTimestamp &&
-      estimated_next_timestamp_ == kNoTimestamp &&
+  if (input->GetTimestamp() == kNoTimestamp() &&
+      estimated_next_timestamp_ == kNoTimestamp() &&
       !input->IsEndOfStream()) {
     ReadFromDemuxerStream();
     return;
   }
 
   AVPacket packet;
   av_init_packet(&packet);
   if (input->IsEndOfStream()) {
     packet.data = NULL;
     packet.size = 0;
@@ skipping 68 matching lines @@
 }
 
 void FFmpegAudioDecoder::UpdateDurationAndTimestamp(
     const Buffer* input,
     DataBuffer* output) {
   // Always calculate duration based on the actual number of samples decoded.
   base::TimeDelta duration = CalculateDuration(output->GetDataSize());
   output->SetDuration(duration);
 
   // Use the incoming timestamp if it's valid.
-  if (input->GetTimestamp() != kNoTimestamp) {
+  if (input->GetTimestamp() != kNoTimestamp()) {
     output->SetTimestamp(input->GetTimestamp());
     estimated_next_timestamp_ = input->GetTimestamp() + duration;
     return;
   }
 
   // Otherwise use an estimated timestamp and attempt to update the estimation
   // as long as it's valid.
   output->SetTimestamp(estimated_next_timestamp_);
-  if (estimated_next_timestamp_ != kNoTimestamp) {
+  if (estimated_next_timestamp_ != kNoTimestamp()) {
     estimated_next_timestamp_ += duration;
   }
 }
 
 base::TimeDelta FFmpegAudioDecoder::CalculateDuration(int size) {
   int64 denominator = ChannelLayoutToChannelCount(channel_layout_) *
       bits_per_channel_ / 8 * samples_per_second_;
   double microseconds = size /
       (denominator / static_cast<double>(base::Time::kMicrosecondsPerSecond));
   return base::TimeDelta::FromMicroseconds(static_cast<int64>(microseconds));
 }
 
 void FFmpegAudioDecoder::DeliverSamples(const scoped_refptr<Buffer>& samples) {
   // Reset the callback before running to protect against reentrancy.
   ReadCB read_cb = read_cb_;
   read_cb_.Reset();
   read_cb.Run(samples);
 }
 
 }  // namespace media