Rename misleading |is_ambiguous| parameter

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/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
@@ skipping 13 matching lines @@
   const char* const codec_id;
   MimeUtil::Codec codec;
 };
 
 // List of codec IDs that provide enough information to determine the
 // codec and profile being requested.
 //
 // The "mp4a" strings come from RFC 6381.
 static const CodecIDMappings kUnambiguousCodecStringMap[] = {
     {"1", MimeUtil::PCM},  // We only allow this for WAV so it isn't ambiguous.
-    // avc1/avc3.XXXXXX may be unambiguous; handled by ParseAVCCodecId().
-    // hev1/hvc1.XXXXXX may be unambiguous; handled by ParseHEVCCodecID().
-    // vp9, vp9.0, vp09.xx.xx.xx.xx.xx.xx.xx may be unambiguous; handled by
+    // avc1/avc3.XXXXXX is handled by ParseAVCCodecId().
+    // hev1/hvc1.XXXXXX is handled by ParseHEVCCodecID().
+    // vp8, vp8.0, vp9, vp9.0, and vp09.xx.xx.xx.xx.xx.xx.xx are handled by

[kqyang, 2016/04/21 00:59:48]

vp8, vp8.0 are still handled in this map; only vp9, vp9.0 and vp09 are handled
in ParseVp9CodecID.

[ddorwin, 2016/04/21 02:09:50]

Done. Thanks.

     // ParseVp9CodecID().
     {"mp3", MimeUtil::MP3},
     // Following is the list of RFC 6381 compliant audio codec strings:
     //   mp4a.66     - MPEG-2 AAC MAIN
     //   mp4a.67     - MPEG-2 AAC LC
     //   mp4a.68     - MPEG-2 AAC SSR
     //   mp4a.69     - MPEG-2 extension to MPEG-1 (MP3)
     //   mp4a.6B     - MPEG-1 audio (MP3)
     //   mp4a.40.2   - MPEG-4 AAC LC
     //   mp4a.40.02  - MPEG-4 AAC LC (leading 0 in aud-oti for compatibility)
@@ skipping 32 matching lines @@
     {"theora", MimeUtil::THEORA}};
 
 // List of codec IDs that are ambiguous and don't provide
 // enough information to determine the codec and profile.
 // The codec in these entries indicate the codec and profile
 // we assume the user is trying to indicate.
 static const CodecIDMappings kAmbiguousCodecStringMap[] = {
     {"mp4a.40", MimeUtil::MPEG4_AAC},
     {"avc1", MimeUtil::H264},
     {"avc3", MimeUtil::H264},
-    // avc1/avc3.XXXXXX may be ambiguous; handled by ParseAVCCodecId().
 };
 
 #if BUILDFLAG(ENABLE_MSE_MPEG2TS_STREAM_PARSER)
 static const char kHexString[] = "0123456789ABCDEF";
 static char IntToHex(int i) {
   DCHECK_GE(i, 0) << i << " not a hex value";
   DCHECK_LE(i, 15) << i << " not a hex value";
   return kHexString[i];
 }
 
@@ skipping 51 matching lines @@
 
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
 // ISO/IEC FDIS 14496-15 standard section E.3 describes the syntax of codec ids
 // reserved for HEVC. According to that spec HEVC codec id must start with
 // either "hev1." or "hvc1.". We don't yet support full parsing of HEVC codec
 // ids, but since no other codec id starts with those string we'll just treat
 // any string starting with "hev1." or "hvc1." as valid HEVC codec ids.
 // crbug.com/482761
 static bool ParseHEVCCodecID(const std::string& codec_id,
                              MimeUtil::Codec* codec,
-                             bool* is_ambiguous) {
+                             bool* is_known_supported) {
   if (base::StartsWith(codec_id, "hev1.", base::CompareCase::SENSITIVE) ||
       base::StartsWith(codec_id, "hvc1.", base::CompareCase::SENSITIVE)) {
     *codec = MimeUtil::HEVC_MAIN;
 
     // TODO(servolk): Full HEVC codec id parsing is not implemented yet (see
-    // crbug.com/482761). So treat HEVC codec ids as ambiguous for now.
-    *is_ambiguous = true;
-
-    // TODO(servolk): Most HEVC codec ids are treated as ambiguous (see above),
-    // but we need to recognize at least one valid unambiguous HEVC codec id,
-    // which is added into kMP4VideoCodecsExpression. We need it to be
-    // unambiguous to avoid DCHECK(!is_ambiguous) in InitializeMimeTypeMaps. We
-    // also use these in unit tests (see
-    // content/browser/media/media_canplaytype_browsertest.cc).
-    // Remove this workaround after crbug.com/482761 is fixed.
-    if (codec_id == "hev1.1.6.L93.B0" || codec_id == "hvc1.1.6.L93.B0") {
-      *is_ambiguous = false;
-    }
-
+    // crbug.com/482761). So treat HEVC as not known supported for now.
+    *is_known_supported = false;
     return true;
   }
 
   return false;
 }
 #endif
 
 // Handle parsing of vp9 codec IDs.
 static bool ParseVp9CodecID(const std::string& mime_type_lower_case,
                             const std::string& codec_id,
@@ skipping 108 matching lines @@
 SupportsType MimeUtil::AreSupportedCodecs(
     const CodecSet& supported_codecs,
     const std::vector<std::string>& codecs,
     const std::string& mime_type_lower_case,
     bool is_encrypted) const {
   DCHECK(!supported_codecs.empty());
   DCHECK(!codecs.empty());
 
   SupportsType result = IsSupported;
   for (size_t i = 0; i < codecs.size(); ++i) {
-    bool is_ambiguous = true;
+    bool is_known_supported = false;
     Codec codec = INVALID_CODEC;
-    if (!StringToCodec(mime_type_lower_case, codecs[i], &codec, &is_ambiguous,
-                       is_encrypted)) {
+    if (!StringToCodec(mime_type_lower_case, codecs[i], &codec,
+                       &is_known_supported, is_encrypted)) {
       return IsNotSupported;
     }
 
     if (!IsCodecSupported(codec, mime_type_lower_case, is_encrypted) ||
         supported_codecs.find(codec) == supported_codecs.end()) {
       return IsNotSupported;
     }
 
-    if (is_ambiguous)
+    if (!is_known_supported)
       result = MayBeSupported;
   }
 
   return result;
 }
 
 void MimeUtil::InitializeMimeTypeMaps() {
 #if defined(USE_PROPRIETARY_CODECS)
   allow_proprietary_codecs_ = true;
 #endif
@@ skipping 330 matching lines @@
       return mime_type_lower_case == "video/webm";
     }
   }
 
   return false;
 }
 
 bool MimeUtil::StringToCodec(const std::string& mime_type_lower_case,
                              const std::string& codec_id,
                              Codec* codec,
-                             bool* is_ambiguous,
+                             bool* is_known_supported,
                              bool is_encrypted) const {
   StringToCodecMappings::const_iterator itr =
       string_to_codec_map_.find(codec_id);
   if (itr != string_to_codec_map_.end()) {
     *codec = itr->second.codec;
-    *is_ambiguous = itr->second.is_ambiguous;
+    *is_known_supported = !itr->second.is_ambiguous;
     return true;
   }
 
 // If |codec_id| is not in |string_to_codec_map_|, then we assume that it is
 // either H.264 or HEVC/H.265 codec ID because currently those are the only
 // ones that are not added to the |string_to_codec_map_| and require parsing.
 
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
-  if (ParseHEVCCodecID(codec_id, codec, is_ambiguous)) {
+  if (ParseHEVCCodecID(codec_id, codec, is_known_supported)) {
     return true;
   }
 #endif
 
   VideoCodecProfile profile = VIDEO_CODEC_PROFILE_UNKNOWN;
   uint8_t level_idc = 0;
   if (ParseAVCCodecId(codec_id, &profile, &level_idc)) {
     *codec = MimeUtil::H264;
     switch (profile) {
 // HIGH10PROFILE is supported through fallback to the ffmpeg decoder
 // which is not available on Android, or if FFMPEG is not used.
 #if !defined(MEDIA_DISABLE_FFMPEG) && !defined(OS_ANDROID)
       case H264PROFILE_HIGH10PROFILE:
         if (is_encrypted) {
           // FFmpeg is not generally used for encrypted videos, so we do not
           // know whether 10-bit is supported.
-          *is_ambiguous = true;
+          *is_known_supported = false;
           break;
         }
 // Fall through.
 #endif
 
       case H264PROFILE_BASELINE:
       case H264PROFILE_MAIN:
       case H264PROFILE_HIGH:
-        *is_ambiguous = !IsValidH264Level(level_idc);
+        *is_known_supported = IsValidH264Level(level_idc);
         break;
       default:
-        *is_ambiguous = true;
+        *is_known_supported = false;
     }
     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;
+        *is_known_supported = true;
         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;
+        *is_known_supported = false;
     }
     return true;
   }
 
   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