Use __func__ instead of __FUNCTION__.

content/renderer/media/html_video_element_capturer_source.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/html_video_element_capturer_source.h"
 
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 44 matching lines @@
 
 HtmlVideoElementCapturerSource::~HtmlVideoElementCapturerSource() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void HtmlVideoElementCapturerSource::GetCurrentSupportedFormats(
     int max_requested_width,
     int max_requested_height,
     double max_requested_frame_rate,
     const VideoCaptureDeviceFormatsCB& callback) {
-  DVLOG(3) << __FUNCTION__ << "{ max_requested_height = "
-           << max_requested_height << "}) { max_requested_width = "
-           << max_requested_width << "}) { max_requested_frame_rate = "
-           << max_requested_frame_rate << "})";
+  DVLOG(3) << __func__ << "{ max_requested_height = " << max_requested_height
+           << "}) { max_requested_width = " << max_requested_width
+           << "}) { max_requested_frame_rate = " << max_requested_frame_rate
+           << "})";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // WebMediaPlayer has a setRate() but can't be read back.
   // TODO(mcasas): Add getRate() to WMPlayer and/or fix the spec to allow users
   // to specify it.
   const media::VideoCaptureFormat format(
       web_media_player_->naturalSize(),
       MediaStreamVideoSource::kDefaultFrameRate,
       media::PIXEL_FORMAT_I420);
   media::VideoCaptureFormats formats;
   formats.push_back(format);
   callback.Run(formats);
 }
 
 void HtmlVideoElementCapturerSource::StartCapture(
     const media::VideoCaptureParams& params,
     const VideoCaptureDeliverFrameCB& new_frame_callback,
     const RunningCallback& running_callback) {
-  DVLOG(3) << __FUNCTION__ << " requested "
+  DVLOG(3) << __func__ << " requested "
            << media::VideoCaptureFormat::ToString(params.requested_format);
   DCHECK(params.requested_format.IsValid());
   DCHECK(thread_checker_.CalledOnValidThread());
 
   running_callback_ = running_callback;
   if (!web_media_player_ || !web_media_player_->hasVideo()) {
     running_callback_.Run(false);
     return;
   }
   const blink::WebSize resolution = web_media_player_->naturalSize();
@@ skipping 11 matching lines @@
                std::min(static_cast<float>(media::limits::kMaxFramesPerSecond),
                         params.requested_format.frame_rate));
 
   running_callback_.Run(true);
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&HtmlVideoElementCapturerSource::sendNewFrame,
                             weak_factory_.GetWeakPtr()));
 }
 
 void HtmlVideoElementCapturerSource::StopCapture() {
-  DVLOG(3) << __FUNCTION__;
+  DVLOG(3) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   running_callback_.Reset();
   new_frame_callback_.Reset();
   next_capture_time_ = base::TimeTicks();
 }
 
 void HtmlVideoElementCapturerSource::sendNewFrame() {
-  DVLOG(3) << __FUNCTION__;
+  DVLOG(3) << __func__;
   TRACE_EVENT0("video", "HtmlVideoElementCapturerSource::sendNewFrame");
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!web_media_player_ || new_frame_callback_.is_null())
     return;
 
   const base::TimeTicks current_time = base::TimeTicks::Now();
   const blink::WebSize resolution = web_media_player_->naturalSize();
 
   SkCanvas* canvas = surface_->getCanvas();
@@ skipping 56 matching lines @@
       next_capture_time_ = current_time;
   }
   // Schedule next capture.
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&HtmlVideoElementCapturerSource::sendNewFrame,
                             weak_factory_.GetWeakPtr()),
       next_capture_time_ - current_time);
 }
 
 }  // namespace content