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

media/filters/ffmpeg_demuxer.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 "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 252 matching lines @@
 
 const VideoDecoderConfig& FFmpegDemuxerStream::video_decoder_config() {
   CHECK_EQ(type_, VIDEO);
   return video_config_;
 }
 
 // static
 base::TimeDelta FFmpegDemuxerStream::ConvertStreamTimestamp(
     const AVRational& time_base, int64 timestamp) {
   if (timestamp == static_cast<int64>(AV_NOPTS_VALUE))
-    return kNoTimestamp;
+    return kNoTimestamp();
 
   return ConvertFromTimeBase(time_base, timestamp);
 }
 
 //
 // FFmpegDemuxer
 //
 FFmpegDemuxer::FFmpegDemuxer(MessageLoop* message_loop, bool local_source)
     : message_loop_(message_loop),
       local_source_(local_source),
       format_context_(NULL),
       read_event_(false, false),
       read_has_failed_(false),
       last_read_bytes_(0),
       read_position_(0),
       max_duration_(base::TimeDelta::FromMicroseconds(-1)),
       deferred_status_(PIPELINE_OK),
       first_seek_hack_(true),
-      start_time_(kNoTimestamp) {
+      start_time_(kNoTimestamp()) {
   DCHECK(message_loop_);
 }
 
 FFmpegDemuxer::~FFmpegDemuxer() {
   // In this destructor, we clean up resources held by FFmpeg. It is ugly to
   // close the codec contexts here because the corresponding codecs are opened
   // in the decoder filters. By reaching this point, all filters should have
   // stopped, so this is the only safe place to do the global clean up.
   // TODO(hclam): close the codecs in the corresponding decoders.
   if (!format_context_)
@@ skipping 206 matching lines @@
     AVStream* stream = format_context_->streams[i];
     scoped_refptr<FFmpegDemuxerStream> demuxer_stream(
         new FFmpegDemuxerStream(this, stream));
 
     streams_[i] = demuxer_stream;
     max_duration = std::max(max_duration, demuxer_stream->duration());
 
     if (stream->first_dts != static_cast<int64_t>(AV_NOPTS_VALUE)) {
       const base::TimeDelta first_dts = ConvertFromTimeBase(
           stream->time_base, stream->first_dts);
-      if (start_time_ == kNoTimestamp || first_dts < start_time_)
+      if (start_time_ == kNoTimestamp() || first_dts < start_time_)
         start_time_ = first_dts;
     }
   }
 
   if (!found_audio_stream && !found_video_stream) {
     callback.Run(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
     return;
   }
 
   if (format_context_->duration != static_cast<int64_t>(AV_NOPTS_VALUE)) {
     // If there is a duration value in the container use that to find the
     // maximum between it and the duration from A/V streams.
     const AVRational av_time_base = {1, AV_TIME_BASE};
     max_duration =
         std::max(max_duration,
                  ConvertFromTimeBase(av_time_base, format_context_->duration));
   } else {
     // The duration is unknown, in which case this is likely a live stream.
-    max_duration = kInfiniteDuration;
+    max_duration = kInfiniteDuration();
   }
 
   // Some demuxers, like WAV, do not put timestamps on their frames. We
   // assume the the start time is 0.
-  if (start_time_ == kNoTimestamp)
+  if (start_time_ == kNoTimestamp())
     start_time_ = base::TimeDelta();
 
   // Good to go: set the duration and bitrate and notify we're done
   // initializing.
   if (host())
     host()->SetDuration(max_duration);
   max_duration_ = max_duration;
 
   int bitrate = GetBitrate();
   if (bitrate > 0)
@@ skipping 15 matching lines @@
     AVCodecContext* codec_context = format_context_->streams[i]->codec;
     bitrate += codec_context->bit_rate;
   }
   if (bitrate > 0)
     return bitrate;
 
   // See if we can approximate the bitrate as long as we have a filesize and
   // valid duration.
   int64 filesize_in_bytes;
   if (max_duration_.InMicroseconds() <= 0 ||
-      max_duration_ == kInfiniteDuration ||
+      max_duration_ == kInfiniteDuration() ||
       !GetSize(&filesize_in_bytes)) {
     return 0;
   }
 
   // Do math in floating point as we'd overflow an int64 if the filesize was
   // larger than ~1073GB.
   double bytes = filesize_in_bytes;
   double duration = max_duration_.InMicroseconds();
   return bytes * 8000000.0 / duration;
 }
@@ skipping 148 matching lines @@
   read_event_.Wait();
   return last_read_bytes_;
 }
 
 void FFmpegDemuxer::SignalReadCompleted(size_t size) {
   last_read_bytes_ = size;
   read_event_.Signal();
 }
 
 }  // namespace media