Use __func__ instead of __FUNCTION__.

content/renderer/media/cdm/ppapi_decryptor.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/cdm/ppapi_decryptor.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 98 matching lines @@
       base::Bind(&PpapiDecryptor::OnLegacySessionError, weak_this),
       base::Bind(&PpapiDecryptor::OnSessionKeysChange, weak_this),
       base::Bind(&PpapiDecryptor::OnSessionExpirationUpdate, weak_this),
       base::Bind(&PpapiDecryptor::OnFatalPluginError, weak_this),
       std::move(promise));
 }
 
 void PpapiDecryptor::SetServerCertificate(
     const std::vector<uint8_t>& certificate,
     std::unique_ptr<media::SimpleCdmPromise> promise) {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(render_task_runner_->BelongsToCurrentThread());
 
   if (!CdmDelegate()) {
     promise->reject(INVALID_STATE_ERROR, 0, "CDM has failed.");
     return;
   }
 
   CdmDelegate()->SetServerCertificate(certificate, std::move(promise));
 }
 
 void PpapiDecryptor::CreateSessionAndGenerateRequest(
     SessionType session_type,
     media::EmeInitDataType init_data_type,
     const std::vector<uint8_t>& init_data,
     std::unique_ptr<media::NewSessionCdmPromise> promise) {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(render_task_runner_->BelongsToCurrentThread());
 
   if (!CdmDelegate()) {
     promise->reject(INVALID_STATE_ERROR, 0, "CDM has failed.");
     return;
   }
 
   CdmDelegate()->CreateSessionAndGenerateRequest(session_type, init_data_type,
                                                  init_data, std::move(promise));
 }
 
 void PpapiDecryptor::LoadSession(
     SessionType session_type,
     const std::string& session_id,
     std::unique_ptr<media::NewSessionCdmPromise> promise) {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(render_task_runner_->BelongsToCurrentThread());
 
   if (!CdmDelegate()) {
     promise->reject(INVALID_STATE_ERROR, 0, "CDM has failed.");
     return;
   }
   CdmDelegate()->LoadSession(session_type, session_id, std::move(promise));
 }
 
 void PpapiDecryptor::UpdateSession(
     const std::string& session_id,
     const std::vector<uint8_t>& response,
     std::unique_ptr<media::SimpleCdmPromise> promise) {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(render_task_runner_->BelongsToCurrentThread());
 
   if (!CdmDelegate()) {
     promise->reject(INVALID_STATE_ERROR, 0, "CDM has failed.");
     return;
   }
   CdmDelegate()->UpdateSession(session_id, response, std::move(promise));
 }
 
 void PpapiDecryptor::CloseSession(
     const std::string& session_id,
     std::unique_ptr<media::SimpleCdmPromise> promise) {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(render_task_runner_->BelongsToCurrentThread());
 
   if (!CdmDelegate()) {
     promise->reject(INVALID_STATE_ERROR, 0, "CDM has failed.");
     return;
   }
 
   CdmDelegate()->CloseSession(session_id, std::move(promise));
 }
 
 void PpapiDecryptor::RemoveSession(
     const std::string& session_id,
     std::unique_ptr<media::SimpleCdmPromise> promise) {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(render_task_runner_->BelongsToCurrentThread());
 
   if (!CdmDelegate()) {
     promise->reject(INVALID_STATE_ERROR, 0, "CDM has failed.");
     return;
   }
 
   CdmDelegate()->RemoveSession(session_id, std::move(promise));
 }
 
@@ skipping 12 matching lines @@
 void PpapiDecryptor::RegisterNewKeyCB(StreamType stream_type,
                                       const NewKeyCB& new_key_cb) {
   if (!render_task_runner_->BelongsToCurrentThread()) {
     render_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&PpapiDecryptor::RegisterNewKeyCB,
                    weak_ptr_factory_.GetWeakPtr(), stream_type, new_key_cb));
     return;
   }
 
