Use __func__ instead of __FUNCTION__.

media/base/video_codecs.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 "media/base/video_codecs.h"
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
@@ skipping 77 matching lines @@
                      VideoCodecProfile* profile,
                      uint8_t* level_idc) {
   // Make sure we have avc1.xxxxxx or avc3.xxxxxx , where xxxxxx are hex digits
   if (!base::StartsWith(codec_id, "avc1.", base::CompareCase::SENSITIVE) &&
       !base::StartsWith(codec_id, "avc3.", base::CompareCase::SENSITIVE)) {
     return false;
   }
   uint32_t elem = 0;
   if (codec_id.size() != 11 ||
       !base::HexStringToUInt(base::StringPiece(codec_id).substr(5), &elem)) {
-    DVLOG(4) << __FUNCTION__ << ": invalid avc codec id (" << codec_id << ")";
+    DVLOG(4) << __func__ << ": invalid avc codec id (" << codec_id << ")";
     return false;
   }
 
   uint8_t level_byte = elem & 0xFF;
   uint8_t constraints_byte = (elem >> 8) & 0xFF;
   uint8_t profile_idc = (elem >> 16) & 0xFF;
 
   // Check that the lower two bits of |constraints_byte| are zero (those are
   // reserved and must be zero according to ISO IEC 14496-10).
   if (constraints_byte & 3) {
-    DVLOG(4) << __FUNCTION__ << ": non-zero reserved bits in codec id "
-             << codec_id;
+    DVLOG(4) << __func__ << ": non-zero reserved bits in codec id " << codec_id;
     return false;
   }
 
   VideoCodecProfile out_profile = VIDEO_CODEC_PROFILE_UNKNOWN;
   // profile_idc values for each profile are taken from ISO IEC 14496-10 and
   // https://en.wikipedia.org/wiki/H.264/MPEG-4_AVC#Profiles
   switch (profile_idc) {
     case 66:
       out_profile = H264PROFILE_BASELINE;
       break;
@@ skipping 68 matching lines @@
 
   // HEVC codec id consists of:
   const int kMaxHevcCodecIdLength =
       5 +  // 'hev1.' or 'hvc1.' prefix (5 chars)
       4 +  // profile, e.g. '.A12' (max 4 chars)
       9 +  // profile_compatibility, dot + 32-bit hex number (max 9 chars)
       5 +  // tier and level, e.g. '.H120' (max 5 chars)
       18;  // up to 6 constraint bytes, bytes are dot-separated and hex-encoded.
 
   if (codec_id.size() > kMaxHevcCodecIdLength) {
-    DVLOG(4) << __FUNCTION__ << ": Codec id is too long (" << codec_id << ")";
+    DVLOG(4) << __func__ << ": Codec id is too long (" << codec_id << ")";
     return false;
   }
 
   std::vector<std::string> elem = base::SplitString(
       codec_id, ".", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   DCHECK(elem[0] == "hev1" || elem[0] == "hvc1");
 
   if (elem.size() < 4) {
-    DVLOG(4) << __FUNCTION__ << ": invalid HEVC codec id " << codec_id;
+    DVLOG(4) << __func__ << ": invalid HEVC codec id " << codec_id;
     return false;
   }
 
   uint8_t general_profile_space = 0;
   if (elem[1].size() > 0 &&
       (elem[1][0] == 'A' || elem[1][0] == 'B' || elem[1][0] == 'C')) {
     general_profile_space = 1 + (elem[1][0] - 'A');
     elem[1].erase(0, 1);
   }
   DCHECK(general_profile_space >= 0 && general_profile_space <= 3);
 
   unsigned general_profile_idc = 0;
   if (!base::StringToUint(elem[1], &general_profile_idc) ||
       general_profile_idc > 0x1f) {
-    DVLOG(4) << __FUNCTION__ << ": invalid general_profile_idc=" << elem[1];
+    DVLOG(4) << __func__ << ": invalid general_profile_idc=" << elem[1];
     return false;
   }
 
   uint32_t general_profile_compatibility_flags = 0;
   if (!base::HexStringToUInt(elem[2], &general_profile_compatibility_flags)) {
-    DVLOG(4) << __FUNCTION__
+    DVLOG(4) << __func__
              << ": invalid general_profile_compatibility_flags=" << elem[2];
     return false;
   }
 
   if (profile) {
     // TODO(servolk): Handle format range extension profiles as explained in
     // HEVC standard (ISO/IEC ISO/IEC 23008-2) section A.3.5
     if (general_profile_idc == 3 || (general_profile_compatibility_flags & 4)) {
       *profile = HEVCPROFILE_MAIN_STILL_PICTURE;
     }
     if (general_profile_idc == 2 || (general_profile_compatibility_flags & 2)) {
       *profile = HEVCPROFILE_MAIN10;
     }
     if (general_profile_idc == 1 || (general_profile_compatibility_flags & 1)) {
       *profile = HEVCPROFILE_MAIN;
     }
   }
 
   uint8_t general_tier_flag;
   if (elem[3].size() > 0 && (elem[3][0] == 'L' || elem[3][0] == 'H')) {
     general_tier_flag = (elem[3][0] == 'L') ? 0 : 1;
     elem[3].erase(0, 1);
   } else {
-    DVLOG(4) << __FUNCTION__ << ": invalid general_tier_flag=" << elem[3];
+    DVLOG(4) << __func__ << ": invalid general_tier_flag=" << elem[3];
     return false;
   }
   DCHECK(general_tier_flag == 0 || general_tier_flag == 1);
 
   unsigned general_level_idc = 0;
   if (!base::StringToUint(elem[3], &general_level_idc) ||
       general_level_idc > 0xff) {
-    DVLOG(4) << __FUNCTION__ << ": invalid general_level_idc=" << elem[3];
+    DVLOG(4) << __func__ << ": invalid general_level_idc=" << elem[3];
     return false;
   }
 
   if (level_idc)
     *level_idc = static_cast<uint8_t>(general_level_idc);
 
   uint8_t constraint_flags[6];
   memset(constraint_flags, 0, sizeof(constraint_flags));
 
   if (elem.size() > 10) {
-    DVLOG(4) << __FUNCTION__ << ": unexpected number of trailing bytes in HEVC "
+    DVLOG(4) << __func__ << ": unexpected number of trailing bytes in HEVC "
              << "codec id " << codec_id;
     return false;
   }
   for (size_t i = 4; i < elem.size(); ++i) {
     unsigned constr_byte = 0;
     if (!base::HexStringToUInt(elem[i], &constr_byte) || constr_byte > 0xFF) {
-      DVLOG(4) << __FUNCTION__ << ": invalid constraint byte=" << elem[i];
+      DVLOG(4) << __func__ << ": invalid constraint byte=" << elem[i];
       return false;
     }
     constraint_flags[i] = constr_byte;
   }
 
   return true;
 }
 #endif
 
 }  // namespace media