Add VDA supported profile to GPUInfo.

content/common/gpu/media/vt_video_decode_accelerator.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 <algorithm>
 
 #include <CoreVideo/CoreVideo.h>
 #include <OpenGL/CGLIOSurface.h>
 #include <OpenGL/gl.h>
 
@@ skipping 15 matching lines @@
 using content_common_gpu_media::StubPathMap;
 
 #define NOTIFY_STATUS(name, status, session_failure)   \
     do {                                               \
       OSSTATUS_DLOG(ERROR, status) << name;            \
       NotifyError(PLATFORM_FAILURE, session_failure);  \
     } while (0)
 
 namespace content {
 
+// Only H.264 with 4:2:0 chroma sampling is supported.
+static const media::VideoCodecProfile kSupportedProfiles[] = {
+  media::H264PROFILE_BASELINE,
+  media::H264PROFILE_MAIN,
+  media::H264PROFILE_EXTENDED,
+  media::H264PROFILE_HIGH,
+  media::H264PROFILE_HIGH10PROFILE,
+  media::H264PROFILE_SCALABLEBASELINE,
+  media::H264PROFILE_SCALABLEHIGH,
+  media::H264PROFILE_STEREOHIGH,
+  media::H264PROFILE_MULTIVIEWHIGH,
+};
+
 // Size to use for NALU length headers in AVC format (can be 1, 2, or 4).
 static const int kNALUHeaderLength = 4;
 
 // We request 5 picture buffers from the client, each of which has a texture ID
 // that we can bind decoded frames to. We need enough to satisfy preroll, and
 // enough to avoid unnecessary stalling, but no more than that. The resource
 // requirements are low, as we don't need the textures to be backed by storage.
 static const int kNumPictureBuffers = media::limits::kMaxVideoFrames + 1;
 
 // Maximum number of frames to queue for reordering before we stop asking for
@@ skipping 258 matching lines @@
 
 bool VTVideoDecodeAccelerator::Initialize(
     media::VideoCodecProfile profile,
     Client* client) {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   client_ = client;
 
   if (!InitializeVideoToolbox())
     return false;
 
-  // Only H.264 with 4:2:0 chroma sampling is supported.
-  if (profile < media::H264PROFILE_MIN ||
-      profile > media::H264PROFILE_MAX ||
-      profile == media::H264PROFILE_HIGH422PROFILE ||
-      profile == media::H264PROFILE_HIGH444PREDICTIVEPROFILE) {
+  bool profile_supported = false;
+  for (const auto& supported_profile : kSupportedProfiles) {
+    if (profile == supported_profile) {
+      profile_supported = true;
+      break;
+    }
+  }
+  if (!profile_supported)
     return false;
-  }
 
   // Spawn a thread to handle parsing and calling VideoToolbox.
   if (!decoder_thread_.Start())
     return false;
 
   // Count the session as successfully initialized.
   UMA_HISTOGRAM_ENUMERATION("Media.VTVDA.SessionFailureReason",
                             SFT_SUCCESSFULLY_INITIALIZED,
                             SFT_MAX + 1);
   return true;
@@ skipping 716 matching lines @@
     client_->NotifyEndOfBitstreamBuffer(bitstream_id);
   assigned_bitstream_ids_.clear();
   state_ = STATE_DESTROYING;
   QueueFlush(TASK_DESTROY);
 }
 
 bool VTVideoDecodeAccelerator::CanDecodeOnIOThread() {
   return false;
 }
 
+// static
+std::vector<media::VideoDecodeAccelerator::SupportedProfile>
+VTVideoDecodeAccelerator::GetSupportedProfiles() {
+  std::vector<media::VideoDecodeAccelerator::SupportedProfile> profiles;
+  for (const auto& supported_profile : kSupportedProfiles) {
+    media::VideoDecodeAccelerator::SupportedProfile profile;
+    profile.profile = supported_profile;
+    profile.min_resolution.SetSize(480, 360);
+    profile.max_resolution.SetSize(4096, 2160);
+    profiles.push_back(profile);
+  }
+  return profiles;
+}
+
 }  // namespace content