Add Create() function to AudioCodecBridge and VideoCodecBridge to allow return of null pointers

media/base/android/media_codec_bridge.cc

 // Copyright (c) 2013 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/android/media_codec_bridge.h"
 
 #include <jni.h>
 
 #include "base/android/build_info.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/basictypes.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/safe_numerics.h"
 #include "base/stringprintf.h"
 
 #include "jni/MediaCodecBridge_jni.h"
 #include "jni/MediaFormat_jni.h"
 
 using base::android::AttachCurrentThread;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ScopedJavaLocalRef;
 
-namespace {
-
-class MediaCodecNativeRegisterer {
- public:
-  MediaCodecNativeRegisterer() {
-    JNIEnv* env = AttachCurrentThread();
-    jni_initialized_ =
-        media::RegisterNativesImpl(env) &&
-        JNI_MediaFormat::RegisterNativesImpl(env);
-  }
-
-  bool IsRegistered() {
-    return jni_initialized_;
-  }
-
- private:
-  bool jni_initialized_;
-};
-
-static base::LazyInstance<MediaCodecNativeRegisterer> g_native_registerer =
-    LAZY_INSTANCE_INITIALIZER;
-
-}  // namespace
-
 namespace media {
 
 enum { kBufferFlagEndOfStream = 4 };
 
 static const char* AudioCodecToMimeType(const AudioCodec codec) {
   switch (codec) {
     case kCodecMP3:
       return "audio/mpeg";
     case kCodecVorbis:
       return "audio/vorbis";
@@ skipping 25 matching lines @@
 
 // static
 bool MediaCodecBridge::IsAvailable() {
   // MediaCodec is only available on JB and greater.
   return base::android::BuildInfo::GetInstance()->sdk_int() >= 16;
 }
 
 MediaCodecBridge::MediaCodecBridge(const char* mime) {
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
-  CHECK(g_native_registerer.Pointer()->IsRegistered());
   DCHECK(mime);
 
   ScopedJavaLocalRef<jstring> j_type = ConvertUTF8ToJavaString(env, mime);
   j_media_codec_.Reset(Java_MediaCodecBridge_create(
       env, j_type.obj()));
 }
 
 MediaCodecBridge::~MediaCodecBridge() {
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
@@ skipping 100 matching lines @@
 
   Java_MediaCodecBridge_releaseOutputBuffer(
       env, j_media_codec_.obj(), index, render);
 }
 
 void MediaCodecBridge::GetOutputBuffers() {
   JNIEnv* env = AttachCurrentThread();
   Java_MediaCodecBridge_getOutputBuffers(env, j_media_codec_.obj());
 }
 
-AudioCodecBridge::AudioCodecBridge(const AudioCodec codec)
-    : MediaCodecBridge(AudioCodecToMimeType(codec)) {
+AudioCodecBridge::AudioCodecBridge(const char* mime)
+    : MediaCodecBridge(mime) {
 }
 
 bool AudioCodecBridge::Start(
     const AudioCodec codec, int sample_rate, int channel_count,
     const uint8* extra_data, size_t extra_data_size, bool play_audio) {
   JNIEnv* env = AttachCurrentThread();
   DCHECK(AudioCodecToMimeType(codec));
 
   ScopedJavaLocalRef<jstring> j_mime =
       ConvertUTF8ToJavaString(env, AudioCodecToMimeType(codec));
@@ skipping 65 matching lines @@
   ScopedJavaLocalRef<jobject> buf =
       Java_MediaCodecBridge_getOutputBuffer(env, media_codec(), index);
   uint8* buffer = static_cast<uint8*>(env->GetDirectBufferAddress(buf.obj()));
 
   ScopedJavaLocalRef<jbyteArray> byte_array =
       base::android::ToJavaByteArray(env, buffer, numBytes);
   Java_MediaCodecBridge_playOutputBuffer(
       env, media_codec(), byte_array.obj());
 }
 
-VideoCodecBridge::VideoCodecBridge(const VideoCodec codec)
-    : MediaCodecBridge(VideoCodecToMimeType(codec)) {
+VideoCodecBridge::VideoCodecBridge(const char* mime)
+    : MediaCodecBridge(mime) {
 }
 
 bool VideoCodecBridge::Start(
     const VideoCodec codec, const gfx::Size& size, jobject surface) {
   JNIEnv* env = AttachCurrentThread();
   DCHECK(VideoCodecToMimeType(codec));
 
   ScopedJavaLocalRef<jstring> j_mime =
       ConvertUTF8ToJavaString(env, VideoCodecToMimeType(codec));
   ScopedJavaLocalRef<jobject> j_format(
       JNI_MediaFormat::Java_MediaFormat_createVideoFormat(
           env, j_mime.obj(), size.width(), size.height()));
   DCHECK(!j_format.is_null());
   Java_MediaCodecBridge_configureVideo(
       env, media_codec(), j_format.obj(), surface, NULL, 0);
   StartInternal();
   return true;
 }
 
+AudioCodecBridge* AudioCodecBridge::Create(const AudioCodec codec) {
+  const char* mime = AudioCodecToMimeType(codec);
+  return mime ? new AudioCodecBridge(mime) : NULL;
+}
+
+VideoCodecBridge* VideoCodecBridge::Create(const VideoCodec codec) {
+  const char* mime = VideoCodecToMimeType(codec);
+  return mime ? new VideoCodecBridge(mime) : NULL;
+}
+
+bool MediaCodecBridge::RegisterMediaCodecBridge(JNIEnv* env) {
+  if (!MediaCodecBridge::IsAvailable())
+    return false;
+  return RegisterNativesImpl(env) && JNI_MediaFormat::RegisterNativesImpl(env);
+}
+
 }  // namespace media