Delete browser MSE implementation.

media/base/android/sdk_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/sdk_media_codec_bridge.h"
 
 #include <algorithm>
 #include <limits>
 #include <memory>
 #include <utility>
@@ skipping 346 matching lines @@
   return MediaCodecUtil::IsKnownUnaccelerated(
       AudioCodecToAndroidMimeType(codec), MEDIA_CODEC_DECODER);
 }
 
 AudioCodecBridge::AudioCodecBridge(const std::string& mime)
     // Audio codec doesn't care about security level and there is no need for
     // audio encoding yet.
     : SdkMediaCodecBridge(mime, false, MEDIA_CODEC_DECODER, false) {}
 
 bool AudioCodecBridge::ConfigureAndStart(const AudioDecoderConfig& config,
-                                         bool play_audio,
                                          jobject media_crypto) {
   const int channel_count =
       ChannelLayoutToChannelCount(config.channel_layout());
   const int64_t codec_delay_ns = base::Time::kNanosecondsPerSecond *
                                  config.codec_delay() /
                                  config.samples_per_second();
   const int64_t seek_preroll_ns =
       1000LL * config.seek_preroll().InMicroseconds();
 
   return ConfigureAndStart(config.codec(), config.samples_per_second(),
                            channel_count, config.extra_data().data(),
                            config.extra_data().size(), codec_delay_ns,
-                           seek_preroll_ns, play_audio, media_crypto);
+                           seek_preroll_ns, media_crypto);
 }
 
 bool AudioCodecBridge::ConfigureAndStart(const AudioCodec& codec,
                                          int sample_rate,
                                          int channel_count,
                                          const uint8_t* extra_data,
                                          size_t extra_data_size,
                                          int64_t codec_delay_ns,
                                          int64_t seek_preroll_ns,
-                                         bool play_audio,
                                          jobject media_crypto) {
   DVLOG(2) << __FUNCTION__ << ": "
            << " codec:" << GetCodecName(codec)
            << " samples_per_second:" << sample_rate
            << " channel_count:" << channel_count
            << " codec_delay_ns:" << codec_delay_ns
            << " seek_preroll_ns:" << seek_preroll_ns
            << " extra data size:" << extra_data_size
-           << " play audio:" << play_audio << " media_crypto:" << media_crypto;
+           << " media_crypto:" << media_crypto;
   DCHECK(media_codec());
 
   std::string codec_string = AudioCodecToAndroidMimeType(codec);
   if (codec_string.empty())
     return false;
 
   JNIEnv* env = AttachCurrentThread();
 
   ScopedJavaLocalRef<jstring> j_mime =
       ConvertUTF8ToJavaString(env, codec_string);
   ScopedJavaLocalRef<jobject> j_format(Java_MediaCodecBridge_createAudioFormat(
       env, j_mime, sample_rate, channel_count));
   DCHECK(!j_format.is_null());
 
   if (!ConfigureMediaFormat(j_format.obj(), codec, extra_data, extra_data_size,
                             codec_delay_ns, seek_preroll_ns)) {
     return false;
   }
 
   if (!Java_MediaCodecBridge_configureAudio(env, media_codec(), j_format,
-                                            media_crypto, 0, play_audio)) {
+                                            media_crypto, 0)) {
     return false;
   }
 
   return Start();
 }
 
 bool AudioCodecBridge::ConfigureMediaFormat(jobject j_format,
                                             const AudioCodec& codec,
                                             const uint8_t* extra_data,
                                             size_t extra_data_size,
@@ skipping 116 matching lines @@
       break;
     }
     default:
       LOG(ERROR) << "Invalid header encountered for codec: "
                  << AudioCodecToAndroidMimeType(codec);
       return false;
   }
   return true;
 }
 
-bool AudioCodecBridge::CreateAudioTrack(int sampling_rate, int channel_count) {
-  DVLOG(2) << __FUNCTION__ << ": samping_rate:" << sampling_rate
-           << " channel_count:" << channel_count;
-
-  JNIEnv* env = AttachCurrentThread();
-  return Java_MediaCodecBridge_createAudioTrack(env, media_codec(),
-                                                sampling_rate, channel_count);
-}
-
-MediaCodecStatus AudioCodecBridge::PlayOutputBuffer(int index,
-                                                    size_t size,
-                                                    size_t offset,
-                                                    bool postpone,
-                                                    int64_t* playback_pos) {
-  DCHECK_LE(0, index);
-  int numBytes = base::checked_cast<int>(size);
-
-  const uint8_t* buffer = nullptr;
-  size_t capacity = 0;
-  MediaCodecStatus status =
-      GetOutputBufferAddress(index, offset, &buffer, &capacity);
-  if (status != MEDIA_CODEC_OK) {
-    DLOG(ERROR) << __FUNCTION__
-                << ": GetOutputBufferAddress() failed for index:" << index;
-    return status;
-  }
-
-  numBytes = std::min(base::checked_cast<int>(capacity), numBytes);
-  CHECK_GE(numBytes, 0);
-
-  JNIEnv* env = AttachCurrentThread();
-  ScopedJavaLocalRef<jbyteArray> byte_array =
-      base::android::ToJavaByteArray(env, buffer, numBytes);
-  *playback_pos = Java_MediaCodecBridge_playOutputBuffer(env, media_codec(),
-                                                         byte_array, postpone);
-  return status;
-}
-
-void AudioCodecBridge::SetVolume(double volume) {
-  JNIEnv* env = AttachCurrentThread();
-  Java_MediaCodecBridge_setVolume(env, media_codec(), volume);
-}
-
 // static
 bool VideoCodecBridge::IsKnownUnaccelerated(const VideoCodec& codec,
                                             MediaCodecDirection direction) {
   return MediaCodecUtil::IsKnownUnaccelerated(
       VideoCodecToAndroidMimeType(codec), direction);
 }
 
 // static
 VideoCodecBridge* VideoCodecBridge::CreateDecoder(const VideoCodec& codec,
                                                   bool is_secure,
@@ skipping 85 matching lines @@
   if (adaptive_playback_supported_for_testing_ == 0)
     return false;
   else if (adaptive_playback_supported_for_testing_ > 0)
     return true;
   JNIEnv* env = AttachCurrentThread();
   return Java_MediaCodecBridge_isAdaptivePlaybackSupported(env, media_codec(),
                                                            width, height);
 }
 
 }  // namespace media