Use __func__ instead of __FUNCTION__.

media/filters/source_buffer_stream.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 "media/filters/source_buffer_stream.h"
 
 #include <algorithm>
 #include <map>
 #include <sstream>
 
@@ skipping 175 matching lines @@
 
 SourceBufferStream::~SourceBufferStream() {
   while (!ranges_.empty()) {
     delete ranges_.front();
     ranges_.pop_front();
   }
 }
 
 void SourceBufferStream::OnStartOfCodedFrameGroup(
     DecodeTimestamp coded_frame_group_start_time) {
-  DVLOG(1) << __FUNCTION__ << " " << GetStreamTypeName() << " ("
+  DVLOG(1) << __func__ << " " << GetStreamTypeName() << " ("
            << coded_frame_group_start_time.InSecondsF() << ")";
   DCHECK(!end_of_stream_);
   coded_frame_group_start_time_ = coded_frame_group_start_time;
   new_coded_frame_group_ = true;
 
   RangeList::iterator last_range = range_for_next_append_;
   range_for_next_append_ = FindExistingRangeFor(coded_frame_group_start_time);
 
   // Only reset |last_appended_buffer_timestamp_| if this new coded frame group
   // is not adjacent to the previous coded frame group appended to the stream.
   if (range_for_next_append_ == ranges_.end() ||
       !AreAdjacentInSequence(last_appended_buffer_timestamp_,
                              coded_frame_group_start_time)) {
     last_appended_buffer_timestamp_ = kNoDecodeTimestamp();
     last_appended_buffer_duration_ = kNoTimestamp;
     last_appended_buffer_is_keyframe_ = false;
-    DVLOG(3) << __FUNCTION__ << " next appended buffers will "
+    DVLOG(3) << __func__ << " next appended buffers will "
              << (range_for_next_append_ == ranges_.end()
                      ? "be in a new range"
                      : "overlap an existing range");
   } else if (last_range != ranges_.end()) {
     DCHECK(last_range == range_for_next_append_);
-    DVLOG(3) << __FUNCTION__ << " next appended buffers will continue range "
-             << "unless intervening remove makes discontinuity";
+    DVLOG(3) << __func__ << " next appended buffers will continue range unless "
+             << "intervening remove makes discontinuity";
   }
 }
 
 bool SourceBufferStream::Append(const BufferQueue& buffers) {
   TRACE_EVENT2("media", "SourceBufferStream::Append",
                "stream type", GetStreamTypeName(),
                "buffers to append", buffers.size());
 
   DCHECK(!buffers.empty());
   DCHECK(coded_frame_group_start_time_ != kNoDecodeTimestamp());
   DCHECK(coded_frame_group_start_time_ <=
          buffers.front()->GetDecodeTimestamp());
   DCHECK(!end_of_stream_);
 
-  DVLOG(1) << __FUNCTION__ << " " << GetStreamTypeName()
-           << ": buffers " << BufferQueueToLogString(buffers);
+  DVLOG(1) << __func__ << " " << GetStreamTypeName() << ": buffers "
+           << BufferQueueToLogString(buffers);
 
   // New coded frame groups emitted by the coded frame processor must begin with
   // a keyframe. TODO(wolenetz): Change this to [DCHECK + MEDIA_LOG(ERROR...) +
   // return false] once the CHECK has baked in a stable release. See
   // https://crbug.com/580621.
   CHECK(!new_coded_frame_group_ || buffers.front()->is_key_frame());
 
   // Buffers within a coded frame group should be monotonically increasing.
   if (!IsMonotonicallyIncreasing(buffers)) {
     return false;
@@ skipping 58 matching lines @@
       while (itr != buffers.end() && !(*itr)->is_key_frame()) {
         ++itr;
       }
 
       // If we didn't find a key frame, then update the last appended
       // buffer state and return.
       if (itr == buffers.end()) {
         last_appended_buffer_timestamp_ = buffers.back()->GetDecodeTimestamp();
         last_appended_buffer_duration_ = buffers.back()->duration();
         last_appended_buffer_is_keyframe_ = buffers.back()->is_key_frame();
-        DVLOG(1) << __FUNCTION__ << " " << GetStreamTypeName()
+        DVLOG(1) << __func__ << " " << GetStreamTypeName()
                  << ": new buffers in the middle of coded frame group depend on"
                     "keyframe that has been removed, and contain no keyframes."
                     "Skipping further processing.";
-        DVLOG(1) << __FUNCTION__ << " " << GetStreamTypeName()
+        DVLOG(1) << __func__ << " " << GetStreamTypeName()
                  << ": done. ranges_=" << RangesToString(ranges_);
         return true;
       } else if (itr != buffers.begin()) {
         // Copy the first key frame and everything after it into
         // |trimmed_buffers|.
         trimmed_buffers.assign(itr, buffers.end());
         buffers_for_new_range = &trimmed_buffers;
       }
 
       new_range_start_time =
@@ skipping 29 matching lines @@
         deleted_buffers.front()->GetDecodeTimestamp();
 
     DCHECK(track_buffer_.empty() ||
            track_buffer_.back()->GetDecodeTimestamp() < start_of_deleted)
         << "decode timestamp "
         << track_buffer_.back()->GetDecodeTimestamp().InSecondsF() << " sec"
         << ", start_of_deleted " << start_of_deleted.InSecondsF()<< " sec";
 
     track_buffer_.insert(track_buffer_.end(), deleted_buffers.begin(),
                          deleted_buffers.end());
-    DVLOG(3) << __FUNCTION__ << " " << GetStreamTypeName() << " Added "
+    DVLOG(3) << __func__ << " " << GetStreamTypeName() << " Added "
              << deleted_buffers.size()
              << " buffers to track buffer. TB size is now "
              << track_buffer_.size();
   } else {
-    DVLOG(3) << __FUNCTION__ << " " << GetStreamTypeName()
+    DVLOG(3) << __func__ << " " << GetStreamTypeName()
              << " No deleted buffers for track buffer";
   }
 
   // Prune any extra buffers in |track_buffer_| if new keyframes
   // are appended to the range covered by |track_buffer_|.
   if (!track_buffer_.empty()) {
     DecodeTimestamp keyframe_timestamp =
         FindKeyframeAfterTimestamp(track_buffer_.front()->GetDecodeTimestamp());
     if (keyframe_timestamp != kNoDecodeTimestamp())
       PruneTrackBuffer(keyframe_timestamp);
   }
 
   SetSelectedRangeIfNeeded(next_buffer_timestamp);
 
-  DVLOG(1) << __FUNCTION__ << " " << GetStreamTypeName()
+  DVLOG(1) << __func__ << " " << GetStreamTypeName()
            << ": done. ranges_=" << RangesToString(ranges_);
   DCHECK(IsRangeListSorted(ranges_));
   DCHECK(OnlySelectedRangeIsSeeked());
   return true;
 }
 
 void SourceBufferStream::Remove(base::TimeDelta start, base::TimeDelta end,
                                 base::TimeDelta duration) {
-  DVLOG(1) << __FUNCTION__ << " " << GetStreamTypeName()
-           << " (" << start.InSecondsF() << ", " << end.InSecondsF()
-           << ", " << duration.InSecondsF() << ")";
+  DVLOG(1) << __func__ << " " << GetStreamTypeName() << " ("
+           << start.InSecondsF() << ", " << end.InSecondsF() << ", "
+           << duration.InSecondsF() << ")";
   DCHECK(start >= base::TimeDelta()) << start.InSecondsF();
   DCHECK(start < end) << "start " << start.InSecondsF()
                       << " end " << end.InSecondsF();
   DCHECK(duration != kNoTimestamp);
 
   DecodeTimestamp start_dts = DecodeTimestamp::FromPresentationTime(start);
   DecodeTimestamp end_dts = DecodeTimestamp::FromPresentationTime(end);
   DecodeTimestamp remove_end_timestamp =
       DecodeTimestamp::FromPresentationTime(duration);
   DecodeTimestamp keyframe_timestamp = FindKeyframeAfterTimestamp(end_dts);
   if (keyframe_timestamp != kNoDecodeTimestamp()) {
     remove_end_timestamp = keyframe_timestamp;
   } else if (end_dts < remove_end_timestamp) {
     remove_end_timestamp = end_dts;
   }
 
   BufferQueue deleted_buffers;
   RemoveInternal(start_dts, remove_end_timestamp, false, &deleted_buffers);
 
   if (!deleted_buffers.empty()) {
     // Buffers for the current position have been removed.
     SetSelectedRangeIfNeeded(deleted_buffers.front()->GetDecodeTimestamp());
     if (last_output_buffer_timestamp_ == kNoDecodeTimestamp()) {
       // We just removed buffers for the current playback position for this
       // stream, yet we also had output no buffer since the last Seek.
       // Re-seek to prevent stall.
-      DVLOG(1) << __FUNCTION__ << " " << GetStreamTypeName()
-               << ": re-seeking to " << seek_buffer_timestamp_
+      DVLOG(1) << __func__ << " " << GetStreamTypeName() << ": re-seeking to "
+               << seek_buffer_timestamp_
                << " to prevent stall if this time becomes buffered again";
       Seek(seek_buffer_timestamp_);
     }
   }
 }
 
 DecodeTimestamp SourceBufferStream::PotentialNextAppendTimestamp() const {
   // The next potential append will either be just at or after
   // |last_appended_buffer_timestamp_| (if known), or if unknown and we are
   // still at the beginning of a new coded frame group, then will be into the
@@ skipping 12 matching lines @@
   // removed the ranged to which it previously belonged and have not completed a
   // subsequent append or received a subsequent OnStartOfCodedFrameGroup()
   // signal.
   return kNoDecodeTimestamp();
 }
 
 void SourceBufferStream::RemoveInternal(DecodeTimestamp start,
                                         DecodeTimestamp end,
                                         bool exclude_start,
                                         BufferQueue* deleted_buffers) {
-  DVLOG(2) << __FUNCTION__ << " " << GetStreamTypeName() << " ("
+  DVLOG(2) << __func__ << " " << GetStreamTypeName() << " ("
            << start.InSecondsF() << ", " << end.InSecondsF() << ", "
            << exclude_start << ")";
-  DVLOG(3) << __FUNCTION__ << " " << GetStreamTypeName()
+  DVLOG(3) << __func__ << " " << GetStreamTypeName()
            << ": before remove ranges_=" << RangesToString(ranges_);
 
   DCHECK(start >= DecodeTimestamp());
   DCHECK(start < end) << "start " << start.InSecondsF()
                       << " end " << end.InSecondsF();
   DCHECK(deleted_buffers);
 
   RangeList::iterator itr = ranges_.begin();
 
   while (itr != ranges_.end()) {
@@ skipping 64 matching lines @@
                  <<  " can't add to the current range.";
         range_for_next_append_ =
             FindExistingRangeFor(potential_next_append_timestamp);
       }
     }
 
     // Move on to the next range.
     ++itr;
   }
 
