Use __func__ instead of __FUNCTION__.

media/filters/frame_processor.cc

 // Copyright 2014 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/frame_processor.h"
 
 #include <stdint.h>
 
 #include <cstdlib>
 
@@ skipping 105 matching lines @@
 MseTrackBuffer::MseTrackBuffer(ChunkDemuxerStream* stream)
     : last_decode_timestamp_(kNoDecodeTimestamp()),
       last_frame_duration_(kNoTimestamp),
       highest_presentation_timestamp_(kNoTimestamp),
       needs_random_access_point_(true),
       stream_(stream) {
   DCHECK(stream_);
 }
 
 MseTrackBuffer::~MseTrackBuffer() {
-  DVLOG(2) << __FUNCTION__ << "()";
+  DVLOG(2) << __func__ << "()";
 }
 
 void MseTrackBuffer::Reset() {
-  DVLOG(2) << __FUNCTION__ << "()";
+  DVLOG(2) << __func__ << "()";
 
   last_decode_timestamp_ = kNoDecodeTimestamp();
   last_frame_duration_ = kNoTimestamp;
   highest_presentation_timestamp_ = kNoTimestamp;
   needs_random_access_point_ = true;
 }
 
 void MseTrackBuffer::SetHighestPresentationTimestampIfIncreased(
     base::TimeDelta timestamp) {
   if (highest_presentation_timestamp_ == kNoTimestamp ||
       timestamp > highest_presentation_timestamp_) {
     highest_presentation_timestamp_ = timestamp;
   }
 }
 
 void MseTrackBuffer::EnqueueProcessedFrame(
     const scoped_refptr<StreamParserBuffer>& frame) {
   processed_frames_.push_back(frame);
 }
 
 bool MseTrackBuffer::FlushProcessedFrames() {
   if (processed_frames_.empty())
     return true;
 
   bool result = stream_->Append(processed_frames_);
   processed_frames_.clear();
 
-  DVLOG_IF(3, !result) << __FUNCTION__
+  DVLOG_IF(3, !result) << __func__
                        << "(): Failure appending processed frames to stream";
 
   return result;
 }
 
 FrameProcessor::FrameProcessor(const UpdateDurationCB& update_duration_cb,
                                const scoped_refptr<MediaLog>& media_log)
     : group_start_timestamp_(kNoTimestamp),
       update_duration_cb_(update_duration_cb),
       media_log_(media_log) {
-  DVLOG(2) << __FUNCTION__ << "()";
+  DVLOG(2) << __func__ << "()";
   DCHECK(!update_duration_cb.is_null());
 }
 
 FrameProcessor::~FrameProcessor() {
-  DVLOG(2) << __FUNCTION__ << "()";
+  DVLOG(2) << __func__ << "()";
   STLDeleteValues(&track_buffers_);
 }
 
 void FrameProcessor::SetSequenceMode(bool sequence_mode) {
-  DVLOG(2) << __FUNCTION__ << "(" << sequence_mode << ")";
+  DVLOG(2) << __func__ << "(" << sequence_mode << ")";
   // Per June 9, 2016 MSE spec editor's draft:
   // https://rawgit.com/w3c/media-source/d8f901f22/
   //     index.html#widl-SourceBuffer-mode
   // Step 7: If the new mode equals "sequence", then set the group start
   // timestamp to the group end timestamp.
   if (sequence_mode) {
     DCHECK(kNoTimestamp != group_end_timestamp_);
     group_start_timestamp_ = group_end_timestamp_;
   } else if (sequence_mode_) {
     // We're switching from 'sequence' to 'segments' mode. Be safe and signal a
@@ skipping 44 matching lines @@
   // 5. If the media segment contains data beyond the current duration, then run
   //    the duration change algorithm with new duration set to the maximum of
   //    the current duration and the group end timestamp.
   update_duration_cb_.Run(group_end_timestamp_);
 
   return true;
 }
 
 void FrameProcessor::SetGroupStartTimestampIfInSequenceMode(
     base::TimeDelta timestamp_offset) {
-  DVLOG(2) << __FUNCTION__ << "(" << timestamp_offset.InSecondsF() << ")";
+  DVLOG(2) << __func__ << "(" << timestamp_offset.InSecondsF() << ")";
   DCHECK(kNoTimestamp != timestamp_offset);
   if (sequence_mode_)
     group_start_timestamp_ = timestamp_offset;
 
   // Changes to timestampOffset should invalidate the preroll buffer.
   audio_preroll_buffer_ = NULL;
 }
 
 bool FrameProcessor::AddTrack(StreamParser::TrackId id,
                               ChunkDemuxerStream* stream) {
-  DVLOG(2) << __FUNCTION__ << "(): id=" << id;
+  DVLOG(2) << __func__ << "(): id=" << id;
 
   MseTrackBuffer* existing_track = FindTrack(id);
   DCHECK(!existing_track);
   if (existing_track) {
     MEDIA_LOG(ERROR, media_log_) << "Failure adding track with duplicate ID "
                                  << id;
     return false;
   }
 
   track_buffers_[id] = new MseTrackBuffer(stream);
   return true;
 }
 
 bool FrameProcessor::UpdateTrack(StreamParser::TrackId old_id,
                                  StreamParser::TrackId new_id) {
-  DVLOG(2) << __FUNCTION__ << "() : old_id=" << old_id << ", new_id=" << new_id;
+  DVLOG(2) << __func__ << "() : old_id=" << old_id << ", new_id=" << new_id;
 
   if (old_id == new_id || !FindTrack(old_id) || FindTrack(new_id)) {
     MEDIA_LOG(ERROR, media_log_) << "Failure updating track id from " << old_id
                                  << " to " << new_id;
     return false;
   }
 
   track_buffers_[new_id] = track_buffers_[old_id];
   CHECK_EQ(1u, track_buffers_.erase(old_id));
   return true;
 }
 
 void FrameProcessor::SetAllTrackBuffersNeedRandomAccessPoint() {
   for (TrackBufferMap::iterator itr = track_buffers_.begin();
        itr != track_buffers_.end();
        ++itr) {
     itr->second->set_needs_random_access_point(true);
   }
 }
 
 void FrameProcessor::Reset() {
-  DVLOG(2) << __FUNCTION__ << "()";
+  DVLOG(2) << __func__ << "()";
   for (TrackBufferMap::iterator itr = track_buffers_.begin();
        itr != track_buffers_.end(); ++itr) {
     itr->second->Reset();
   }
 
   // Maintain current |coded_frame_group_last_dts_| state for Reset() during
   // sequence mode. Reset it here only if in segments mode. In sequence mode,
   // the current coded frame group may be continued across Reset() operations to
   // allow the stream to coaelesce what might otherwise be gaps in the buffered
   // ranges. See also the declaration for |coded_frame_group_last_dts_|.
@@ skipping 25 matching lines @@
 MseTrackBuffer* FrameProcessor::FindTrack(StreamParser::TrackId id) {
   TrackBufferMap::iterator itr = track_buffers_.find(id);
   if (itr == track_buffers_.end())
     return NULL;
 
   return itr->second;
 }
 
 void FrameProcessor::NotifyStartOfCodedFrameGroup(
     DecodeTimestamp start_timestamp) {
-  DVLOG(2) << __FUNCTION__ << "(" << start_timestamp.InSecondsF() << ")";
+  DVLOG(2) << __func__ << "(" << start_timestamp.InSecondsF() << ")";
 
   for (TrackBufferMap::iterator itr = track_buffers_.begin();
        itr != track_buffers_.end();
        ++itr) {
     itr->second->stream()->OnStartOfCodedFrameGroup(start_timestamp);
   }
 }
 
 bool FrameProcessor::FlushProcessedFrames() {
-  DVLOG(2) << __FUNCTION__ << "()";
+  DVLOG(2) << __func__ << "()";
 
   bool result = true;
   for (TrackBufferMap::iterator itr = track_buffers_.begin();
        itr != track_buffers_.end();
        ++itr) {
     if (!itr->second->FlushProcessedFrames())
       result = false;
   }
 
   return result;
@@ skipping 116 matching lines @@
     //      seconds.
     // 1.2. Let decode timestamp be a double precision floating point
     //      representation of the coded frame's decode timestamp in seconds.
     // 2. Let frame duration be a double precision floating point representation
     //    of the coded frame's duration in seconds.
     // We use base::TimeDelta and DecodeTimestamp instead of double.
     base::TimeDelta presentation_timestamp = frame->timestamp();
     DecodeTimestamp decode_timestamp = frame->GetDecodeTimestamp();
     base::TimeDelta frame_duration = frame->duration();
 
-    DVLOG(3) << __FUNCTION__ << ": Processing frame "
-             << "Type=" << frame->type()
+    DVLOG(3) << __func__ << ": Processing frame Type=" << frame->type()
              << ", TrackID=" << frame->track_id()
              << ", PTS=" << presentation_timestamp.InSecondsF()
              << ", DTS=" << decode_timestamp.InSecondsF()
              << ", DUR=" << frame_duration.InSecondsF()
              << ", RAP=" << frame->is_key_frame();
 
     // Sanity check the timestamps.
     if (presentation_timestamp == kNoTimestamp) {
       MEDIA_LOG(ERROR, media_log_) << "Unknown PTS for " << frame->GetTypeName()
                                    << " frame";
       return false;
     }
     if (decode_timestamp == kNoDecodeTimestamp()) {
       MEDIA_LOG(ERROR, media_log_) << "Unknown DTS for " << frame->GetTypeName()
                                    << " frame";
       return false;
     }
     if (decode_timestamp.ToPresentationTime() > presentation_timestamp) {
       // TODO(wolenetz): Determine whether DTS>PTS should really be allowed. See
       // http://crbug.com/354518.
       LIMITED_MEDIA_LOG(DEBUG, media_log_, num_dts_beyond_pts_warnings_,
                         kMaxDtsBeyondPtsWarnings)
           << "Parsed " << frame->GetTypeName() << " frame has DTS "
           << decode_timestamp.InMicroseconds()
           << "us, which is after the frame's PTS "
           << presentation_timestamp.InMicroseconds() << "us";
-      DVLOG(2) << __FUNCTION__ << ": WARNING: Frame DTS("
+      DVLOG(2) << __func__ << ": WARNING: Frame DTS("
                << decode_timestamp.InSecondsF() << ") > PTS("
                << presentation_timestamp.InSecondsF()
                << "), frame type=" << frame->GetTypeName();
     }
 
     // All stream parsers must emit valid (non-negative) frame durations.
     // Note that duration of 0 can occur for at least WebM alt-ref frames.
     if (frame_duration == kNoTimestamp) {
       MEDIA_LOG(ERROR, media_log_)
           << "Unknown duration for " << frame->GetTypeName() << " frame at PTS "
           << presentation_timestamp.InMicroseconds() << "us";
       return false;
     }
     if (frame_duration <  base::TimeDelta()) {
       MEDIA_LOG(ERROR, media_log_)
           << "Negative duration " << frame_duration.InMicroseconds()
           << "us for " << frame->GetTypeName() << " frame at PTS "
           << presentation_timestamp.InMicroseconds() << "us";
       return false;
     }
 
     // 3. If mode equals "sequence" and group start timestamp is set, then run
     //    the following steps:
     if (sequence_mode_ && group_start_timestamp_ != kNoTimestamp) {
       // 3.1. Set timestampOffset equal to group start timestamp -
       //      presentation timestamp.
       *timestamp_offset = group_start_timestamp_ - presentation_timestamp;
 
-      DVLOG(3) << __FUNCTION__ << ": updated timestampOffset is now "
+      DVLOG(3) << __func__ << ": updated timestampOffset is now "
                << timestamp_offset->InSecondsF();
 
       // 3.2. Set group end timestamp equal to group start timestamp.
       group_end_timestamp_ = group_start_timestamp_;
 
       // 3.3. Set the need random access point flag on all track buffers to
       //      true.
       SetAllTrackBuffersNeedRandomAccessPoint();
 
       // 3.4. Unset group start timestamp.
@@ skipping 59 matching lines @@
         //      presentation timestamp.
         //      If mode equals "sequence": Set group start timestamp equal to
         //      the group end timestamp.
         if (!sequence_mode_) {
           group_end_timestamp_ = presentation_timestamp;
           // This triggers a discontinuity so we need to treat the next frames
           // appended within the append window as if they were the beginning of
           // a new coded frame group. |coded_frame_group_last_dts_| is reset in
           // Reset(), below, for "segments" mode.
         } else {
-          DVLOG(3) << __FUNCTION__ << " : Sequence mode discontinuity, GETS: "
+          DVLOG(3) << __func__ << " : Sequence mode discontinuity, GETS: "
                    << group_end_timestamp_.InSecondsF();
           // Reset(), below, performs the "Set group start timestamp equal to
           // the group end timestamp" operation for "sequence" mode.
         }
 
         // 6.2. - 6.5.:
         Reset();
 
         // 6.6. Jump to the Loop Top step above to restart processing of the
         //      current coded frame.
-        DVLOG(3) << __FUNCTION__ << ": Discontinuity: reprocessing frame";
+        DVLOG(3) << __func__ << ": Discontinuity: reprocessing frame";
         continue;
       }
     }
 
     // 7. Let frame end timestamp equal the sum of presentation timestamp and
     //    frame duration.
     base::TimeDelta frame_end_timestamp =
         presentation_timestamp + frame_duration;
 
     // 8.  If presentation timestamp is less than appendWindowStart, then set
@@ skipping 46 matching lines @@
       return false;
     }
 
     // 10. If the need random access point flag on track buffer equals true,
     //     then run the following steps:
     if (track_buffer->needs_random_access_point()) {
       // 10.1. If the coded frame is not a random access point, then drop the
       //       coded frame and jump to the top of the loop to start processing
       //       the next coded frame.
       if (!frame->is_key_frame()) {
-        DVLOG(3) << __FUNCTION__
+        DVLOG(3) << __func__
                  << ": Dropping frame that is not a random access point";
         return true;
       }
 
       // 10.2. Set the need random access point flag on track buffer to false.
       track_buffer->set_needs_random_access_point(false);
     }
 
     // We now have a processed buffer to append to the track buffer's stream.
     // If it is the first in a new coded frame group (such as following a
@@ skipping 10 matching lines @@
       if (!FlushProcessedFrames())
         return false;
 
       // TODO(wolenetz): This should be changed to a presentation timestamp. See
       // http://crbug.com/402502
       NotifyStartOfCodedFrameGroup(decode_timestamp);
     }
 
     coded_frame_group_last_dts_ = decode_timestamp;
 
-    DVLOG(3) << __FUNCTION__ << ": Sending processed frame to stream, "
+    DVLOG(3) << __func__ << ": Sending processed frame to stream, "
              << "PTS=" << presentation_timestamp.InSecondsF()
              << ", DTS=" << decode_timestamp.InSecondsF();
 
     // Steps 11-16: Note, we optimize by appending groups of contiguous
     // processed frames for each track buffer at end of ProcessFrames() or prior
     // to NotifyStartOfCodedFrameGroup().
     track_buffer->EnqueueProcessedFrame(frame);
 
     // 17. Set last decode timestamp for track buffer to decode timestamp.
     track_buffer->set_last_decode_timestamp(decode_timestamp);
@@ skipping 17 matching lines @@
     // Step 21 is currently handled differently. See MediaSourceState's
     // |auto_update_timestamp_offset_|.
     return true;
   }
 
   NOTREACHED();
   return false;
 }
 
 }  // namespace media