Use __func__ instead of __FUNCTION__.

media/filters/gpu_video_decoder.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/gpu_video_decoder.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 211 matching lines @@
   needs_bitstream_conversion_ = (config.codec() == kCodecH264);
   requires_texture_copy_ =
       !!(capabilities.flags &
          VideoDecodeAccelerator::Capabilities::REQUIRES_TEXTURE_COPY);
   supports_deferred_initialization_ = !!(
       capabilities.flags &
       VideoDecodeAccelerator::Capabilities::SUPPORTS_DEFERRED_INITIALIZATION);
   output_cb_ = output_cb;
 
   if (config.is_encrypted() && !supports_deferred_initialization_) {
-    DVLOG(1) << __FUNCTION__
+    DVLOG(1) << __func__
              << " Encrypted stream requires deferred initialialization.";
     bound_init_cb.Run(false);
     return;
   }
 
   if (previously_initialized) {
-    DVLOG(3) << __FUNCTION__
+    DVLOG(3) << __func__
              << " Expecting initialized VDA to detect in-stream config change.";
     // Reinitialization with a different config (but same codec and profile).
     // VDA should handle it by detecting this in-stream by itself,
     // no need to notify it.
     bound_init_cb.Run(true);
     return;
   }
 
   vda_ = factories_->CreateVideoDecodeAccelerator();
   if (!vda_) {
@@ skipping 57 matching lines @@
   }
 
   // If deferred initialization is not supported, initialization is complete.
   // Otherwise, a call to NotifyInitializationComplete will follow with the
   // result of deferred initialization.
   if (!supports_deferred_initialization_)
     base::ResetAndReturn(&init_cb_).Run(true);
 }
 
 void GpuVideoDecoder::NotifyInitializationComplete(bool success) {
-  DVLOG_IF(1, !success) << __FUNCTION__ << " Deferred initialization failed.";
+  DVLOG_IF(1, !success) << __func__ << " Deferred initialization failed.";
   DCHECK(!init_cb_.is_null());
 
   base::ResetAndReturn(&init_cb_).Run(success);
 }
 
 void GpuVideoDecoder::DestroyPictureBuffers(PictureBufferMap* buffers) {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   for (PictureBufferMap::iterator it = buffers->begin(); it != buffers->end();
        ++it) {
     for (uint32_t id : it->second.texture_ids())
@@ skipping 17 matching lines @@
     assigned_picture_buffers_.erase(it->first);
   }
   DestroyPictureBuffers(&assigned_picture_buffers_);
 }
 
 void GpuVideoDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
                              const DecodeCB& decode_cb) {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   DCHECK(pending_reset_cb_.is_null());
 
-  DVLOG(3) << __FUNCTION__ << " " << buffer->AsHumanReadableString();
+  DVLOG(3) << __func__ << " " << buffer->AsHumanReadableString();
 
   DecodeCB bound_decode_cb = BindToCurrentLoop(decode_cb);
 
   if (state_ == kError || !vda_) {
     bound_decode_cb.Run(DecodeStatus::DECODE_ERROR);
     return;
   }
 
   switch (state_) {
     case kDecoderDrained:
       state_ = kNormal;
       // Fall-through.
     case kNormal:
       break;
     case kDrainingDecoder:
     case kError:
       NOTREACHED();
       return;
   }
 
   DCHECK_EQ(state_, kNormal);
 
   if (buffer->end_of_stream()) {
-    DVLOG(3) << __FUNCTION__ << " Initiating Flush for EOS.";
+    DVLOG(3) << __func__ << " Initiating Flush for EOS.";
     state_ = kDrainingDecoder;
     eos_decode_cb_ = bound_decode_cb;
     vda_->Flush();
     return;
   }
 
   size_t size = buffer->data_size();
   std::unique_ptr<SHMBuffer> shm_buffer = GetSHM(size);
   if (!shm_buffer) {
     bound_decode_cb.Run(DecodeStatus::DECODE_ERROR);
@@ skipping 169 matching lines @@
     NotifyError(VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
   PictureBuffer& pb = it->second;
   if (picture.size_changed()) {
     // Update the PictureBuffer size to match that of the Picture. Some VDA's
     // (e.g. Android) will handle resolution changes internally without
     // requesting new PictureBuffers. Sending a Picture of unmatched size is
     // the signal that we should update the size of our PictureBuffer.
     DCHECK(pb.size() != picture.visible_rect().size());
-    DVLOG(3) << __FUNCTION__ << " Updating size of PictureBuffer[" << pb.id()
+    DVLOG(3) << __func__ << " Updating size of PictureBuffer[" << pb.id()
              << "] from:" << pb.size().ToString()
              << " to:" << picture.visible_rect().size().ToString();
     pb.set_size(picture.visible_rect().size());
   }
 
   // Update frame's timestamp.
   base::TimeDelta timestamp;
   // Some of the VDAs like DXVA, and VTVDA don't support and thus don't provide
   // us with visible size in picture.size, passing (0, 0) instead, so for those
   // cases drop it and use config information instead.
@@ skipping 144 matching lines @@
     return;
   }
 
   PutSHM(base::WrapUnique(it->second.shm_buffer));
   it->second.done_cb.Run(state_ == kError ? DecodeStatus::DECODE_ERROR
                                           : DecodeStatus::OK);
   bitstream_buffers_in_decoder_.erase(it);
 }
 
 GpuVideoDecoder::~GpuVideoDecoder() {
-  DVLOG(3) << __FUNCTION__;
+  DVLOG(3) << __func__;
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
 
   if (vda_)
     DestroyVDA();
   DCHECK(assigned_picture_buffers_.empty());
 
   if (!init_cb_.is_null())
     base::ResetAndReturn(&init_cb_).Run(false);
   if (!request_surface_cb_.is_null())
     base::ResetAndReturn(&request_surface_cb_).Run(SurfaceCreatedCB());
@@ skipping 78 matching lines @@
   }
   return false;
 }
 
 void GpuVideoDecoder::DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent()
     const {
   DCHECK(factories_->GetTaskRunner()->BelongsToCurrentThread());
 }
 
 }  // namespace media