Use __func__ instead of __FUNCTION__.

media/cdm/cdm_adapter.cc

 // Copyright 2015 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/cdm/cdm_adapter.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 533 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   cdm::InputBuffer input_buffer;
   std::vector<cdm::SubsampleEntry> subsamples;
   std::unique_ptr<DecryptedBlockImpl> decrypted_block(new DecryptedBlockImpl());
 
   ToCdmInputBuffer(encrypted, &subsamples, &input_buffer);
   cdm::Status status = cdm_->Decrypt(input_buffer, decrypted_block.get());
 
   if (status != cdm::kSuccess) {
-    DVLOG(1) << __FUNCTION__ << " failed with cdm::Error " << status;
+    DVLOG(1) << __func__ << " failed with cdm::Error " << status;
     decrypt_cb.Run(ToMediaDecryptorStatus(status), nullptr);
     return;
   }
 
   scoped_refptr<DecoderBuffer> decrypted_buffer(
       DecoderBuffer::CopyFrom(decrypted_block->DecryptedBuffer()->Data(),
                               decrypted_block->DecryptedBuffer()->Size()));
   decrypted_buffer->set_timestamp(
       base::TimeDelta::FromMicroseconds(decrypted_block->Timestamp()));
   decrypt_cb.Run(Decryptor::kSuccess, decrypted_buffer);
