Add VDA supported profile to GPUInfo.

gpu/config/gpu_info.h

 // 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.
 
 #ifndef GPU_CONFIG_GPU_INFO_H_
 #define GPU_CONFIG_GPU_INFO_H_
 
 // Provides access to the GPU information for the system
 // on which chrome is currently running.
 
@@ skipping 37 matching lines @@
   H264PROFILE_HIGH444PREDICTIVEPROFILE = 6,
   H264PROFILE_SCALABLEBASELINE = 7,
   H264PROFILE_SCALABLEHIGH = 8,
   H264PROFILE_STEREOHIGH = 9,
   H264PROFILE_MULTIVIEWHIGH = 10,
   VP8PROFILE_ANY = 11,
   VP9PROFILE_ANY = 12,
   VIDEO_CODEC_PROFILE_MAX = VP9PROFILE_ANY,
 };
 
+// Specification of a decoding profile supported by a hardware decoder.
+struct GPU_EXPORT VideoDecodeAcceleratorSupportedProfile {
+  VideoCodecProfile profile;
+  gfx::Size max_resolution;
+  gfx::Size min_resolution;
+};
+
 // Specification of an encoding profile supported by a hardware encoder.
 struct GPU_EXPORT VideoEncodeAcceleratorSupportedProfile {
   VideoCodecProfile profile;
   gfx::Size max_resolution;
   uint32 max_framerate_numerator;
   uint32 max_framerate_denominator;
 };
 
 struct GPU_EXPORT GPUInfo {
   struct GPU_EXPORT GPUDevice {
@@ skipping 131 matching lines @@
   // if the collection fails or not.
   CollectInfoResult basic_info_state;
   CollectInfoResult context_info_state;
 #if defined(OS_WIN)
   CollectInfoResult dx_diagnostics_info_state;
 
   // The information returned by the DirectX Diagnostics Tool.
   DxDiagNode dx_diagnostics;
 #endif
 
+  // Whether the platform supports to query video decoder profiles. Currently
+  // only CrOS supports to query video decoder supported profiles. If

[wuchengli, 2015/03/19 15:02:57]

Remove "Currently only CrOS supports to query video decoder supported
profiles.". When someone adds the support for another platform, they won't know
they should update the comments here. The rest of the comments should be clear
enough.

[henryhsu, 2015/03/23 03:21:07]

Done.

+  // |supported_query_video_decode_profiles| is true,
+  // |video_decode_accelerator_supported_profiles| is the profiles supported by
+  // the platform. Otherwise, it is invalid.
+  bool support_query_video_decode_profiles;

[piman, 2015/03/19 20:46:09]

Why do we do this?
If this is false, we hardcode the resolution on the client side and accept any
codec.
Could we instead hardcode the codecs&resolution on the service side, that way we
could be more exact (Mac and Windows only accept a subset of codecs, and
possibly Android as well).

[henryhsu, 2015/03/23 03:21:07]

Done.

+  std::vector<VideoDecodeAcceleratorSupportedProfile>
+      video_decode_accelerator_supported_profiles;
   std::vector<VideoEncodeAcceleratorSupportedProfile>
       video_encode_accelerator_supported_profiles;
   // Note: when adding new members, please remember to update EnumerateFields
   // in gpu_info.cc.
 
   // In conjunction with EnumerateFields, this allows the embedder to
   // enumerate the values in this structure without having to embed
   // references to its specific member variables. This simplifies the
   // addition of new fields to this type.
   class Enumerator {
    public:
     // The following methods apply to the "current" object. Initially this
     // is the root object, but calls to BeginGPUDevice/EndGPUDevice and
     // BeginAuxAttributes/EndAuxAttributes change the object to which these
     // calls should apply.
     virtual void AddInt64(const char* name, int64 value) = 0;
     virtual void AddInt(const char* name, int value) = 0;
     virtual void AddString(const char* name, const std::string& value) = 0;
     virtual void AddBool(const char* name, bool value) = 0;
     virtual void AddTimeDeltaInSecondsF(const char* name,
                                         const base::TimeDelta& value) = 0;
 
     // Markers indicating that a GPUDevice is being described.
     virtual void BeginGPUDevice() = 0;
     virtual void EndGPUDevice() = 0;
 
+    // Markers indicating that a VideoDecodeAcceleratorSupportedProfile is
+    // being described.
+    virtual void BeginVideoDecodeAcceleratorSupportedProfile() = 0;
+    virtual void EndVideoDecodeAcceleratorSupportedProfile() = 0;
+
     // Markers indicating that a VideoEncodeAcceleratorSupportedProfile is
     // being described.
     virtual void BeginVideoEncodeAcceleratorSupportedProfile() = 0;
     virtual void EndVideoEncodeAcceleratorSupportedProfile() = 0;
 
     // Markers indicating that "auxiliary" attributes of the GPUInfo
     // (according to the DevTools protocol) are being described.
     virtual void BeginAuxAttributes() = 0;
     virtual void EndAuxAttributes() = 0;
 
    protected:
     virtual ~Enumerator() {}
   };
 
   // Outputs the fields in this structure to the provided enumerator.
   void EnumerateFields(Enumerator* enumerator) const;
 };
 
 }  // namespace gpu
 
 #endif  // GPU_CONFIG_GPU_INFO_H_