Use __func__ instead of __FUNCTION__.

content/renderer/media/media_stream_video_capturer_source.cc

 // Copyright 2014 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/media_stream_video_capturer_source.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 151 matching lines @@
     } else {
       // Constraints specify a minimum resolution that is smaller than the
       // maximum resolution and has a different aspect ratio (possibly even
       // 0x0). This indicates any frame resolution and aspect ratio is
       // acceptable.
       params->resolution_change_policy =
           media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT;
     }
   }
 
-  DVLOG(1) << __FUNCTION__ << " "
+  DVLOG(1) << __func__ << " "
            << media::VideoCaptureFormat::ToString(params->requested_format)
            << " with resolution change policy "
            << params->resolution_change_policy;
 }
 
 // Interprets the properties in |constraints| to override values in |params| and
 // determine the power line frequency.
 void SetPowerLineFrequencyParamFromConstraints(
     const blink::WebMediaConstraints& constraints,
     media::VideoCaptureParams* params) {
@@ skipping 122 matching lines @@
   running_callback_ = running_callback;
 
   stop_capture_cb_ = manager_->StartCapture(
       session_id_, params, media::BindToCurrentLoop(base::Bind(
                                &LocalVideoCapturerSource::OnStateUpdate,
                                weak_factory_.GetWeakPtr())),
       new_frame_callback);
 }
 
 void LocalVideoCapturerSource::RequestRefreshFrame() {
-  DVLOG(3) << __FUNCTION__;
+  DVLOG(3) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   if (stop_capture_cb_.is_null())
     return;  // Do not request frames if the source is stopped.
   manager_->RequestRefreshFrame(session_id_);
 }
 
 void LocalVideoCapturerSource::StopCapture() {
-  DVLOG(3) << __FUNCTION__;
+  DVLOG(3) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   // Immediately make sure we don't provide more frames.
   if (!stop_capture_cb_.is_null())
     base::ResetAndReturn(&stop_capture_cb_).Run();
   running_callback_.Reset();
   // Invalidate any potential format enumerations going on.
   formats_enumerated_callback_.Reset();
 }
 
 void LocalVideoCapturerSource::OnStateUpdate(VideoCaptureState state) {
-  DVLOG(3) << __FUNCTION__ << " state = " << state;
+  DVLOG(3) << __func__ << " state = " << state;
   DCHECK(thread_checker_.CalledOnValidThread());
   if (running_callback_.is_null())
     return;
   const bool is_started_ok = state == VIDEO_CAPTURE_STATE_STARTED;
   running_callback_.Run(is_started_ok);
   if (!is_started_ok)
     running_callback_.Reset();
 }
 
 void LocalVideoCapturerSource::OnDeviceFormatsInUseReceived(
     const media::VideoCaptureFormats& formats_in_use) {
-  DVLOG(3) << __FUNCTION__ << ", #formats received: " << formats_in_use.size();
+  DVLOG(3) << __func__ << ", #formats received: " << formats_in_use.size();
   DCHECK(thread_checker_.CalledOnValidThread());
   // StopCapture() might have destroyed |formats_enumerated_callback_| before
   // arriving here.
   if (formats_enumerated_callback_.is_null())
     return;
   if (formats_in_use.size()) {
     base::ResetAndReturn(&formats_enumerated_callback_).Run(formats_in_use);
     return;
   }
 
   // The device doesn't seem to have formats in use so try and retrieve the
   // whole list of supported ones.
   manager_->GetDeviceSupportedFormats(
       session_id_,
       media::BindToCurrentLoop(
           base::Bind(
               &LocalVideoCapturerSource::OnDeviceSupportedFormatsEnumerated,
               weak_factory_.GetWeakPtr())));
 }
 
 void LocalVideoCapturerSource::OnDeviceSupportedFormatsEnumerated(
     const media::VideoCaptureFormats& formats) {
-  DVLOG(3) << __FUNCTION__ << ", #formats received: " << formats.size();
+  DVLOG(3) << __func__ << ", #formats received: " << formats.size();
   DCHECK(thread_checker_.CalledOnValidThread());
   // StopCapture() might have destroyed |formats_enumerated_callback_| before
   // arriving here.
   if (formats_enumerated_callback_.is_null())
     return;
   if (formats.size()) {
     base::ResetAndReturn(&formats_enumerated_callback_).Run(formats);
     return;
   }
 
@@ skipping 77 matching lines @@
 void MediaStreamVideoCapturerSource::OnStarted(bool result) {
   OnStartDone(result ? MEDIA_DEVICE_OK : MEDIA_DEVICE_TRACK_START_FAILURE);
 }
 
 const char*
 MediaStreamVideoCapturerSource::GetPowerLineFrequencyForTesting() const {
   return kPowerLineFrequency;
 }
 
 }  // namespace content