-  DVLOG(3) << __FUNCTION__ << " " << GetStreamTypeName()
+  DVLOG(3) << __func__ << " " << GetStreamTypeName()
            << ": after remove ranges_=" << RangesToString(ranges_);
 
   DCHECK(IsRangeListSorted(ranges_));
   DCHECK(OnlySelectedRangeIsSeeked());
 }
 
 void SourceBufferStream::ResetSeekState() {
   SetSelectedRange(NULL);
   track_buffer_.clear();
   config_change_pending_ = false;
@@ skipping 118 matching lines @@
         << ", currently buffered ranges_size=" << ranges_size;
     return false;
   }
 
   // Return if we're under or at the memory limit.
   if (ranges_size + newDataSize <= memory_limit_)
     return true;
 
   size_t bytes_to_free = ranges_size + newDataSize - memory_limit_;
 
-  DVLOG(2) << __FUNCTION__ << " " << GetStreamTypeName() << ": Before GC"
-           << " media_time=" << media_time.InSecondsF()
+  DVLOG(2) << __func__ << " " << GetStreamTypeName()
+           << ": Before GC media_time=" << media_time.InSecondsF()
            << " ranges_=" << RangesToString(ranges_)
            << " seek_pending_=" << seek_pending_
-           << " ranges_size=" << ranges_size
-           << " newDataSize=" << newDataSize
+           << " ranges_size=" << ranges_size << " newDataSize=" << newDataSize
            << " memory_limit_=" << memory_limit_
            << " last_appended_buffer_timestamp_="
            << last_appended_buffer_timestamp_.InSecondsF();
 
   if (selected_range_ && !seek_pending_ &&
       media_time > selected_range_->GetBufferedEndTimestamp()) {
     // Strictly speaking |media_time| (taken from HTMLMediaElement::currentTime)
     // should always be in the buffered ranges, but media::Pipeline uses audio
     // stream as the main time source, when audio is present.
     // In cases when audio and video streams have different buffered ranges, the
     // |media_time| value might be slightly outside of the video stream buffered
     // range. In those cases we need to clamp |media_time| value to the current
     // stream buffered ranges, to ensure the MSE garbage collection algorithm
     // works correctly (see crbug.com/563292 for details).
     DecodeTimestamp selected_buffered_end =
         selected_range_->GetBufferedEndTimestamp();
 
-    DVLOG(2) << __FUNCTION__ << " media_time " << media_time.InSecondsF()
+    DVLOG(2) << __func__ << " media_time " << media_time.InSecondsF()
              << " is outside of selected_range_=["
              << selected_range_->GetStartTimestamp().InSecondsF() << ";"
              << selected_buffered_end.InSecondsF()
              << "] clamping media_time to be "
              << selected_buffered_end.InSecondsF();
     media_time = selected_buffered_end;
   }
 
   size_t bytes_freed = 0;
 
   // If last appended buffer position was earlier than the current playback time
   // then try deleting data between last append and current media_time.
   if (last_appended_buffer_timestamp_ != kNoDecodeTimestamp() &&
       last_appended_buffer_duration_ != kNoTimestamp &&
       media_time >
           last_appended_buffer_timestamp_ + last_appended_buffer_duration_) {
     size_t between = FreeBuffersAfterLastAppended(bytes_to_free, media_time);
-    DVLOG(3) << __FUNCTION__ << " FreeBuffersAfterLastAppended "
+    DVLOG(3) << __func__ << " FreeBuffersAfterLastAppended "
              << " released " << between << " bytes"
              << " ranges_=" << RangesToString(ranges_);
     bytes_freed += between;
 
     // Some players start appending data at the new seek target position before
     // actually initiating the seek operation (i.e. they try to improve seek
     // performance by prebuffering some data at the seek target position and
     // initiating seek once enough data is pre-buffered. In those cases we'll
     // see that data is being appended at some new position, but there is no
     // pending seek reported yet. In this situation we need to try preserving
     // the most recently appended data, i.e. data belonging to the same buffered
     // range as the most recent append.
     if (range_for_next_append_ != ranges_.end()) {
       DCHECK((*range_for_next_append_)->GetStartTimestamp() <= media_time);
       media_time = (*range_for_next_append_)->GetStartTimestamp();
-      DVLOG(3) << __FUNCTION__ << " media_time adjusted to "
+      DVLOG(3) << __func__ << " media_time adjusted to "
                << media_time.InSecondsF();
     }
   }
 
   // If there is an unsatisfied pending seek, we can safely remove all data that
   // is earlier than seek target, then remove from the back until we reach the
   // most recently appended GOP and then remove from the front if we still don't
   // have enough space for the upcoming append.
   if (bytes_freed < bytes_to_free && seek_pending_) {
     DCHECK(!ranges_.empty());
     // All data earlier than the seek target |media_time| can be removed safely
     size_t front = FreeBuffers(bytes_to_free - bytes_freed, media_time, false);
-    DVLOG(3) << __FUNCTION__ << " Removed " << front << " bytes from the"
-             << " front. ranges_=" << RangesToString(ranges_);
+    DVLOG(3) << __func__ << " Removed " << front
+             << " bytes from the front. ranges_=" << RangesToString(ranges_);
     bytes_freed += front;
 
     // If removing data earlier than |media_time| didn't free up enough space,
     // then try deleting from the back until we reach most recently appended GOP
     if (bytes_freed < bytes_to_free) {
       size_t back = FreeBuffers(bytes_to_free - bytes_freed, media_time, true);
-      DVLOG(3) << __FUNCTION__ << " Removed " << back << " bytes from the back"
-               << " ranges_=" << RangesToString(ranges_);
+      DVLOG(3) << __func__ << " Removed " << back
+               << " bytes from the back. ranges_=" << RangesToString(ranges_);
       bytes_freed += back;
     }
 
     // If even that wasn't enough, then try greedily deleting from the front,
     // that should allow us to remove as much data as necessary to succeed.
     if (bytes_freed < bytes_to_free) {
       size_t front2 = FreeBuffers(bytes_to_free - bytes_freed,
                                   ranges_.back()->GetEndTimestamp(), false);
-      DVLOG(3) << __FUNCTION__ << " Removed " << front2 << " bytes from the"
-               << " front. ranges_=" << RangesToString(ranges_);
+      DVLOG(3) << __func__ << " Removed " << front2
+               << " bytes from the front. ranges_=" << RangesToString(ranges_);
       bytes_freed += front2;
     }
     DCHECK(bytes_freed >= bytes_to_free);
   }
 
   // Try removing data from the front of the SourceBuffer up to |media_time|
   // position.
   if (bytes_freed < bytes_to_free) {
     size_t front = FreeBuffers(bytes_to_free - bytes_freed, media_time, false);
-    DVLOG(3) << __FUNCTION__ << " Removed " << front << " bytes from the"
-             << " front. ranges_=" << RangesToString(ranges_);
+    DVLOG(3) << __func__ << " Removed " << front
+             << " bytes from the front. ranges_=" << RangesToString(ranges_);
     bytes_freed += front;
   }
 
   // Try removing data from the back of the SourceBuffer, until we reach the
   // most recent append position.
   if (bytes_freed < bytes_to_free) {
     size_t back = FreeBuffers(bytes_to_free - bytes_freed, media_time, true);
-    DVLOG(3) << __FUNCTION__ << " Removed " << back << " bytes from the back."
-             << " ranges_=" << RangesToString(ranges_);
+    DVLOG(3) << __func__ << " Removed " << back
+             << " bytes from the back. ranges_=" << RangesToString(ranges_);
     bytes_freed += back;
   }
 
