Use __func__ instead of __FUNCTION__.

content/renderer/media/webmediaplayer_ms.cc

 // Copyright 2013 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/webmediaplayer_ms.h"
 
 #include <stddef.h>
 #include <limits>
 #include <string>
 #include <utility>
@@ skipping 52 matching lines @@
       worker_task_runner_(worker_task_runner),
       gpu_factories_(gpu_factories),
       compositor_task_runner_(compositor_task_runner),
       initial_audio_output_device_id_(sink_id.utf8()),
       initial_security_origin_(security_origin.isNull()
                                    ? url::Origin()
                                    : url::Origin(security_origin)),
       volume_(1.0),
       volume_multiplier_(1.0),
       should_play_upon_shown_(false) {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(client);
   if (delegate_)
     delegate_id_ = delegate_->AddObserver(this);
 
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_CREATED));
 }
 
 WebMediaPlayerMS::~WebMediaPlayerMS() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Destruct compositor resources in the proper order.
   get_client()->setWebLayer(nullptr);
   if (video_weblayer_)
     static_cast<cc::VideoLayer*>(video_weblayer_->layer())->StopUsingProvider();
   if (compositor_)
     compositor_task_runner_->DeleteSoon(FROM_HERE, compositor_.release());
 
   if (video_frame_provider_)
     video_frame_provider_->Stop();
 
   if (audio_renderer_)
     audio_renderer_->Stop();
 
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_DESTROYED));
 
   if (delegate_) {
     delegate_->PlayerGone(delegate_id_);
     delegate_->RemoveObserver(delegate_id_);
   }
 }
 
 void WebMediaPlayerMS::load(LoadType load_type,
                             const blink::WebMediaPlayerSource& source,
                             CORSMode /*cors_mode*/) {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // TODO(acolwell): Change this to DCHECK_EQ(load_type, LoadTypeMediaStream)
   // once Blink-side changes land.
   DCHECK_NE(load_type, LoadTypeMediaSource);
   blink::WebMediaStream web_stream =
       GetWebMediaStreamFromWebMediaPlayerSource(source);
 
   compositor_.reset(new WebMediaPlayerMSCompositor(compositor_task_runner_,
                                                    web_stream, AsWeakPtr()));
@@ skipping 33 matching lines @@
   if (video_frame_provider_)
     video_frame_provider_->Start();
   if (audio_renderer_ && !video_frame_provider_) {
     // This is audio-only mode.
     SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
     SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
   }
 }
 
 void WebMediaPlayerMS::play() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   media_log_->AddEvent(media_log_->CreateEvent(media::MediaLogEvent::PLAY));
   if (!paused_)
     return;
 
   if (video_frame_provider_)
     video_frame_provider_->Resume();
 
   compositor_->StartRendering();
 
   if (audio_renderer_)
     audio_renderer_->Play();
 
   if (delegate_) {
     // TODO(perkj, magjed): We send a duration of 1 second here to avoid
     // creating an interactive media session on Android. We'd like to use zero
     // here, but that is treated as an unknown duration and assumed to be
     // interactive. See http://crbug.com/595297 for more details.
     delegate_->DidPlay(delegate_id_, hasVideo(), hasAudio(), false,
                        base::TimeDelta::FromSeconds(1));
   }
 
   paused_ = false;
 }
 
 void WebMediaPlayerMS::pause() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   should_play_upon_shown_ = false;
   media_log_->AddEvent(media_log_->CreateEvent(media::MediaLogEvent::PAUSE));
   if (paused_)
     return;
 
   if (video_frame_provider_)
     video_frame_provider_->Pause();
 
