Add EME support for new VP9 codec string in WebM.

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 <map>
 
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 184 matching lines @@
   for (size_t i = 0; i < codecs.size(); ++i) {
     // Parse the string.
     bool ambiguous_codec_string = false;
     Codec codec = INVALID_CODEC;
     VideoCodecProfile video_profile = VIDEO_CODEC_PROFILE_UNKNOWN;
     uint8_t video_level = 0;
     VideoColorSpace color_space;
     if (!ParseCodecString(mime_type_lower_case, codecs[i], &codec,
                           &ambiguous_codec_string, &video_profile, &video_level,
                           &color_space)) {
+      DVLOG(2) << __func__ << " Failed to parse codec string:" << codecs[i];
       return IsNotSupported;
     }
 
     // Bail if codec not in supported list for given container.
-    if (supported_codecs.find(codec) == supported_codecs.end())
+    if (supported_codecs.find(codec) == supported_codecs.end()) {
+      DVLOG(2) << __func__ << " Codec " << codecs[i]
+               << " not supported in container " << mime_type_lower_case;
       return IsNotSupported;
+    }
 
     // Make conservative guesses to resolve ambiguity before checking platform
     // support. H264 and VP9 are the only allowed ambiguous video codec. DO NOT
     // ADD SUPPORT FOR MORE AMIBIGUOUS STRINGS.
     if (codec == MimeUtil::H264 && ambiguous_codec_string) {
       if (video_profile == VIDEO_CODEC_PROFILE_UNKNOWN)
         video_profile = H264PROFILE_BASELINE;
       if (!IsValidH264Level(video_level))
         video_level = 10;
     } else if (codec == MimeUtil::VP9 && video_level == 0) {
       // Original VP9 content type (codecs="vp9") does not specify the level.
       // TODO(chcunningham): Mark this string as ambiguous when new multi-part
       // VP9 content type is published.
       video_level = 10;
     }
 
     // Check platform support.
     SupportsType result =
         IsCodecSupported(mime_type_lower_case, codec, video_profile,
                          video_level, color_space, is_encrypted);
-    if (result == IsNotSupported)
+    if (result == IsNotSupported) {
+      DVLOG(2) << __func__ << " Codec " << codecs[i]
+               << " not supported by platform";
       return IsNotSupported;
+    }
 
     // If any codec is "MayBeSupported", return Maybe for the combined result.
     // Downgrade to MayBeSupported if we had to guess the meaning of one of the
     // codec strings.
     if (result == MayBeSupported ||
         (result == IsSupported && ambiguous_codec_string))
       combined_result = MayBeSupported;
   }
 
   return combined_result;
@@ skipping 584 matching lines @@
 SupportsType MimeUtil::IsDefaultCodecSupported(const std::string& mime_type,
                                                bool is_encrypted) const {
   Codec default_codec = Codec::INVALID_CODEC;
   if (!GetDefaultCodec(mime_type, &default_codec))
     return IsNotSupported;
   return IsSimpleCodecSupported(mime_type, default_codec, is_encrypted);
 }
 
 }  // namespace internal
 }  // namespace media