media/.../{android_,gpu_}video_encode_accelerator{,_host} cleanup

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 67 matching lines @@
     default:
       return std::string();
   }
 }
 
 SdkMediaCodecBridge::SdkMediaCodecBridge(const std::string& mime,
                                          bool is_secure,
                                          MediaCodecDirection direction,
                                          bool require_software_codec) {
   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, is_secure, direction, require_software_codec));
 }
 
 SdkMediaCodecBridge::~SdkMediaCodecBridge() {
   JNIEnv* env = AttachCurrentThread();
-  CHECK(env);
   if (j_media_codec_.obj())
     Java_MediaCodecBridge_release(env, j_media_codec_);
 }
 
 bool SdkMediaCodecBridge::Start() {
   JNIEnv* env = AttachCurrentThread();
   return Java_MediaCodecBridge_start(env, j_media_codec_);
 }
 
 void SdkMediaCodecBridge::Stop() {
@@ skipping 42 matching lines @@
   if (status == MEDIA_CODEC_OK)
     *channel_count = Java_GetOutputFormatResult_channelCount(env, result);
   return status;
 }
 
 MediaCodecStatus SdkMediaCodecBridge::QueueInputBuffer(
     int index,
     const uint8_t* data,
     size_t data_size,
     base::TimeDelta presentation_time) {
-  DVLOG(3) << __PRETTY_FUNCTION__ << index << ": " << data_size;
+  DVLOG(3) << __FUNCTION__ << index << ": " << data_size;
   if (data_size >
       base::checked_cast<size_t>(std::numeric_limits<int32_t>::max())) {
     return MEDIA_CODEC_ERROR;
   }
   if (data && !FillInputBuffer(index, data, data_size))
     return MEDIA_CODEC_ERROR;
   JNIEnv* env = AttachCurrentThread();
   return static_cast<MediaCodecStatus>(Java_MediaCodecBridge_queueInputBuffer(
       env, j_media_codec_, index, 0, data_size,
       presentation_time.InMicroseconds(), 0));
 }
 
 // TODO(timav): Combine this and above methods together keeping only the first
 // interface after we switch to Spitzer pipeline.
 MediaCodecStatus SdkMediaCodecBridge::QueueSecureInputBuffer(
     int index,
     const uint8_t* data,
     size_t data_size,
     const std::vector<char>& key_id,
     const std::vector<char>& iv,
     const SubsampleEntry* subsamples,
     int subsamples_size,
     base::TimeDelta presentation_time) {
-  DVLOG(3) << __PRETTY_FUNCTION__ << index << ": " << data_size;
+  DVLOG(3) << __FUNCTION__ << index << ": " << data_size;
   if (data_size >
       base::checked_cast<size_t>(std::numeric_limits<int32_t>::max())) {
     return MEDIA_CODEC_ERROR;
   }
   if (data && !FillInputBuffer(index, data, data_size))
     return MEDIA_CODEC_ERROR;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jbyteArray> j_key_id = base::android::ToJavaByteArray(
       env, reinterpret_cast<const uint8_t*>(key_id.data()), key_id.size());
@@ skipping 34 matching lines @@
       ToJavaIntArray(env, std::move(native_cypher_array), new_subsamples_size);
 
   return static_cast<MediaCodecStatus>(
       Java_MediaCodecBridge_queueSecureInputBuffer(
           env, j_media_codec_.obj(), index, 0, j_iv.obj(), j_key_id.obj(),
           clear_array, cypher_array, new_subsamples_size,
           presentation_time.InMicroseconds()));
 }
 
 void SdkMediaCodecBridge::QueueEOS(int input_buffer_index) {
-  DVLOG(3) << __PRETTY_FUNCTION__ << ": " << input_buffer_index;
+  DVLOG(3) << __FUNCTION__ << ": " << input_buffer_index;
   JNIEnv* env = AttachCurrentThread();
   Java_MediaCodecBridge_queueInputBuffer(
       env, j_media_codec_, input_buffer_index, 0, 0, 0, kBufferFlagEndOfStream);
 }
 
 MediaCodecStatus SdkMediaCodecBridge::DequeueInputBuffer(
     base::TimeDelta timeout,
     int* index) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> result = Java_MediaCodecBridge_dequeueInputBuffer(
       env, j_media_codec_, timeout.InMicroseconds());
   *index = Java_DequeueInputResult_index(env, result);
   MediaCodecStatus status = static_cast<MediaCodecStatus>(
       Java_DequeueInputResult_status(env, result));
-  DVLOG(3) << __PRETTY_FUNCTION__ << ": status: " << status
-           << ", index: " << *index;
+  DVLOG(3) << __FUNCTION__ << ": status: " << status << ", index: " << *index;
   return status;
 }
 
 MediaCodecStatus SdkMediaCodecBridge::DequeueOutputBuffer(
     base::TimeDelta timeout,
     int* index,
     size_t* offset,
     size_t* size,
     base::TimeDelta* presentation_time,
     bool* end_of_stream,
@@ skipping 11 matching lines @@
     *presentation_time = base::TimeDelta::FromMicroseconds(
         Java_DequeueOutputResult_presentationTimeMicroseconds(env, result));
   }
   int flags = Java_DequeueOutputResult_flags(env, result);
   if (end_of_stream)
     *end_of_stream = flags & kBufferFlagEndOfStream;
   if (key_frame)
     *key_frame = flags & kBufferFlagSyncFrame;
   MediaCodecStatus status = static_cast<MediaCodecStatus>(
       Java_DequeueOutputResult_status(env, result));
-  DVLOG(3) << __PRETTY_FUNCTION__ << ": status: " << status
-           << ", index: " << *index << ", offset: " << *offset
-           << ", size: " << *size << ", flags: " << flags;
+  DVLOG(3) << __FUNCTION__ << ": status: " << status << ", index: " << *index
+           << ", offset: " << *offset << ", size: " << *size
+           << ", flags: " << flags;
   return status;
 }
 
 void SdkMediaCodecBridge::ReleaseOutputBuffer(int index, bool render) {
-  DVLOG(3) << __PRETTY_FUNCTION__ << ": " << index;
+  DVLOG(3) << __FUNCTION__ << ": " << index;
   JNIEnv* env = AttachCurrentThread();
-  CHECK(env);
-
   Java_MediaCodecBridge_releaseOutputBuffer(env, j_media_codec_, index, render);
 }
 
 MediaCodecStatus SdkMediaCodecBridge::GetInputBuffer(int input_buffer_index,
                                                      uint8_t** data,
                                                      size_t* capacity) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_buffer(Java_MediaCodecBridge_getInputBuffer(
       env, j_media_codec_, input_buffer_index));
   if (j_buffer.is_null())
@@ skipping 392 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