@@ skipping 16 matching lines @@
 
 void WebMediaPlayerMS::seek(double seconds) {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void WebMediaPlayerMS::setRate(double rate) {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void WebMediaPlayerMS::setVolume(double volume) {
-  DVLOG(1) << __FUNCTION__ << "(volume=" << volume << ")";
+  DVLOG(1) << __func__ << "(volume=" << volume << ")";
   DCHECK(thread_checker_.CalledOnValidThread());
   volume_ = volume;
   if (audio_renderer_.get())
     audio_renderer_->SetVolume(volume_ * volume_multiplier_);
 }
 
 void WebMediaPlayerMS::setSinkId(
     const blink::WebString& sink_id,
     const blink::WebSecurityOrigin& security_origin,
     blink::WebSetSinkIdCallbacks* web_callback) {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   const media::OutputDeviceStatusCB callback =
       media::ConvertToOutputDeviceStatusCB(web_callback);
   if (audio_renderer_) {
     audio_renderer_->SwitchOutputDevice(sink_id.utf8(), security_origin,
                                         callback);
   } else {
     callback.Run(media::OUTPUT_DEVICE_STATUS_ERROR_INTERNAL);
   }
 }
@@ skipping 41 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   const base::TimeDelta current_time = compositor_->GetCurrentTime();
   if (current_time.ToInternalValue() != 0)
     return current_time.InSecondsF();
   else if (audio_renderer_.get())
     return audio_renderer_->GetCurrentRenderTime().InSecondsF();
   return 0.0;
 }
 
 blink::WebMediaPlayer::NetworkState WebMediaPlayerMS::getNetworkState() const {
-  DVLOG(1) << __FUNCTION__ << ", state:" << network_state_;
+  DVLOG(1) << __func__ << ", state:" << network_state_;
   DCHECK(thread_checker_.CalledOnValidThread());
   return network_state_;
 }
 
 blink::WebMediaPlayer::ReadyState WebMediaPlayerMS::getReadyState() const {
-  DVLOG(1) << __FUNCTION__ << ", state:" << ready_state_;
+  DVLOG(1) << __func__ << ", state:" << ready_state_;
   DCHECK(thread_checker_.CalledOnValidThread());
   return ready_state_;
 }
 
 blink::WebString WebMediaPlayerMS::getErrorMessage() {
   return blink::WebString::fromUTF8(media_log_->GetLastErrorMessage());
 }
 
 blink::WebTimeRanges WebMediaPlayerMS::buffered() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return buffered_;
 }
 
 blink::WebTimeRanges WebMediaPlayerMS::seekable() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return blink::WebTimeRanges();
 }
 
 bool WebMediaPlayerMS::didLoadingProgress() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return true;
 }
 
 void WebMediaPlayerMS::paint(blink::WebCanvas* canvas,
                              const blink::WebRect& rect,
                              unsigned char alpha,
                              SkXfermode::Mode mode) {
-  DVLOG(3) << __FUNCTION__;
+  DVLOG(3) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const scoped_refptr<media::VideoFrame> frame =
       compositor_->GetCurrentFrameWithoutUpdatingStatistics();
 
   media::Context3D context_3d;
   if (frame && frame->HasTextures()) {
     auto* provider =
         RenderThreadImpl::current()->SharedMainThreadContextProvider().get();
     // GPU Process crashed.
@@ skipping 128 matching lines @@
     return false;
   context_3d = media::Context3D(provider->ContextGL(), provider->GrContext());
   DCHECK(context_3d.gl);
   return video_renderer_.CopyVideoFrameTexturesToGLTexture(
       context_3d, gl, video_frame.get(), texture, internal_format, type,
       premultiply_alpha, flip_y);
 }
 
 void WebMediaPlayerMS::OnFrameAvailable(
     const scoped_refptr<media::VideoFrame>& frame) {
-  DVLOG(3) << __FUNCTION__;
+  DVLOG(3) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (render_frame_suspended_)
     return;
 
   base::TimeTicks render_time;
   if (frame->metadata()->GetTimeTicks(media::VideoFrameMetadata::REFERENCE_TIME,
                                       &render_time)) {
     TRACE_EVENT1("webrtc", "WebMediaPlayerMS::OnFrameAvailable",
                  "Ideal Render Instant", render_time.ToInternalValue());
@@ skipping 15 matching lines @@
       video_weblayer_->layer()->SetContentsOpaque(false);
       video_weblayer_->SetContentsOpaqueIsFixed(true);
       get_client()->setWebLayer(video_weblayer_.get());
     }
   }
 
   compositor_->EnqueueFrame(frame);
 }
 
 void WebMediaPlayerMS::RepaintInternal() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   get_client()->repaint();
 }
 
 void WebMediaPlayerMS::OnSourceError() {
   DCHECK(thread_checker_.CalledOnValidThread());
   SetNetworkState(WebMediaPlayer::NetworkStateFormatError);
   RepaintInternal();
 }
 
@@ skipping 18 matching lines @@
 void WebMediaPlayerMS::ResetCanvasCache() {
   DCHECK(thread_checker_.CalledOnValidThread());
   video_renderer_.ResetCache();
 }
 
 void WebMediaPlayerMS::TriggerResize() {
   get_client()->sizeChanged();
 }
 
 }  // namespace content