Make video codec support logic overridable via MediaClient

media/base/mime_util_internal.cc

 // Copyright 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/base/mime_util_internal.h"
 
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "media/base/media.h"
+#include "media/base/media_client.h"
 #include "media/base/media_switches.h"
 #include "media/base/video_codecs.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
 #include "media/base/android/media_codec_util.h"
 #endif
 
 namespace media {
 namespace internal {
@@ skipping 648 matching lines @@
 #endif
 
       case H264PROFILE_BASELINE:
       case H264PROFILE_MAIN:
       case H264PROFILE_HIGH:
         *is_ambiguous = !IsValidH264Level(level_idc);
         break;
       default:
         *is_ambiguous = true;
     }
+    if (GetMediaClient()) {
+      return GetMediaClient()->IsSupportedVideoConfig(kCodecH264, profile,

[chcunningham, 2016/07/22 00:54:41]

This method is called StringToCodec, and its header comment says: 

Returns true if this method was able to map |codec_id| with
|mime_type_lower_case| to a specific Codec enum value. 

Given the above, it feels weird to me for this function to now be the arbiter of
platform support ... I think these calls to media client would be more at home
in AreSupportedCodecs. Then you'd only have to call it once. You'll want to
surface the level and profile as out params though

[ddorwin, 2016/07/22 02:06:37]

Agreed about the naming. There are other issues, such as, IIRC IsTypeSupported()
only returning a value that then gets checked for real support.

[servolk, 2016/07/22 02:26:09]

David, do you mean MSE's IsTypeSupported? It actually relies on the checks being
done here to decide if the codec is actually supported by the platform or not.
It then does some additional checks, but it never returns true for a codec that
was rejected here. So I believe it should be fine.

[servolk, 2016/07/22 02:26:09]

I agree with this, but actually performing that is much trickier than it might
seem at first. There's a couple of things that make it harder:
* StringToCodec returns a MimeUtil codec, while for a publicly visible API in
the MediaClient we'd prefer to use a public media::VideoCodec type.
* I'd prefer to keep the logic for handling various H264 and VP9 profiles for
now to minimize a chance of regressing something.
Having said that, it might still be possible to shuffle some code around to
invoke MediaClient::IsSupported from AreSupportedCodecs. I'll give it a try.

[servolk, 2016/07/22 03:06:28]

Done in patchset #4

+                                                      level_idc);
+    }
     return true;
   }
 
   if (ParseVp9CodecID(mime_type_lower_case, codec_id, &profile)) {
     *codec = MimeUtil::VP9;
     switch (profile) {
       case VP9PROFILE_PROFILE0:
         // Profile 0 should always be supported if VP9 is supported.
         *is_ambiguous = false;
         break;
       default:
         // We don't know if the underlying platform supports these profiles.
         // Need to add platform level querying to get supported profiles
         // (crbug/604566).
         *is_ambiguous = true;
     }
+    if (GetMediaClient()) {
+      // TODO(servolk): Add VP9 level info when it becomes available in VP9
+      // codec ids.
+      return GetMediaClient()->IsSupportedVideoConfig(kCodecVP9, profile, 1);
+    }
     return true;
   }
 
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
   if (ParseHEVCCodecId(codec_id, &profile, &level_idc)) {
-    // TODO(servolk): Set |is_ambiguous| to true for now to make CanPlayType
-    // return 'maybe' for HEVC codec ids, instead of probably. This needs to be
-    // changed to false after adding platform-level HEVC profile and level
-    // checks, see crbug.com/601949.
+    *codec = MimeUtil::HEVC;
+    if (GetMediaClient()) {
+      *is_ambiguous = false;
+      return GetMediaClient()->IsSupportedVideoConfig(kCodecHEVC, profile,
+                                                      level_idc);
+    }
     *is_ambiguous = true;
-    *codec = MimeUtil::HEVC;
     return true;
   }
 #endif
 
   DVLOG(4) << __FUNCTION__ << ": Unrecognized codec id " << codec_id;
   return false;
 }
 
 bool MimeUtil::IsCodecSupported(Codec codec,
                                 const std::string& mime_type_lower_case,
@@ skipping 55 matching lines @@
     const std::string& mime_type_lower_case,
     bool is_encrypted) const {
   Codec default_codec = Codec::INVALID_CODEC;
   if (!GetDefaultCodecLowerCase(mime_type_lower_case, &default_codec))
     return false;
   return IsCodecSupported(default_codec, mime_type_lower_case, is_encrypted);
 }
 
 }  // namespace internal
 }  // namespace media