Use __func__ instead of __FUNCTION__.

content/renderer/media/video_track_recorder.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 "content/renderer/media/video_track_recorder.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 507 matching lines @@
 
 VEAEncoder::~VEAEncoder() {
   encoding_task_runner_->PostTask(
       FROM_HERE, base::Bind(&media::VideoEncodeAccelerator::Destroy,
                             base::Unretained(video_encoder_.release())));
 }
 
 void VEAEncoder::RequireBitstreamBuffers(unsigned int /*input_count*/,
                                          const gfx::Size& input_coded_size,
                                          size_t output_buffer_size) {
-  DVLOG(3) << __FUNCTION__;
+  DVLOG(3) << __func__;
   DCHECK(encoding_task_runner_->BelongsToCurrentThread());
 
   vea_requested_input_size_ = input_coded_size;
   output_buffers_.clear();
   std::queue<std::unique_ptr<base::SharedMemory>>().swap(input_buffers_);
 
   for (int i = 0; i < kVEAEncoderOutputBufferCount; ++i) {
     std::unique_ptr<base::SharedMemory> shm =
         gpu_factories_->CreateSharedMemory(output_buffer_size);
     if (shm)
       output_buffers_.push_back(base::WrapUnique(shm.release()));
   }
 
   for (size_t i = 0; i < output_buffers_.size(); ++i)
     UseOutputBitstreamBufferId(i);
 }
 
 void VEAEncoder::BitstreamBufferReady(int32_t bitstream_buffer_id,
                                       size_t payload_size,
                                       bool keyframe,
                                       base::TimeDelta timestamp) {
-  DVLOG(3) << __FUNCTION__;
+  DVLOG(3) << __func__;
   DCHECK(encoding_task_runner_->BelongsToCurrentThread());
 
   base::SharedMemory* output_buffer =
       output_buffers_[bitstream_buffer_id].get();
 
   std::unique_ptr<std::string> data(new std::string);
   data->append(reinterpret_cast<char*>(output_buffer->memory()), payload_size);
 
   const auto front_frame = frames_in_encode_.front();
   frames_in_encode_.pop();
   origin_task_runner_->PostTask(
       FROM_HERE, base::Bind(OnFrameEncodeCompleted, on_encoded_video_callback_,
                             front_frame.first, base::Passed(&data),
                             front_frame.second, keyframe));
   UseOutputBitstreamBufferId(bitstream_buffer_id);
 }
 
 void VEAEncoder::NotifyError(media::VideoEncodeAccelerator::Error error) {
-  DVLOG(3) << __FUNCTION__;
+  DVLOG(3) << __func__;
   DCHECK(encoding_task_runner_->BelongsToCurrentThread());
 
   // TODO(emircan): Notify the owner via a callback.
   error_notified_ = true;
 }
 
 void VEAEncoder::UseOutputBitstreamBufferId(int32_t bitstream_buffer_id) {
-  DVLOG(3) << __FUNCTION__;
+  DVLOG(3) << __func__;
   DCHECK(encoding_task_runner_->BelongsToCurrentThread());
 
   video_encoder_->UseOutputBitstreamBuffer(media::BitstreamBuffer(
       bitstream_buffer_id, output_buffers_[bitstream_buffer_id]->handle(),
       output_buffers_[bitstream_buffer_id]->mapped_size()));
 }
 
 void VEAEncoder::FrameFinished(std::unique_ptr<base::SharedMemory> shm) {
-  DVLOG(3) << __FUNCTION__;
+  DVLOG(3) << __func__;
   DCHECK(encoding_task_runner_->BelongsToCurrentThread());
   input_buffers_.push(std::move(shm));
 }
 
 void VEAEncoder::EncodeOnEncodingTaskRunner(
     const scoped_refptr<VideoFrame>& frame,
     base::TimeTicks capture_timestamp) {
-  DVLOG(3) << __FUNCTION__;
+  DVLOG(3) << __func__;
   DCHECK(encoding_task_runner_->BelongsToCurrentThread());
 
   if (input_size_ != frame->visible_rect().size() && video_encoder_) {
     video_encoder_->Destroy();
     video_encoder_.reset();
   }
 
   if (!video_encoder_)
     ConfigureEncoderOnEncodingTaskRunner(frame->visible_rect().size());
 
@@ skipping 67 matching lines @@
   }
   frames_in_encode_.push(std::make_pair(video_frame, capture_timestamp));
 
   encoding_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&media::VideoEncodeAccelerator::Encode,
                  base::Unretained(video_encoder_.get()), video_frame, false));
 }
 
 void VEAEncoder::ConfigureEncoderOnEncodingTaskRunner(const gfx::Size& size) {
-  DVLOG(3) << __FUNCTION__;
+  DVLOG(3) << __func__;
   DCHECK(encoding_task_runner_->BelongsToCurrentThread());
   DCHECK(gpu_factories_->GetTaskRunner()->BelongsToCurrentThread());
 
   input_size_ = size;
   video_encoder_ = gpu_factories_->CreateVideoEncodeAccelerator();
   if (!video_encoder_ ||
       !video_encoder_->Initialize(media::PIXEL_FORMAT_I420, input_size_, codec_,
                                   bits_per_second_, this)) {
     NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
   }
@@ skipping 390 matching lines @@
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   if (encoder_)
     encoder_->SetPaused(false);
   else
     paused_before_init_ = false;
 }
 
 void VideoTrackRecorder::OnVideoFrameForTesting(
     const scoped_refptr<media::VideoFrame>& frame,
     base::TimeTicks timestamp) {
-  DVLOG(3) << __FUNCTION__;
+  DVLOG(3) << __func__;
 
   if (!encoder_) {
     DCHECK(!initialize_encoder_callback_.is_null());
     initialize_encoder_callback_.Run(frame, timestamp);
   }
 
   encoder_->StartFrameEncode(frame, timestamp);
 }
 
 void VideoTrackRecorder::InitializeEncoder(
     CodecId codec,
     const OnEncodedVideoCB& on_encoded_video_callback,
     int32_t bits_per_second,
     const scoped_refptr<media::VideoFrame>& frame,
     base::TimeTicks capture_time) {
-  DVLOG(3) << __FUNCTION__ << frame->visible_rect().size().ToString();
+  DVLOG(3) << __func__ << frame->visible_rect().size().ToString();
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
 
   MediaStreamVideoSink::DisconnectFromTrack();
 
   const gfx::Size& input_size = frame->visible_rect().size();
   const auto& vea_supported_profile = CodecIdToVEAProfile(codec);
   if (vea_supported_profile != media::VIDEO_CODEC_PROFILE_UNKNOWN &&
       input_size.width() >= kVEAEncoderMinResolutionWidth &&
       input_size.height() >= kVEAEncoderMinResolutionHeight) {
     encoder_ = new VEAEncoder(on_encoded_video_callback, bits_per_second,
@@ skipping 20 matching lines @@
     encoder_->SetPaused(paused_before_init_);
 
   // StartFrameEncode() will be called on Render IO thread.
   MediaStreamVideoSink::ConnectToTrack(
       track_,
       base::Bind(&VideoTrackRecorder::Encoder::StartFrameEncode, encoder_),
       false);
 }
 
 }  // namespace content