Use __func__ instead of __FUNCTION__.

media/filters/chunk_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 "media/filters/chunk_demuxer.h"
 
 #include <algorithm>
 #include <limits>
 #include <list>
 #include <utility>
@@ skipping 336 matching lines @@
   scoped_refptr<StreamParserBuffer> buffer;
 
   switch (state_) {
     case UNINITIALIZED:
       NOTREACHED();
       return;
     case RETURNING_DATA_FOR_READS:
       switch (stream_->GetNextBuffer(&buffer)) {
         case SourceBufferStream::kSuccess:
           status = DemuxerStream::kOk;
-          DVLOG(2) << __FUNCTION__ << ": returning kOk, type " << type_
-                   << ", dts " << buffer->GetDecodeTimestamp().InSecondsF()
-                   << ", pts " << buffer->timestamp().InSecondsF()
-                   << ", dur " << buffer->duration().InSecondsF()
-                   << ", key " << buffer->is_key_frame();
+          DVLOG(2) << __func__ << ": returning kOk, type " << type_ << ", dts "
+                   << buffer->GetDecodeTimestamp().InSecondsF() << ", pts "
+                   << buffer->timestamp().InSecondsF() << ", dur "
+                   << buffer->duration().InSecondsF() << ", key "
+                   << buffer->is_key_frame();
           break;
         case SourceBufferStream::kNeedBuffer:
           // Return early without calling |read_cb_| since we don't have
           // any data to return yet.
-          DVLOG(2) << __FUNCTION__ << ": returning kNeedBuffer, type "
-                   << type_;
+          DVLOG(2) << __func__ << ": returning kNeedBuffer, type " << type_;
           return;
         case SourceBufferStream::kEndOfStream:
           status = DemuxerStream::kOk;
           buffer = StreamParserBuffer::CreateEOSBuffer();
-          DVLOG(2) << __FUNCTION__ << ": returning kOk with EOS buffer, type "
+          DVLOG(2) << __func__ << ": returning kOk with EOS buffer, type "
                    << type_;
           break;
         case SourceBufferStream::kConfigChange:
           status = kConfigChanged;
           buffer = NULL;
-          DVLOG(2) << __FUNCTION__ << ": returning kConfigChange, type "
-                   << type_;
+          DVLOG(2) << __func__ << ": returning kConfigChange, type " << type_;
           break;
       }
       break;
     case RETURNING_ABORT_FOR_READS:
       // Null buffers should be returned in this state since we are waiting
       // for a seek. Any buffers in the SourceBuffer should NOT be returned
       // because they are associated with the seek.
       status = DemuxerStream::kAborted;
       buffer = NULL;
-      DVLOG(2) << __FUNCTION__ << ": returning kAborted, type " << type_;
+      DVLOG(2) << __func__ << ": returning kAborted, type " << type_;
       break;
     case SHUTDOWN:
       status = DemuxerStream::kOk;
       buffer = StreamParserBuffer::CreateEOSBuffer();
-      DVLOG(2) << __FUNCTION__ << ": returning kOk with EOS buffer, type "
-               << type_;
+      DVLOG(2) << __func__ << ": returning kOk with EOS buffer, type " << type_;
       break;
   }
 
   base::ResetAndReturn(&read_cb_).Run(status, buffer);
 }
 
 ChunkDemuxer::ChunkDemuxer(
     const base::Closure& open_cb,
     const EncryptedMediaInitDataCB& encrypted_media_init_data_cb,
     const scoped_refptr<MediaLog>& media_log,
@@ skipping 249 matching lines @@
   bool enabled = false;
   CHECK(audio_stream);
   DCHECK_LE(track_ids.size(), 1u);
   if (track_ids.size() > 0) {
 #if DCHECK_IS_ON()
     base::AutoLock auto_lock(lock_);
     DCHECK(track_id_to_demux_stream_map_[track_ids[0]] == audio_stream);
 #endif
     enabled = true;
   }
-  DVLOG(1) << __FUNCTION__ << ": " << (enabled ? "enabling" : "disabling")
+  DVLOG(1) << __func__ << ": " << (enabled ? "enabling" : "disabling")
            << " audio stream";
   audio_stream->set_enabled(enabled, currTime);
 }
 
 void ChunkDemuxer::OnSelectedVideoTrackChanged(
     const std::vector<MediaTrack::Id>& track_ids,
     base::TimeDelta currTime) {
   // Note: We intentionally don't lock here, since we are not accessing any
   // members directly.
   DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
   bool enabled = false;
   CHECK(video_stream);
   DCHECK_LE(track_ids.size(), 1u);
   if (track_ids.size() > 0) {
 #if DCHECK_IS_ON()
     base::AutoLock auto_lock(lock_);
     DCHECK(track_id_to_demux_stream_map_[track_ids[0]] == video_stream);
 #endif
     enabled = true;
   }
-  DVLOG(1) << __FUNCTION__ << ": " << (enabled ? "enabling" : "disabling")
+  DVLOG(1) << __func__ << ": " << (enabled ? "enabling" : "disabling")
            << " video stream";
   video_stream->set_enabled(enabled, currTime);
 }
 
 bool ChunkDemuxer::EvictCodedFrames(const std::string& id,
                                     base::TimeDelta currentMediaTime,
                                     size_t newDataSize) {
-  DVLOG(1) << __FUNCTION__ << "(" << id << ")"
+  DVLOG(1) << __func__ << "(" << id << ")"
            << " media_time=" << currentMediaTime.InSecondsF()
            << " newDataSize=" << newDataSize;
   base::AutoLock auto_lock(lock_);
 
   // Note: The direct conversion from PTS to DTS is safe here, since we don't
   // need to know currentTime precisely for GC. GC only needs to know which GOP
   // currentTime points to.
   DecodeTimestamp media_time_dts =
       DecodeTimestamp::FromPresentationTime(currentMediaTime);
 
   DCHECK(!id.empty());
   MediaSourceStateMap::const_iterator itr = source_state_map_.find(id);
   if (itr == source_state_map_.end()) {
-    LOG(WARNING) << __FUNCTION__ << " stream " << id << " not found";
+    LOG(WARNING) << __func__ << " stream " << id << " not found";
     return false;
   }
   return itr->second->EvictCodedFrames(media_time_dts, newDataSize);
 }
 
 bool ChunkDemuxer::AppendData(const std::string& id,
                               const uint8_t* data,
                               size_t length,
                               TimeDelta append_window_start,
                               TimeDelta append_window_end,
@@ skipping 463 matching lines @@
   // Per April 1, 2014 MSE spec editor's draft:
   // https://dvcs.w3.org/hg/html-media/raw-file/d471a4412040/media-source/
   //     media-source.html#sourcebuffer-coded-frame-processing
   // 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.
 
   if (new_duration <= duration_)
     return;
 
-  DVLOG(2) << __FUNCTION__ << ": Increasing duration: "
-           << duration_.InSecondsF() << " -> " << new_duration.InSecondsF();
+  DVLOG(2) << __func__ << ": Increasing duration: " << duration_.InSecondsF()
+           << " -> " << new_duration.InSecondsF();
 
   UpdateDuration(new_duration);
 }
 
 void ChunkDemuxer::DecreaseDurationIfNecessary() {
   lock_.AssertAcquired();
 
   TimeDelta max_duration;
 
   for (MediaSourceStateMap::const_iterator itr = source_state_map_.begin();
@@ skipping 58 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (MediaSourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media