Use __func__ instead of __FUNCTION__.

media/formats/webm/webm_cluster_parser.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/formats/webm/webm_cluster_parser.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 545 matching lines @@
   // estimation may still apply in cases of encryption and codecs for which
   // we do not extract encoded duration. Within a cluster, estimates are applied
   // as Block Timecode deltas, or once the whole cluster is parsed in the case
   // of the last Block in the cluster. See Track::AddBuffer and
   // ApplyDurationEstimateIfNeeded().
   if (encoded_duration != kNoTimestamp) {
     DCHECK(encoded_duration != kInfiniteDuration);
     DCHECK(encoded_duration > base::TimeDelta());
     buffer->set_duration(encoded_duration);
 
-    DVLOG(3) << __FUNCTION__ << " : "
+    DVLOG(3) << __func__ << " : "
              << "Using encoded duration " << encoded_duration.InSecondsF();
 
     if (block_duration_time_delta != kNoTimestamp) {
       base::TimeDelta duration_difference =
           block_duration_time_delta - encoded_duration;
 
       const auto kWarnDurationDiff =
           base::TimeDelta::FromMicroseconds(timecode_multiplier_ * 2);
       if (duration_difference.magnitude() > kWarnDurationDiff) {
         LIMITED_MEDIA_LOG(DEBUG, media_log_, num_duration_errors_,
@@ skipping 49 matching lines @@
   DCHECK(ready_buffers_.empty());
   DCHECK(DecodeTimestamp() <= before_timestamp);
   DCHECK(kNoDecodeTimestamp() != before_timestamp);
 
   if (buffers_.empty())
     return;
 
   if (buffers_.back()->GetDecodeTimestamp() < before_timestamp) {
     // All of |buffers_| are ready.
     ready_buffers_.swap(buffers_);
-    DVLOG(3) << __FUNCTION__ << " : " << track_num_ << " All "
+    DVLOG(3) << __func__ << " : " << track_num_ << " All "
              << ready_buffers_.size() << " are ready: before upper bound ts "
              << before_timestamp.InSecondsF();
     return;
   }
 
   // Not all of |buffers_| are ready yet. Move any that are ready to
   // |ready_buffers_|.
   while (true) {
     const scoped_refptr<StreamParserBuffer>& buffer = buffers_.front();
     if (buffer->GetDecodeTimestamp() >= before_timestamp)
       break;
     ready_buffers_.push_back(buffer);
     buffers_.pop_front();
     DCHECK(!buffers_.empty());
   }
 
-  DVLOG(3) << __FUNCTION__ << " : " << track_num_ << " Only "
+  DVLOG(3) << __func__ << " : " << track_num_ << " Only "
            << ready_buffers_.size() << " ready, " << buffers_.size()
            << " at or after upper bound ts " << before_timestamp.InSecondsF();
 }
 
 bool WebMClusterParser::Track::AddBuffer(
     const scoped_refptr<StreamParserBuffer>& buffer) {
   DVLOG(2) << "AddBuffer() : " << track_num_
            << " ts " << buffer->timestamp().InSecondsF()
            << " dur " << buffer->duration().InSecondsF()
            << " kf " << buffer->is_key_frame()
@@ skipping 43 matching lines @@
   }
 
   LIMITED_MEDIA_LOG(INFO, media_log_, num_duration_estimates_,
                     kMaxDurationEstimateLogs)
       << "Estimating WebM block duration to be "
       << estimated_duration.InMilliseconds()
       << "ms for the last (Simple)Block in the Cluster for this Track. Use "
          "BlockGroups with BlockDurations at the end of each Track in a "
          "Cluster to avoid estimation.";
 
-  DVLOG(2) << __FUNCTION__ << " new dur : ts "
+  DVLOG(2) << __func__ << " new dur : ts "
            << last_added_buffer_missing_duration_->timestamp().InSecondsF()
            << " dur "
            << last_added_buffer_missing_duration_->duration().InSecondsF()
            << " kf " << last_added_buffer_missing_duration_->is_key_frame()
            << " size " << last_added_buffer_missing_duration_->data_size();
 
   // Don't use the applied duration as a future estimation (don't use
   // QueueBuffer() here.)
   buffers_.push_back(last_added_buffer_missing_duration_);
   last_added_buffer_missing_duration_ = NULL;
@@ skipping 60 matching lines @@
     }
   }
 
   buffers_.push_back(buffer);
   return true;
 }
 
 base::TimeDelta WebMClusterParser::Track::GetDurationEstimate() {
   base::TimeDelta duration = estimated_next_frame_duration_;
   if (duration != kNoTimestamp) {
-    DVLOG(3) << __FUNCTION__ << " : using estimated duration";
+    DVLOG(3) << __func__ << " : using estimated duration";
   } else {
-    DVLOG(3) << __FUNCTION__ << " : using hardcoded default duration";
+    DVLOG(3) << __func__ << " : using hardcoded default duration";
     if (is_video_) {
       duration = base::TimeDelta::FromMilliseconds(
           kDefaultVideoBufferDurationInMs);
     } else {
       duration = base::TimeDelta::FromMilliseconds(
           kDefaultAudioBufferDurationInMs);
     }
   }
 
   DCHECK(duration > base::TimeDelta());
@@ skipping 54 matching lines @@
 WebMClusterParser::FindTextTrack(int track_num) {
   const TextTrackMap::iterator it = text_track_map_.find(track_num);
 
   if (it == text_track_map_.end())
     return NULL;
 
   return &it->second;
 }
 
 }  // namespace media