Use GetProfileName() for error logs in gpu_video_decode_accelerator.cc

media/gpu/vaapi_video_decode_accelerator.cc

 // Copyright (c) 2012 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/gpu/vaapi_video_decode_accelerator.h"
 
 #include <string.h>
 
 #include <memory>
 
@@ skipping 341 matching lines @@
       return false;
   }
 
   client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client));
   client_ = client_ptr_factory_->GetWeakPtr();
 
   VideoCodecProfile profile = config.profile;
 
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kUninitialized);
-  DVLOG(2) << "Initializing VAVDA, profile: " << profile;
+  DVLOG(2) << "Initializing VAVDA, profile: " << GetProfileName(profile);
 
 #if defined(USE_X11)
   if (gl::GetGLImplementation() != gl::kGLImplementationDesktopGL) {
     DVLOG(1) << "HW video decode acceleration not available without "
                 "DesktopGL (GLX).";
     return false;
   }
 #elif defined(USE_OZONE)
   if (gl::GetGLImplementation() != gl::kGLImplementationEGLGLES2) {
     DVLOG(1) << "HW video decode acceleration not available without "
              << "EGLGLES2.";
     return false;
   }
 #endif  // USE_X11
 
   vaapi_wrapper_ = VaapiWrapper::CreateForVideoCodec(
       VaapiWrapper::kDecode, profile, base::Bind(&ReportToUMA, VAAPI_ERROR));
 
   if (!vaapi_wrapper_.get()) {
-    DVLOG(1) << "Failed initializing VAAPI for profile " << profile;
+    DVLOG(1) << "Failed initializing VAAPI for profile "
+             << GetProfileName(profile);
     return false;
   }
 
   if (profile >= H264PROFILE_MIN && profile <= H264PROFILE_MAX) {
     h264_accelerator_.reset(
         new VaapiH264Accelerator(this, vaapi_wrapper_.get()));
     decoder_.reset(new H264Decoder(h264_accelerator_.get()));
   } else if (profile >= VP8PROFILE_MIN && profile <= VP8PROFILE_MAX) {
     vp8_accelerator_.reset(new VaapiVP8Accelerator(this, vaapi_wrapper_.get()));
     decoder_.reset(new VP8Decoder(vp8_accelerator_.get()));
   } else if (profile >= VP9PROFILE_MIN && profile <= VP9PROFILE_MAX) {
     vp9_accelerator_.reset(new VaapiVP9Accelerator(this, vaapi_wrapper_.get()));
     decoder_.reset(new VP9Decoder(vp9_accelerator_.get()));
   } else {
-    DLOG(ERROR) << "Unsupported profile " << profile;
+    DLOG(ERROR) << "Unsupported profile " << GetProfileName(profile);
     return false;
   }
 
   CHECK(decoder_thread_.Start());
   decoder_thread_task_runner_ = decoder_thread_.task_runner();
 
   state_ = kIdle;
   output_mode_ = config.output_mode;
   return true;
 }
@@ skipping 1329 matching lines @@
   // |done_cb| should be null as we return false from IsFrameContextRequired().
   DCHECK(done_cb.is_null());
 
   VADecPictureParameterBufferVP9 pic_param;
   memset(&pic_param, 0, sizeof(pic_param));
 
   const Vp9FrameHeader* frame_hdr = pic->frame_hdr.get();
   DCHECK(frame_hdr);
 
   if (frame_hdr->profile != 0) {
-    DVLOG(1) << "Unsupported profile" << frame_hdr->profile;
+    DVLOG(1) << "Unsupported profile" << GetProfileName(frame_hdr->profile);
     return false;
   }
 
   pic_param.frame_width = base::checked_cast<uint16_t>(frame_hdr->frame_width);
   pic_param.frame_height =
       base::checked_cast<uint16_t>(frame_hdr->frame_height);
 
   CHECK_EQ(ref_pictures.size(), arraysize(pic_param.reference_frames));
   for (size_t i = 0; i < arraysize(pic_param.reference_frames); ++i) {
     VASurfaceID va_surface_id;
@@ skipping 122 matching lines @@
   return vaapi_pic->dec_surface();
 }
 
 // static
 VideoDecodeAccelerator::SupportedProfiles
 VaapiVideoDecodeAccelerator::GetSupportedProfiles() {
   return VaapiWrapper::GetSupportedDecodeProfiles();
 }
 
 }  // namespace media