-  DVLOG(2) << __FUNCTION__ << " " << GetStreamTypeName() << ": After GC"
-           << " bytes_to_free=" << bytes_to_free
+  DVLOG(2) << __func__ << " " << GetStreamTypeName()
+           << ": After GC bytes_to_free=" << bytes_to_free
            << " bytes_freed=" << bytes_freed
            << " ranges_=" << RangesToString(ranges_);
 
   return bytes_freed >= bytes_to_free;
 }
 
 size_t SourceBufferStream::FreeBuffersAfterLastAppended(
     size_t total_bytes_to_free, DecodeTimestamp media_time) {
-  DVLOG(4) << __FUNCTION__ << " last_appended_buffer_timestamp_="
-            << last_appended_buffer_timestamp_.InSecondsF()
-            << " media_time=" << media_time.InSecondsF();
+  DVLOG(4) << __func__ << " last_appended_buffer_timestamp_="
+           << last_appended_buffer_timestamp_.InSecondsF()
+           << " media_time=" << media_time.InSecondsF();
 
   DecodeTimestamp remove_range_start = last_appended_buffer_timestamp_;
   if (last_appended_buffer_is_keyframe_)
     remove_range_start += GetMaxInterbufferDistance();
 
   DecodeTimestamp remove_range_start_keyframe = FindKeyframeAfterTimestamp(
       remove_range_start);
   if (remove_range_start_keyframe != kNoDecodeTimestamp())
     remove_range_start = remove_range_start_keyframe;
   if (remove_range_start >= media_time)
     return 0;
 
   DecodeTimestamp remove_range_end;
   size_t bytes_freed = GetRemovalRange(remove_range_start,
                                        media_time,
                                        total_bytes_to_free,
                                        &remove_range_end);
   if (bytes_freed > 0) {
-    DVLOG(4) << __FUNCTION__ << " removing ["
+    DVLOG(4) << __func__ << " removing ["
              << remove_range_start.ToPresentationTime().InSecondsF() << ";"
              << remove_range_end.ToPresentationTime().InSecondsF() << "]";
     Remove(remove_range_start.ToPresentationTime(),
            remove_range_end.ToPresentationTime(),
            media_time.ToPresentationTime());
   }
 
   return bytes_freed;
 }
 
@@ skipping 193 matching lines @@
 
 void SourceBufferStream::PruneTrackBuffer(const DecodeTimestamp timestamp) {
   // If we don't have the next timestamp, we don't have anything to delete.
   if (timestamp == kNoDecodeTimestamp())
     return;
 
   while (!track_buffer_.empty() &&
          track_buffer_.back()->GetDecodeTimestamp() >= timestamp) {
     track_buffer_.pop_back();
   }
-  DVLOG(3) << __FUNCTION__ << " " << GetStreamTypeName()
+  DVLOG(3) << __func__ << " " << GetStreamTypeName()
            << " Removed all buffers with DTS >= " << timestamp.InSecondsF()
            << ". New track buffer size:" << track_buffer_.size();
 }
 
 void SourceBufferStream::MergeWithAdjacentRangeIfNecessary(
     const RangeList::iterator& range_with_new_buffers_itr) {
   DCHECK(range_with_new_buffers_itr != ranges_.end());
 
   SourceBufferRange* range_with_new_buffers = *range_with_new_buffers_itr;
   RangeList::iterator next_range_itr = range_with_new_buffers_itr;
   ++next_range_itr;
 
   if (next_range_itr == ranges_.end() ||
       !range_with_new_buffers->CanAppendRangeToEnd(**next_range_itr)) {
     return;
   }
 
   bool transfer_current_position = selected_range_ == *next_range_itr;
-  DVLOG(3) << __FUNCTION__ << " " << GetStreamTypeName()
-           << " merging " << RangeToString(*range_with_new_buffers)
-           << " into " << RangeToString(**next_range_itr);
+  DVLOG(3) << __func__ << " " << GetStreamTypeName() << " merging "
+           << RangeToString(*range_with_new_buffers) << " into "
+           << RangeToString(**next_range_itr);
   range_with_new_buffers->AppendRangeToEnd(**next_range_itr,
                                            transfer_current_position);
   // Update |selected_range_| pointer if |range| has become selected after
   // merges.
   if (transfer_current_position)
     SetSelectedRange(range_with_new_buffers);
 
   if (next_range_itr == range_for_next_append_)
     range_for_next_append_ = range_with_new_buffers_itr;
 
   DeleteAndRemoveRange(&next_range_itr);
 }
 
 void SourceBufferStream::Seek(base::TimeDelta timestamp) {
   DCHECK(timestamp >= base::TimeDelta());
-  DVLOG(1) << __FUNCTION__ << " " << GetStreamTypeName()
-           << " (" << timestamp.InSecondsF() << ")";
+  DVLOG(1) << __func__ << " " << GetStreamTypeName() << " ("
+           << timestamp.InSecondsF() << ")";
   ResetSeekState();
 
   seek_buffer_timestamp_ = timestamp;
   seek_pending_ = true;
 
   if (ShouldSeekToStartOfBuffered(timestamp)) {
     ranges_.front()->SeekToStart();
     SetSelectedRange(ranges_.front());
     seek_pending_ = false;
     return;
@@ skipping 14 matching lines @@
   seek_pending_ = false;
 }
 
 bool SourceBufferStream::IsSeekPending() const {
   return seek_pending_ && !IsEndOfStreamReached();
 }
 
 void SourceBufferStream::OnSetDuration(base::TimeDelta duration) {
   DecodeTimestamp duration_dts =
       DecodeTimestamp::FromPresentationTime(duration);
-  DVLOG(1) << __FUNCTION__ << " " << GetStreamTypeName()
-           << " (" << duration.InSecondsF() << ")";
+  DVLOG(1) << __func__ << " " << GetStreamTypeName() << " ("
+           << duration.InSecondsF() << ")";
 
   RangeList::iterator itr = ranges_.end();
   for (itr = ranges_.begin(); itr != ranges_.end(); ++itr) {
     if ((*itr)->GetEndTimestamp() > duration_dts)
       break;
   }
   if (itr == ranges_.end())
     return;
 
   // Need to partially truncate this range.
@@ skipping 14 matching lines @@
     // If we're about to delete the selected range, also reset the seek state.
     DCHECK((*itr)->GetStartTimestamp() >= duration_dts);
     if (*itr == selected_range_)
       ResetSeekState();
     DeleteAndRemoveRange(&itr);
   }
 }
 
 SourceBufferStream::Status SourceBufferStream::GetNextBuffer(
     scoped_refptr<StreamParserBuffer>* out_buffer) {
-  DVLOG(2) << __FUNCTION__ << " " << GetStreamTypeName();
+  DVLOG(2) << __func__ << " " << GetStreamTypeName();
   if (!pending_buffer_.get()) {
     const SourceBufferStream::Status status = GetNextBufferInternal(out_buffer);
     if (status != SourceBufferStream::kSuccess ||
         !SetPendingBuffer(out_buffer)) {
-      DVLOG(2) << __FUNCTION__ << " " << GetStreamTypeName()
+      DVLOG(2) << __func__ << " " << GetStreamTypeName()
                << ": no pending buffer, returning status " << status;
       return status;
     }
   }
 
   if (!pending_buffer_->splice_buffers().empty()) {
     const SourceBufferStream::Status status =
         HandleNextBufferWithSplice(out_buffer);
-    DVLOG(2) << __FUNCTION__ << " " << GetStreamTypeName()
+    DVLOG(2) << __func__ << " " << GetStreamTypeName()
              << ": handled next buffer with splice, returning status "
              << status;
     return status;
   }
 
   DCHECK(pending_buffer_->preroll_buffer().get());
 
   const SourceBufferStream::Status status =
       HandleNextBufferWithPreroll(out_buffer);
-  DVLOG(2) << __FUNCTION__ << " " << GetStreamTypeName()
-           << ": handled next buffer with preroll, returning status "
-           << status;
+  DVLOG(2) << __func__ << " " << GetStreamTypeName()
+           << ": handled next buffer with preroll, returning status " << status;
   return status;
 }
 
 SourceBufferStream::Status SourceBufferStream::HandleNextBufferWithSplice(
     scoped_refptr<StreamParserBuffer>* out_buffer) {
   const BufferQueue& splice_buffers = pending_buffer_->splice_buffers();
   const size_t last_splice_buffer_index = splice_buffers.size() - 1;
 
   // Are there any splice buffers left to hand out?  The last buffer should be
   // handed out separately since it represents the first post-splice buffer.
@@ skipping 68 matching lines @@
     scoped_refptr<StreamParserBuffer>& next_buffer = track_buffer_.front();
 
     // If the next buffer is an audio splice frame, the next effective config id
     // comes from the first splice buffer.
     if (next_buffer->GetSpliceBufferConfigId(0) != current_config_index_) {
       config_change_pending_ = true;
       DVLOG(1) << "Config change (track buffer config ID does not match).";
       return kConfigChange;
     }
 
-    DVLOG(3) << __FUNCTION__ << " Next buffer coming from track_buffer_";
+    DVLOG(3) << __func__ << " Next buffer coming from track_buffer_";
     *out_buffer = next_buffer;
     track_buffer_.pop_front();
     WarnIfTrackBufferExhaustionSkipsForward(*out_buffer);
     last_output_buffer_timestamp_ = (*out_buffer)->GetDecodeTimestamp();
 
     // If the track buffer becomes empty, then try to set the selected range
     // based on the timestamp of this buffer being returned.
     if (track_buffer_.empty()) {
       just_exhausted_track_buffer_ = true;
       SetSelectedRangeIfNeeded(last_output_buffer_timestamp_);
     }
 
     return kSuccess;
   }
 
   DCHECK(track_buffer_.empty());
   if (!selected_range_ || !selected_range_->HasNextBuffer()) {
     if (IsEndOfStreamReached()) {
       return kEndOfStream;
     }
-    DVLOG(3) << __FUNCTION__ << " " << GetStreamTypeName()
+    DVLOG(3) << __func__ << " " << GetStreamTypeName()
              << ": returning kNeedBuffer "
              << (selected_range_ ? "(selected range has no next buffer)"
                                  : "(no selected range)");
     return kNeedBuffer;
   }
 
   if (selected_range_->GetNextConfigId() != current_config_index_) {
     config_change_pending_ = true;
     DVLOG(1) << "Config change (selected range config ID does not match).";
     return kConfigChange;
@@ skipping 72 matching lines @@
 }
 
 void SourceBufferStream::SeekAndSetSelectedRange(
     SourceBufferRange* range, DecodeTimestamp seek_timestamp) {
   if (range)
     range->Seek(seek_timestamp);
   SetSelectedRange(range);
 }
 
 void SourceBufferStream::SetSelectedRange(SourceBufferRange* range) {
-  DVLOG(1) << __FUNCTION__ << " " << GetStreamTypeName() << ": "
-           << selected_range_ << " "
-           << (selected_range_ ? RangeToString(*selected_range_) : "")
+  DVLOG(1) << __func__ << " " << GetStreamTypeName() << ": " << selected_range_
+           << " " << (selected_range_ ? RangeToString(*selected_range_) : "")
            << " -> " << range << " " << (range ? RangeToString(*range) : "");
   if (selected_range_)
     selected_range_->ResetNextBufferPosition();
   DCHECK(!range || range->HasNextBufferPosition());
   selected_range_ = range;
 }
 
 Ranges<base::TimeDelta> SourceBufferStream::GetBufferedTime() const {
   Ranges<base::TimeDelta> ranges;
   for (RangeList::const_iterator itr = ranges_.begin();
@@ skipping 155 matching lines @@
     current_config_index_ = track_buffer_.front()->GetSpliceBufferConfigId(0);
     return;
   }
 
   if (selected_range_ && selected_range_->HasNextBuffer())
     current_config_index_ = selected_range_->GetNextConfigId();
 }
 
 void SourceBufferStream::SetSelectedRangeIfNeeded(
     const DecodeTimestamp timestamp) {
-  DVLOG(2) << __FUNCTION__ << " " << GetStreamTypeName()
-           << "(" << timestamp.InSecondsF() << ")";
+  DVLOG(2) << __func__ << " " << GetStreamTypeName() << "("
+           << timestamp.InSecondsF() << ")";
 
   if (selected_range_) {
     DCHECK(track_buffer_.empty());
     return;
   }
 
   if (!track_buffer_.empty()) {
     DCHECK(!selected_range_);
     return;
   }
 
   DecodeTimestamp start_timestamp = timestamp;
 
   // If the next buffer timestamp is not known then use a timestamp just after
   // the timestamp on the last buffer returned by GetNextBuffer().
   if (start_timestamp == kNoDecodeTimestamp()) {
     if (last_output_buffer_timestamp_ == kNoDecodeTimestamp()) {
-      DVLOG(2) << __FUNCTION__ << " " << GetStreamTypeName()
+      DVLOG(2) << __func__ << " " << GetStreamTypeName()
                << " no previous output timestamp";
       return;
     }
 
     start_timestamp = last_output_buffer_timestamp_ +
         base::TimeDelta::FromInternalValue(1);
   }
 
   DecodeTimestamp seek_timestamp =
       FindNewSelectedRangeSeekTimestamp(start_timestamp);
 
   // If we don't have buffered data to seek to, then return.
   if (seek_timestamp == kNoDecodeTimestamp()) {
-      DVLOG(2) << __FUNCTION__ << " " << GetStreamTypeName()
-               << " couldn't find new selected range seek timestamp";
-      return;
+    DVLOG(2) << __func__ << " " << GetStreamTypeName()
+             << " couldn't find new selected range seek timestamp";
+    return;
   }
 
   DCHECK(track_buffer_.empty());
   SeekAndSetSelectedRange(*FindExistingRangeFor(seek_timestamp),
                           seek_timestamp);
 }
 
 DecodeTimestamp SourceBufferStream::FindNewSelectedRangeSeekTimestamp(
     const DecodeTimestamp start_timestamp) {
   DCHECK(start_timestamp != kNoDecodeTimestamp());
@@ skipping 19 matching lines @@
     if (start_timestamp < range_start &&
         start_timestamp_plus_fudge >= range_start) {
       search_timestamp = range_start;
     }
     DecodeTimestamp keyframe_timestamp =
         (*itr)->NextKeyframeTimestamp(search_timestamp);
     if (keyframe_timestamp != kNoDecodeTimestamp())
       return keyframe_timestamp;
   }
 
