Support creating secure decoder in MediaCodecBridge.

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 <string>
 
 #include "base/android/build_info.h"
@@ skipping 70 matching lines @@
 // 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) {
+MediaCodecBridge::MediaCodecBridge(const std::string& mime, bool is_secure) {
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
 
   DCHECK(!mime.empty());
   ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
-  j_media_codec_.Reset(Java_MediaCodecBridge_create(env, j_mime.obj(), false));
+  j_media_codec_.Reset(
+      Java_MediaCodecBridge_create(env, j_mime.obj(), is_secure));
 }
 
 MediaCodecBridge::~MediaCodecBridge() {
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
   if (j_media_codec_.obj())
     Java_MediaCodecBridge_release(env, j_media_codec_.obj());
 }
 
 void MediaCodecBridge::StartInternal() {
@@ skipping 145 matching lines @@
   // TODO(qinmin): Handling the case that not all the data can be copied.
   DCHECK(size_to_copy == size) <<
       "Failed to fill all the data into the input buffer. Size to fill: "
       << size << ". Size filled: " << size_to_copy;
   if (size_to_copy > 0)
     memcpy(direct_buffer, data, size_to_copy);
   return size_to_copy;
 }
 
 AudioCodecBridge::AudioCodecBridge(const std::string& mime)
-    : MediaCodecBridge(mime) {
+    // Audio codec doesn't care about security level.
+    : MediaCodecBridge(mime, false) {
 }
 
 bool AudioCodecBridge::Start(
     const AudioCodec codec, int sample_rate, int channel_count,
     const uint8* extra_data, size_t extra_data_size, bool play_audio,
     jobject media_crypto) {
   JNIEnv* env = AttachCurrentThread();
 
   if (!media_codec())
     return false;
@@ skipping 137 matching lines @@
       base::android::ToJavaByteArray(env, buffer, numBytes);
   Java_MediaCodecBridge_playOutputBuffer(
       env, media_codec(), byte_array.obj());
 }
 
 void AudioCodecBridge::SetVolume(double volume) {
   JNIEnv* env = AttachCurrentThread();
   Java_MediaCodecBridge_setVolume(env, media_codec(), volume);
 }
 
-VideoCodecBridge::VideoCodecBridge(const std::string& mime)
-    : MediaCodecBridge(mime) {
+VideoCodecBridge::VideoCodecBridge(const std::string& mime, bool is_secure)
+    : MediaCodecBridge(mime, is_secure) {
 }
 
 bool VideoCodecBridge::Start(
     const VideoCodec codec, const gfx::Size& size, jobject surface,
     jobject media_crypto) {
   JNIEnv* env = AttachCurrentThread();
 
   if (!media_codec())
     return false;
 
@@ skipping 13 matching lines @@
   }
   StartInternal();
   return true;
 }
 
 AudioCodecBridge* AudioCodecBridge::Create(const AudioCodec codec) {
   const std::string mime = AudioCodecToMimeType(codec);
   return mime.empty() ? NULL : new AudioCodecBridge(mime);
 }
 
-VideoCodecBridge* VideoCodecBridge::Create(const VideoCodec codec) {
+VideoCodecBridge* VideoCodecBridge::Create(const VideoCodec codec,
+                                           bool is_secure) {
   const std::string mime = VideoCodecToMimeType(codec);
-  return mime.empty() ? NULL : new VideoCodecBridge(mime);
+  return mime.empty() ? NULL : new VideoCodecBridge(mime, is_secure);
 }
 
 bool MediaCodecBridge::RegisterMediaCodecBridge(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace media