Add VP9 to canPlayType on Android

net/base/mime_util.cc

 // 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.
 
 #include <algorithm>
 #include <iterator>
 #include <map>
 #include <string>
 
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/mime_util.h"
 #include "net/base/platform_mime_util.h"
 
+#if defined(OS_ANDROID)
+#include "base/android/build_info.h"
+#endif
+
 using std::string;
 
 namespace {
 
 struct MediaType {
   const char name[12];
   const char matcher[13];
 };
 
 static const MediaType kIanaMediaTypes[] = {
@@ skipping 267 matching lines @@
 // This set of codecs is supported by all variations of Chromium.
 //
 // Refer to http://wiki.whatwg.org/wiki/Video_type_parameters#Browser_Support
 // for more information.
 //
 // The codecs for WAV are integers as defined in Appendix A of RFC2361:
 // http://tools.ietf.org/html/rfc2361
 static const char* const common_media_codecs[] = {
 #if !defined(OS_ANDROID)  // Android doesn't support Ogg Theora.
   "theora",
-  "vp9",  // TODO(tomfinegan): Move vp9 back down with vp8 once VP9 is supported
-          // on Android. https://crbug.com/285016
 #endif
   "vorbis",
   "vp8",
+  "vp9",
   "1"  // WAVE_FORMAT_PCM.
 };
 
 // List of proprietary codecs only supported by Google Chrome.
 static const char* const proprietary_media_codecs[] = {
   "avc1",
   "avc3",
   "mp4a"
 };
 
@@ skipping 80 matching lines @@
   "application/javascript",
   "application/ecmascript",
   "application/x-javascript",
   "text/javascript1.1",
   "text/javascript1.2",
   "text/javascript1.3",
   "text/jscript",
   "text/livescript"
 };
 
+#if defined(OS_ANDROID)
+static bool IsCodecSupportedOnAndroid(std::string codec) {

[scherkus (not reviewing), 2013/11/11 21:33:46]

const-ref

[vignesh, 2013/11/12 00:02:48]

Done.

+  // VP9 is supported only in KitKat+ (API Level 19).
+  if ((!codec.compare("vp9") || !codec.compare("vp9.0")) &&
+      base::android::BuildInfo::GetInstance()->sdk_int() < 19)
+    return false;

[qinmin, 2013/11/11 21:52:50]

you need {} as the if statement contains multiple lines.

[vignesh, 2013/11/12 00:02:48]

Done.

+  return true;
+}
+#endif
+
 struct MediaFormatStrict {
   const char* mime_type;
   const char* codecs_list;
 };
 
 static const MediaFormatStrict format_codec_mappings[] = {
-  // TODO(tomfinegan): Remove this if/else when VP9 is supported on Android.
-  // https://crbug.com/285016
-#if !defined(OS_ANDROID)
   { "video/webm", "vorbis,vp8,vp8.0,vp9,vp9.0" },
-#else
-  { "video/webm", "vorbis,vp8,vp8.0" },
-#endif
   { "audio/webm", "vorbis" },
   { "audio/wav", "1" }
 };
 
 MimeUtil::MimeUtil() {
   InitializeMimeTypeMaps();
 }
 
 // static
 bool MimeUtil::AreSupportedCodecs(const MimeMappings& supported_codecs,
@@ skipping 29 matching lines @@
   for (size_t i = 0; i < arraysize(common_media_types); ++i)
     media_map_.insert(common_media_types[i]);
 #if defined(USE_PROPRIETARY_CODECS)
   for (size_t i = 0; i < arraysize(proprietary_media_types); ++i)
     media_map_.insert(proprietary_media_types[i]);
 #endif
 
   for (size_t i = 0; i < arraysize(supported_javascript_types); ++i)
     javascript_map_.insert(supported_javascript_types[i]);
 
-  for (size_t i = 0; i < arraysize(common_media_codecs); ++i)
+  for (size_t i = 0; i < arraysize(common_media_codecs); ++i) {
+#if defined(OS_ANDROID)
+    if (IsCodecSupportedOnAndroid(common_media_codecs[i]))

[scherkus (not reviewing), 2013/11/11 21:33:46]

technically line 485 should be indented as this if statement is applying to it
... it's really subtle when reading

I'd reverse the condition and make the android case use a continue statement

[vignesh, 2013/11/12 00:02:48]

Nice idea. Done.

+#endif
     codecs_map_.insert(common_media_codecs[i]);
+  }
 #if defined(USE_PROPRIETARY_CODECS)
   for (size_t i = 0; i < arraysize(proprietary_media_codecs); ++i)
     codecs_map_.insert(proprietary_media_codecs[i]);
 #endif
 
   // Initialize the strict supported media types.
   for (size_t i = 0; i < arraysize(format_codec_mappings); ++i) {
     std::vector<std::string> mime_type_codecs;
     ParseCodecString(format_codec_mappings[i].codecs_list,
                      &mime_type_codecs,
                      false);
 
     MimeMappings codecs;
-    for (size_t j = 0; j < mime_type_codecs.size(); ++j)
+    for (size_t j = 0; j < mime_type_codecs.size(); ++j) {
+#if defined(OS_ANDROID)
+      if (IsCodecSupportedOnAndroid(mime_type_codecs[j]))

[scherkus (not reviewing), 2013/11/11 21:33:46]

ditto

[vignesh, 2013/11/12 00:02:48]

Done.

+#endif
       codecs.insert(mime_type_codecs[j]);
+    }
     strict_format_map_[format_codec_mappings[i].mime_type] = codecs;
   }
 }
 
 bool MimeUtil::IsSupportedImageMimeType(const std::string& mime_type) const {
   return image_map_.find(mime_type) != image_map_.end();
 }
 
 bool MimeUtil::IsSupportedMediaMimeType(const std::string& mime_type) const {
   return media_map_.find(mime_type) != media_map_.end();
@@ skipping 499 matching lines @@
   post_data->append("\r\n" + value + "\r\n");
 }
 
 void AddMultipartFinalDelimiterForUpload(const std::string& mime_boundary,
                                          std::string* post_data) {
   DCHECK(post_data);
   post_data->append("--" + mime_boundary + "--\r\n");
 }
 
 }  // namespace net