@@ skipping 15 matching lines @@
       ChannelLayoutToChannelCount(config.channel_layout());
   cdm_decoder_config.bits_per_channel = config.bits_per_channel();
   cdm_decoder_config.samples_per_second = config.samples_per_second();
   cdm_decoder_config.extra_data =
       const_cast<uint8_t*>(config.extra_data().data());
   cdm_decoder_config.extra_data_size = config.extra_data().size();
 
   cdm::Status status = cdm_->InitializeAudioDecoder(cdm_decoder_config);
   if (status != cdm::kSuccess && status != cdm::kDeferredInitialization) {
     // DCHECK(status == cdm::kSessionError); http://crbug.com/570486
-    DVLOG(1) << __FUNCTION__ << " failed with cdm::Error " << status;
+    DVLOG(1) << __func__ << " failed with cdm::Error " << status;
     init_cb.Run(false);
     return;
   }
 
   audio_samples_per_second_ = config.samples_per_second();
   audio_channel_layout_ = config.channel_layout();
 
   if (status == cdm::kDeferredInitialization) {
-    DVLOG(1) << "Deferred initialization in " << __FUNCTION__;
+    DVLOG(1) << "Deferred initialization in " << __func__;
     audio_init_cb_ = init_cb;
     return;
   }
 
   init_cb.Run(true);
 }
 
 void CdmAdapter::InitializeVideoDecoder(const VideoDecoderConfig& config,
                                         const DecoderInitCB& init_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(video_init_cb_.is_null());
 
   cdm::VideoDecoderConfig cdm_decoder_config;
   cdm_decoder_config.codec = ToCdmVideoCodec(config.codec());
   cdm_decoder_config.profile = ToCdmVideoCodecProfile(config.profile());
   cdm_decoder_config.format = ToCdmVideoFormat(config.format());
   cdm_decoder_config.coded_size.width = config.coded_size().width();
   cdm_decoder_config.coded_size.height = config.coded_size().height();
   cdm_decoder_config.extra_data =
       const_cast<uint8_t*>(config.extra_data().data());
   cdm_decoder_config.extra_data_size = config.extra_data().size();
 
   cdm::Status status = cdm_->InitializeVideoDecoder(cdm_decoder_config);
   if (status != cdm::kSuccess && status != cdm::kDeferredInitialization) {
     // DCHECK(status == cdm::kSessionError); http://crbug.com/570486
-    DVLOG(1) << __FUNCTION__ << " failed with cdm::Error " << status;
+    DVLOG(1) << __func__ << " failed with cdm::Error " << status;
     init_cb.Run(false);
     return;
   }
 
   natural_size_ = config.natural_size();
 
   if (status == cdm::kDeferredInitialization) {
-    DVLOG(1) << "Deferred initialization in " << __FUNCTION__;
+    DVLOG(1) << "Deferred initialization in " << __func__;
     video_init_cb_ = init_cb;
     return;
   }
 
   init_cb.Run(true);
 }
 
 void CdmAdapter::DecryptAndDecodeAudio(
     const scoped_refptr<DecoderBuffer>& encrypted,
     const AudioDecodeCB& audio_decode_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   cdm::InputBuffer input_buffer;
   std::vector<cdm::SubsampleEntry> subsamples;
   std::unique_ptr<AudioFramesImpl> audio_frames(new AudioFramesImpl());
 
   ToCdmInputBuffer(encrypted, &subsamples, &input_buffer);
   cdm::Status status =
       cdm_->DecryptAndDecodeSamples(input_buffer, audio_frames.get());
 
   const Decryptor::AudioFrames empty_frames;
   if (status != cdm::kSuccess) {
-    DVLOG(1) << __FUNCTION__ << " failed with cdm::Error " << status;
+    DVLOG(1) << __func__ << " failed with cdm::Error " << status;
     audio_decode_cb.Run(ToMediaDecryptorStatus(status), empty_frames);
     return;
   }
 
   Decryptor::AudioFrames audio_frame_list;
   DCHECK(audio_frames->FrameBuffer());
   if (!AudioFramesDataToAudioFrames(std::move(audio_frames),
                                     &audio_frame_list)) {
-    DVLOG(1) << __FUNCTION__ << " unable to convert Audio Frames";
+    DVLOG(1) << __func__ << " unable to convert Audio Frames";
     audio_decode_cb.Run(Decryptor::kError, empty_frames);
     return;
   }
 
   audio_decode_cb.Run(Decryptor::kSuccess, audio_frame_list);
 }
 
 void CdmAdapter::DecryptAndDecodeVideo(
     const scoped_refptr<DecoderBuffer>& encrypted,
     const VideoDecodeCB& video_decode_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  DVLOG(3) << __FUNCTION__
-           << " encrypted: " << encrypted->AsHumanReadableString();
+  DVLOG(3) << __func__ << " encrypted: " << encrypted->AsHumanReadableString();
 
   cdm::InputBuffer input_buffer;
   std::vector<cdm::SubsampleEntry> subsamples;
   std::unique_ptr<VideoFrameImpl> video_frame =
       allocator_->CreateCdmVideoFrame();
 
   ToCdmInputBuffer(encrypted, &subsamples, &input_buffer);
   cdm::Status status =
       cdm_->DecryptAndDecodeFrame(input_buffer, video_frame.get());
 
   if (status != cdm::kSuccess) {
-    DVLOG(1) << __FUNCTION__ << " failed with cdm::Error " << status;
+    DVLOG(1) << __func__ << " failed with cdm::Error " << status;
     video_decode_cb.Run(ToMediaDecryptorStatus(status), nullptr);
     return;
   }
 
   scoped_refptr<VideoFrame> decoded_frame =
       video_frame->TransformToVideoFrame(natural_size_);
   video_decode_cb.Run(Decryptor::kSuccess, decoded_frame);
 }
 
 void CdmAdapter::ResetDecoder(StreamType stream_type) {
@@ skipping 173 matching lines @@
 
   // TODO(jrummell): If output protection is available, use it.
   NOTIMPLEMENTED();
   cdm_->OnQueryOutputProtectionStatus(cdm::kQueryFailed, 0, 0);
 }
 
 void CdmAdapter::OnDeferredInitializationDone(cdm::StreamType stream_type,
                                               cdm::Status decoder_status) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DVLOG_IF(1, decoder_status != cdm::kSuccess)
-      << __FUNCTION__ << " failed with cdm::Error " << decoder_status;
+      << __func__ << " failed with cdm::Error " << decoder_status;
 
   switch (stream_type) {
     case cdm::kStreamTypeAudio:
       base::ResetAndReturn(&audio_init_cb_)
           .Run(decoder_status == cdm::kSuccess);
       return;
     case cdm::kStreamTypeVideo:
       base::ResetAndReturn(&video_init_cb_)
           .Run(decoder_status == cdm::kSuccess);
       return;
@@ skipping 65 matching lines @@
     result_frames->push_back(frame);
 
     data += frame_size;
     bytes_left -= frame_size;
   } while (bytes_left > 0);
 
   return true;
 }
 
 }  // namespace media