MediaSourcePlayer implements IsTypeSupported().

media/base/android/media_codec_bridge.cc

Index: media/base/android/media_codec_bridge.cc
diff --git a/media/base/android/media_codec_bridge.cc b/media/base/android/media_codec_bridge.cc
index bb5ddccfd7e5a239961ba4761ee8903da0a84e56..ba9bae813a859fd72edee8c902813a8e5cf21ac8 100644
--- a/media/base/android/media_codec_bridge.cc
+++ b/media/base/android/media_codec_bridge.cc
@@ -5,6 +5,7 @@
 #include "media/base/android/media_codec_bridge.h"
 
 #include <jni.h>
+#include <string>
 
 #include "base/android/build_info.h"
 #include "base/android/jni_android.h"
@@ -27,7 +28,7 @@ namespace media {
 
 enum { kBufferFlagEndOfStream = 4 };
 
-static const char* AudioCodecToMimeType(const AudioCodec codec) {
+static const std::string AudioCodecToMimeType(const AudioCodec codec) {
   switch (codec) {
     case kCodecMP3:
       return "audio/mpeg";
@@ -36,21 +37,34 @@ static const char* AudioCodecToMimeType(const AudioCodec codec) {
     case kCodecAAC:
       return "audio/mp4a-latm";
     default:
-      return NULL;
+      return std::string();
   }
 }
 
-static const char* VideoCodecToMimeType(const VideoCodec codec) {
+static const std::string VideoCodecToMimeType(const VideoCodec codec) {

[ddorwin, 2013/08/28 18:41:56]

Who is converting to these codec enums? It seems we should have a consistent API
that always takes an enum or string.

[xhwang, 2013/08/30 05:32:38]

Enums (AudioCodec et al) comes from media code. It comes from container meta
info and converted to enum by the demuxer.

   switch (codec) {
     case kCodecH264:
       return "video/avc";
     case kCodecVP8:
       return "video/x-vnd.on2.vp8";
     default:
-      return NULL;
+      return std::string();
   }
 }
 
+static const std::string CodecTypeToMimeType(const std::string& codec) {
+  if (codec == "avc1")
+    return "video/avc";
+  // TODO(xhwang): Shall we handle strings like "mp4a.40.2"?

[ddorwin, 2013/08/28 18:41:56]

We should*. We'll need to see whether the upper layers pass this down or pass
just the stripped version. If the latter, we should DCHECK that the value does
not start with "mp4a.".

On second thought: The reason I say we should is that it's possible that the
platform (this code) can do something with the additional information. However,
it doesn't appear Android differentiates, so maybe we should just simplify
things in the browser. And maybe we can use an enum (made common with the above
conversions).

* I know Chrome allows this for avc1, but I'm not sure about mp4a. The TODO
should probably be above line 56.

[xhwang, 2013/08/30 05:32:38]

Currently mime_util doesn't have this granularity. We need to figure out at what
layer we strip out the codec list and at what precision we keep those strings. 

TODO moved up and we'll address that in a later CL.

+  if (codec == "mp4a")
+    return "audio/mp4a-latm";
+  if (codec == "vp8" || codec == "vp8.0")
+    return "video/x-vnd.on2.vp8";
+  if (codec == "vorbis")
+    return "audio/vorbis";
+  return std::string();
+}
+
 static ScopedJavaLocalRef<jintArray> ToJavaIntArray(
     JNIEnv* env, scoped_ptr<jint[]> native_array, int size) {
   ScopedJavaLocalRef<jintArray> j_array(env, env->NewIntArray(size));
@@ -72,14 +86,24 @@ bool MediaCodecBridge::IsAvailable() {
   return base::android::BuildInfo::GetInstance()->sdk_int() >= 16;
 }
 
-MediaCodecBridge::MediaCodecBridge(const char* mime) {
+// static
+bool MediaCodecBridge::CanDecode(const std::string& codec, bool is_secure) {
+  JNIEnv* env = AttachCurrentThread();
+  std::string mime = CodecTypeToMimeType(codec);
+  if (mime.empty())
+    return false;
+  ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
+  return !Java_MediaCodecBridge_create(env, j_mime.obj(), is_secure).is_null();
+}
+
+// TODO(xhwang): Support creating secure MediaCodecBridge.
+MediaCodecBridge::MediaCodecBridge(const std::string& mime) {
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
-  DCHECK(mime);
 
-  ScopedJavaLocalRef<jstring> j_type = ConvertUTF8ToJavaString(env, mime);
-  j_media_codec_.Reset(Java_MediaCodecBridge_create(
-      env, j_type.obj()));
+  DCHECK(!mime.empty());
+  ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
+  j_media_codec_.Reset(Java_MediaCodecBridge_create(env, j_mime.obj(), false));
 }
 
 MediaCodecBridge::~MediaCodecBridge() {
@@ -227,7 +251,7 @@ size_t MediaCodecBridge::FillInputBuffer(
   return size_to_copy;
 }
 
-AudioCodecBridge::AudioCodecBridge(const char* mime)
+AudioCodecBridge::AudioCodecBridge(const std::string& mime)
     : MediaCodecBridge(mime) {
 }
 
@@ -236,13 +260,16 @@ bool AudioCodecBridge::Start(
     const uint8* extra_data, size_t extra_data_size, bool play_audio,
     jobject media_crypto) {
   JNIEnv* env = AttachCurrentThread();
-  DCHECK(AudioCodecToMimeType(codec));
 
   if (!media_codec())
     return false;
 
+  std::string codec_string = AudioCodecToMimeType(codec);
+  if (codec_string.empty())
+    return false;
+
   ScopedJavaLocalRef<jstring> j_mime =
-      ConvertUTF8ToJavaString(env, AudioCodecToMimeType(codec));
+      ConvertUTF8ToJavaString(env, codec_string);
   ScopedJavaLocalRef<jobject> j_format(
       Java_MediaCodecBridge_createAudioFormat(
           env, j_mime.obj(), sample_rate, channel_count));
@@ -255,6 +282,7 @@ bool AudioCodecBridge::Start(
       env, media_codec(), j_format.obj(), media_crypto, 0, play_audio)) {
     return false;
   }
+
   StartInternal();
   return true;
 }
@@ -382,7 +410,7 @@ void AudioCodecBridge::SetVolume(double volume) {
   Java_MediaCodecBridge_setVolume(env, media_codec(), volume);
 }
 
-VideoCodecBridge::VideoCodecBridge(const char* mime)
+VideoCodecBridge::VideoCodecBridge(const std::string& mime)
     : MediaCodecBridge(mime) {
 }
 
@@ -390,13 +418,16 @@ bool VideoCodecBridge::Start(
     const VideoCodec codec, const gfx::Size& size, jobject surface,
     jobject media_crypto) {
   JNIEnv* env = AttachCurrentThread();
-  DCHECK(VideoCodecToMimeType(codec));
 
   if (!media_codec())
     return false;
 
+  std::string codec_string = VideoCodecToMimeType(codec);
+  if (codec_string.empty())
+    return false;
+
   ScopedJavaLocalRef<jstring> j_mime =
-      ConvertUTF8ToJavaString(env, VideoCodecToMimeType(codec));
+      ConvertUTF8ToJavaString(env, codec_string);
   ScopedJavaLocalRef<jobject> j_format(
       Java_MediaCodecBridge_createVideoFormat(
           env, j_mime.obj(), size.width(), size.height()));
@@ -410,13 +441,13 @@ bool VideoCodecBridge::Start(
 }
 
 AudioCodecBridge* AudioCodecBridge::Create(const AudioCodec codec) {
-  const char* mime = AudioCodecToMimeType(codec);
-  return mime ? new AudioCodecBridge(mime) : NULL;
+  const std::string mime = AudioCodecToMimeType(codec);
+  return mime.empty() ? NULL : new AudioCodecBridge(mime);
 }
 
 VideoCodecBridge* VideoCodecBridge::Create(const VideoCodec codec) {
-  const char* mime = VideoCodecToMimeType(codec);
-  return mime ? new VideoCodecBridge(mime) : NULL;
+  const std::string mime = VideoCodecToMimeType(codec);
+  return mime.empty() ? NULL : new VideoCodecBridge(mime);
 }
 
 bool MediaCodecBridge::RegisterMediaCodecBridge(JNIEnv* env) {