-  DVLOG(3) << __FUNCTION__ << " - stream_type: " << stream_type;
+  DVLOG(3) << __func__ << " - stream_type: " << stream_type;
   switch (stream_type) {
     case kAudio:
       new_audio_key_cb_ = new_key_cb;
       break;
     case kVideo:
       new_video_key_cb_ = new_key_cb;
       break;
     default:
       NOTREACHED();
   }
 }
 
 void PpapiDecryptor::Decrypt(
     StreamType stream_type,
     const scoped_refptr<media::DecoderBuffer>& encrypted,
     const DecryptCB& decrypt_cb) {
   if (!render_task_runner_->BelongsToCurrentThread()) {
     render_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&PpapiDecryptor::Decrypt, weak_ptr_factory_.GetWeakPtr(),
                    stream_type, encrypted, decrypt_cb));
     return;
   }
 
-  DVLOG(3) << __FUNCTION__ << " - stream_type: " << stream_type;
+  DVLOG(3) << __func__ << " - stream_type: " << stream_type;
   if (!CdmDelegate() ||
       !CdmDelegate()->Decrypt(stream_type, encrypted, decrypt_cb)) {
     decrypt_cb.Run(kError, NULL);
   }
 }
 
 void PpapiDecryptor::CancelDecrypt(StreamType stream_type) {
   if (!render_task_runner_->BelongsToCurrentThread()) {
     render_task_runner_->PostTask(
         FROM_HERE, base::Bind(&PpapiDecryptor::CancelDecrypt,
                               weak_ptr_factory_.GetWeakPtr(), stream_type));
     return;
   }
 
-  DVLOG(1) << __FUNCTION__ << " - stream_type: " << stream_type;
+  DVLOG(1) << __func__ << " - stream_type: " << stream_type;
   if (CdmDelegate())
     CdmDelegate()->CancelDecrypt(stream_type);
 }
 
 void PpapiDecryptor::InitializeAudioDecoder(
     const media::AudioDecoderConfig& config,
     const DecoderInitCB& init_cb) {
   if (!render_task_runner_->BelongsToCurrentThread()) {
     render_task_runner_->PostTask(
         FROM_HERE, base::Bind(&PpapiDecryptor::InitializeAudioDecoder,
                               weak_ptr_factory_.GetWeakPtr(), config, init_cb));
     return;
   }
 
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(config.is_encrypted());
   DCHECK(config.IsValidConfig());
 
   audio_decoder_init_cb_ = init_cb;
   if (!CdmDelegate() ||
       !CdmDelegate()->InitializeAudioDecoder(
           config, base::Bind(&PpapiDecryptor::OnDecoderInitialized,
                              weak_ptr_factory_.GetWeakPtr(), kAudio))) {
     base::ResetAndReturn(&audio_decoder_init_cb_).Run(false);
     return;
   }
 }
 
 void PpapiDecryptor::InitializeVideoDecoder(
     const media::VideoDecoderConfig& config,
     const DecoderInitCB& init_cb) {
   if (!render_task_runner_->BelongsToCurrentThread()) {
     render_task_runner_->PostTask(
         FROM_HERE, base::Bind(&PpapiDecryptor::InitializeVideoDecoder,
                               weak_ptr_factory_.GetWeakPtr(), config, init_cb));
     return;
   }
 
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(config.is_encrypted());
   DCHECK(config.IsValidConfig());
 
   video_decoder_init_cb_ = init_cb;
   if (!CdmDelegate() ||
       !CdmDelegate()->InitializeVideoDecoder(
           config, base::Bind(&PpapiDecryptor::OnDecoderInitialized,
                              weak_ptr_factory_.GetWeakPtr(), kVideo))) {
     base::ResetAndReturn(&video_decoder_init_cb_).Run(false);
     return;
   }
 }
 
 void PpapiDecryptor::DecryptAndDecodeAudio(
     const scoped_refptr<media::DecoderBuffer>& encrypted,
     const AudioDecodeCB& audio_decode_cb) {
   if (!render_task_runner_->BelongsToCurrentThread()) {
     render_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&PpapiDecryptor::DecryptAndDecodeAudio,
                    weak_ptr_factory_.GetWeakPtr(), encrypted, audio_decode_cb));
     return;
   }
 