-  DVLOG(2) << __FUNCTION__ << " " << GetStreamTypeName()
+  DVLOG(2) << __func__ << " " << GetStreamTypeName()
            << " no buffered data for dts=" << start_timestamp.InSecondsF();
   return kNoDecodeTimestamp();
 }
 
 DecodeTimestamp SourceBufferStream::FindKeyframeAfterTimestamp(
     const DecodeTimestamp timestamp) {
   DCHECK(timestamp != kNoDecodeTimestamp());
 
   RangeList::iterator itr = FindExistingRangeFor(timestamp);
 
@@ skipping 21 matching lines @@
 SourceBufferStream::Type SourceBufferStream::GetType() const {
   if (!audio_configs_.empty())
     return kAudio;
   if (!video_configs_.empty())
     return kVideo;
   DCHECK_NE(text_track_config_.kind(), kTextNone);
   return kText;
 }
 
 void SourceBufferStream::DeleteAndRemoveRange(RangeList::iterator* itr) {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
 
   DCHECK(*itr != ranges_.end());
   if (**itr == selected_range_) {
-    DVLOG(1) << __FUNCTION__ << " deleting selected range.";
+    DVLOG(1) << __func__ << " deleting selected range.";
     SetSelectedRange(NULL);
   }
 
   if (*itr == range_for_next_append_) {
-    DVLOG(1) << __FUNCTION__ << " deleting range_for_next_append_.";
+    DVLOG(1) << __func__ << " deleting range_for_next_append_.";
     range_for_next_append_ = ranges_.end();
     last_appended_buffer_timestamp_ = kNoDecodeTimestamp();
     last_appended_buffer_is_keyframe_ = false;
   }
 
   delete **itr;
   *itr = ranges_.erase(*itr);
 }
 
 void SourceBufferStream::GenerateSpliceFrame(const BufferQueue& new_buffers) {
@@ skipping 114 matching lines @@
     return false;
 
   DCHECK_NE(have_splice_buffers, have_preroll_buffer);
   splice_buffers_index_ = 0;
   pending_buffer_.swap(*out_buffer);
   pending_buffers_complete_ = false;
   return true;
 }
 
 }  // namespace media