-  DVLOG(3) << __FUNCTION__;
+  DVLOG(3) << __func__;
   if (!CdmDelegate() ||
       !CdmDelegate()->DecryptAndDecodeAudio(encrypted, audio_decode_cb)) {
     audio_decode_cb.Run(kError, AudioFrames());
   }
 }
 
 void PpapiDecryptor::DecryptAndDecodeVideo(
     const scoped_refptr<media::DecoderBuffer>& encrypted,
     const VideoDecodeCB& video_decode_cb) {
   if (!render_task_runner_->BelongsToCurrentThread()) {
     render_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&PpapiDecryptor::DecryptAndDecodeVideo,
                    weak_ptr_factory_.GetWeakPtr(), encrypted, video_decode_cb));
     return;
   }
 
-  DVLOG(3) << __FUNCTION__;
+  DVLOG(3) << __func__;
   if (!CdmDelegate() ||
       !CdmDelegate()->DecryptAndDecodeVideo(encrypted, video_decode_cb)) {
     video_decode_cb.Run(kError, NULL);
   }
 }
 
 void PpapiDecryptor::ResetDecoder(StreamType stream_type) {
   if (!render_task_runner_->BelongsToCurrentThread()) {
     render_task_runner_->PostTask(
         FROM_HERE, base::Bind(&PpapiDecryptor::ResetDecoder,
                               weak_ptr_factory_.GetWeakPtr(), stream_type));
     return;
   }
 
-  DVLOG(2) << __FUNCTION__ << " - stream_type: " << stream_type;
+  DVLOG(2) << __func__ << " - stream_type: " << stream_type;
   if (CdmDelegate())
     CdmDelegate()->ResetDecoder(stream_type);
 }
 
 void PpapiDecryptor::DeinitializeDecoder(StreamType stream_type) {
   if (!render_task_runner_->BelongsToCurrentThread()) {
     render_task_runner_->PostTask(
         FROM_HERE, base::Bind(&PpapiDecryptor::DeinitializeDecoder,
                               weak_ptr_factory_.GetWeakPtr(), stream_type));
     return;
   }
 
-  DVLOG(2) << __FUNCTION__ << " - stream_type: " << stream_type;
+  DVLOG(2) << __func__ << " - stream_type: " << stream_type;
   if (CdmDelegate())
     CdmDelegate()->DeinitializeDecoder(stream_type);
 }
 
 void PpapiDecryptor::OnDecoderInitialized(StreamType stream_type,
                                           bool success) {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
   switch (stream_type) {
     case kAudio:
       DCHECK(!audio_decoder_init_cb_.is_null());
@@ skipping 13 matching lines @@
                                       const std::vector<uint8_t>& message,
                                       const GURL& legacy_destination_url) {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
   session_message_cb_.Run(session_id, message_type, message,
                           legacy_destination_url);
 }
 
 void PpapiDecryptor::OnSessionKeysChange(const std::string& session_id,
                                          bool has_additional_usable_key,
                                          media::CdmKeysInfo keys_info) {
-  DVLOG(2) << __FUNCTION__ << ": " << has_additional_usable_key;
+  DVLOG(2) << __func__ << ": " << has_additional_usable_key;
   DCHECK(render_task_runner_->BelongsToCurrentThread());
 
   // TODO(jrummell): Handling resume playback should be done in the media
   // player, not in the Decryptors. http://crbug.com/413413.
   if (has_additional_usable_key)
     AttemptToResumePlayback();
 
   session_keys_change_cb_.Run(session_id, has_additional_usable_key,
                               std::move(keys_info));
 }
@@ skipping 32 matching lines @@
   DCHECK(render_task_runner_->BelongsToCurrentThread());
   pepper_cdm_wrapper_.reset();
 }
 
 ContentDecryptorDelegate* PpapiDecryptor::CdmDelegate() {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
   return (pepper_cdm_wrapper_) ? pepper_cdm_wrapper_->GetCdmDelegate() : NULL;
 }
 
 }  // namespace content