media: Remove suffix underscores from public member variables in AVDA

media/gpu/android_video_decode_accelerator.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/gpu/android_video_decode_accelerator.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 262 matching lines @@
 
   if (config.output_mode != Config::OutputMode::ALLOCATE) {
     DLOG(ERROR) << "Only ALLOCATE OutputMode is supported by this VDA";
     return false;
   }
 
   DCHECK(client);
   client_ = client;
   config_ = config;
   codec_config_ = new CodecConfig();
-  codec_config_->codec_ = VideoCodecProfileToVideoCodec(config.profile);
-  codec_config_->initial_expected_coded_size_ =
+  codec_config_->codec = VideoCodecProfileToVideoCodec(config.profile);
+  codec_config_->initial_expected_coded_size =
       config.initial_expected_coded_size;
 
-  if (codec_config_->codec_ != kCodecVP8 &&
-      codec_config_->codec_ != kCodecVP9 &&
+  if (codec_config_->codec != kCodecVP8 && codec_config_->codec != kCodecVP9 &&
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
-      codec_config_->codec_ != kCodecHEVC &&
+      codec_config_->codec != kCodecHEVC &&
 #endif
-      codec_config_->codec_ != kCodecH264) {
+      codec_config_->codec != kCodecH264) {
     DLOG(ERROR) << "Unsupported profile: " << config.profile;
     return false;
   }
 
-  if (codec_config_->codec_ == kCodecH264) {
-    codec_config_->csd0_ = config.sps;
-    codec_config_->csd1_ = config.pps;
+  if (codec_config_->codec == kCodecH264) {
+    codec_config_->csd0 = config.sps;
+    codec_config_->csd1 = config.pps;
   }
 
   // Only use MediaCodec for VP8/9 if it's likely backed by hardware
   // or if the stream is encrypted.
   if (IsMediaCodecSoftwareDecodingForbidden() &&
-      VideoCodecBridge::IsKnownUnaccelerated(codec_config_->codec_,
+      VideoCodecBridge::IsKnownUnaccelerated(codec_config_->codec,
                                              MEDIA_CODEC_DECODER)) {
     DVLOG(1) << "Initialization failed: "
-             << (codec_config_->codec_ == kCodecVP8 ? "vp8" : "vp9")
+             << (codec_config_->codec == kCodecVP8 ? "vp8" : "vp9")
              << " is not hardware accelerated";
     return false;
   }
 
   auto gles_decoder = get_gles2_decoder_cb_.Run();
   if (!gles_decoder) {
     DLOG(ERROR) << "Failed to get gles2 decoder instance.";
     return false;
   }
 
   // SetSurface() can't be called before Initialize(), so we pick up our first
   // surface ID from the codec configuration.
   DCHECK(!pending_surface_id_);
 
   // If we're low on resources, we may decide to defer creation of the surface
   // until the codec is actually used.
-  if (ShouldDeferSurfaceCreation(config_.surface_id, codec_config_->codec_)) {
+  if (ShouldDeferSurfaceCreation(config_.surface_id, codec_config_->codec)) {
     DCHECK(!deferred_initialization_pending_);
     // We should never be here if a SurfaceView is required.
     DCHECK_EQ(config_.surface_id, SurfaceManager::kNoSurfaceID);
     defer_surface_creation_ = true;
     NotifyInitializationComplete(true);
     return true;
   }
 
   // We signaled that we support deferred initialization, so see if the client
   // does also.
@@ skipping 23 matching lines @@
     deferred_initialization_pending_ = false;
   }
 }
 
 bool AndroidVideoDecodeAccelerator::InitializePictureBufferManager() {
   if (!make_context_current_cb_.Run()) {
     LOG(ERROR) << "Failed to make this decoder's GL context current.";
     return false;
   }
 
-  codec_config_->surface_ =
+  codec_config_->surface =
       picture_buffer_manager_.Initialize(config_.surface_id);
-  if (codec_config_->surface_.IsEmpty())
+  if (codec_config_->surface.IsEmpty())
     return false;
 
   if (!AVDACodecAllocator::Instance()->StartThread(this))
     return false;
 
   // If we are encrypted, then we aren't able to create the codec yet.
   if (config_.is_encrypted) {
     InitializeCdm();
     return true;
   }
@@ skipping 491 matching lines @@
 }
 
 void AndroidVideoDecodeAccelerator::ConfigureMediaCodecAsynchronously() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DCHECK_NE(state_, WAITING_FOR_CODEC);
   state_ = WAITING_FOR_CODEC;
 
   if (media_codec_) {
     AVDACodecAllocator::Instance()->ReleaseMediaCodec(
-        std::move(media_codec_), codec_config_->task_type_, config_.surface_id);
+        std::move(media_codec_), codec_config_->task_type, config_.surface_id);
     picture_buffer_manager_.CodecChanged(nullptr);
   }
 
   base::Optional<TaskType> task_type =
       AVDACodecAllocator::Instance()->TaskTypeForAllocation();
   if (!task_type) {
     // If there is no free thread, then just fail.
     OnCodecConfigured(nullptr);
     return;
   }
 
   // If autodetection is disallowed, fall back to Chrome's software decoders
   // instead of using the software decoders provided by MediaCodec.
   if (task_type == TaskType::SW_CODEC &&
       IsMediaCodecSoftwareDecodingForbidden()) {
     OnCodecConfigured(nullptr);
     return;
   }
 
-  codec_config_->task_type_ = task_type.value();
+  codec_config_->task_type = task_type.value();
   AVDACodecAllocator::Instance()->CreateMediaCodecAsync(
       weak_this_factory_.GetWeakPtr(), codec_config_);
 }
 
 bool AndroidVideoDecodeAccelerator::ConfigureMediaCodecSynchronously() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!media_codec_);
   DCHECK_NE(state_, WAITING_FOR_CODEC);
   state_ = WAITING_FOR_CODEC;
 
   base::Optional<TaskType> task_type =
       AVDACodecAllocator::Instance()->TaskTypeForAllocation();
   if (!task_type) {
     // If there is no free thread, then just fail.
     OnCodecConfigured(nullptr);
     return false;
   }
 
-  codec_config_->task_type_ = task_type.value();
+  codec_config_->task_type = task_type.value();
   std::unique_ptr<VideoCodecBridge> media_codec =
       AVDACodecAllocator::Instance()->CreateMediaCodecSync(codec_config_);
   OnCodecConfigured(std::move(media_codec));
   return !!media_codec_;
 }
 
 void AndroidVideoDecodeAccelerator::OnCodecConfigured(
     std::unique_ptr<VideoCodecBridge> media_codec) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(state_ == WAITING_FOR_CODEC || state_ == SURFACE_DESTROYED);
@@ skipping 162 matching lines @@
                      weak_this_factory_.GetWeakPtr(), bitstream_buffer_id));
     }
   }
   TRACE_COUNTER1("media", "AVDA::PendingBitstreamBufferCount", 0);
   bitstreams_notified_in_advance_.clear();
 
   picture_buffer_manager_.ReleaseCodecBuffers(output_picture_buffers_);
 
   // Some VP8 files require complete MediaCodec drain before we can call
   // MediaCodec.flush() or MediaCodec.reset(). http://crbug.com/598963.
-  if (media_codec_ && codec_config_->codec_ == kCodecVP8 &&
+  if (media_codec_ && codec_config_->codec == kCodecVP8 &&
       !bitstream_buffers_in_decoder_.empty()) {
     // Postpone ResetCodecState() after the drain.
     StartCodecDrain(DRAIN_FOR_RESET);
   } else {
     ResetCodecState();
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&AndroidVideoDecodeAccelerator::NotifyResetDone,
                               weak_this_factory_.GetWeakPtr()));
   }
 }
@@ skipping 17 matching lines @@
   DVLOG(1) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   picture_buffer_manager_.Destroy(output_picture_buffers_);
 
   client_ = nullptr;
 
   // Some VP8 files require a complete MediaCodec drain before we can call
   // MediaCodec.flush() or MediaCodec.release(). http://crbug.com/598963. In
   // that case, postpone ActualDestroy() until after the drain.
-  if (media_codec_ && codec_config_->codec_ == kCodecVP8) {
+  if (media_codec_ && codec_config_->codec == kCodecVP8) {
     // Clear |pending_bitstream_records_|.
     while (!pending_bitstream_records_.empty())
       pending_bitstream_records_.pop();
 
     StartCodecDrain(DRAIN_FOR_DESTROY);
   } else {
     ActualDestroy();
   }
 }
 
 void AndroidVideoDecodeAccelerator::ActualDestroy() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Note that async codec construction might still be in progress.  In that
   // case, the codec will be deleted when it completes once we invalidate all
   // our weak refs.
   weak_this_factory_.InvalidateWeakPtrs();
   g_avda_manager.Get().StopTimer(this);
   if (media_codec_) {
     AVDACodecAllocator::Instance()->ReleaseMediaCodec(
-        std::move(media_codec_), codec_config_->task_type_, config_.surface_id);
+        std::move(media_codec_), codec_config_->task_type, config_.surface_id);
   }
 
   // We no longer care about |surface_id|, in case we did before.  It's okay
   // if we have no surface and/or weren't the owner or a waiter.
   AVDACodecAllocator::Instance()->DeallocateSurface(this, config_.surface_id);
 
   delete this;
 }
 
 bool AndroidVideoDecodeAccelerator::TryToSetupDecodeOnSeparateThread(
@@ skipping 35 matching lines @@
     UpdateSurface();
     return;
   }
 
   // If we're currently asynchronously configuring a codec, it will be destroyed
   // when configuration completes and it notices that |state_| has changed to
   // SURFACE_DESTROYED.
   state_ = SURFACE_DESTROYED;
   if (media_codec_) {
     AVDACodecAllocator::Instance()->ReleaseMediaCodec(
-        std::move(media_codec_), codec_config_->task_type_, config_.surface_id);
+        std::move(media_codec_), codec_config_->task_type, config_.surface_id);
     picture_buffer_manager_.CodecChanged(nullptr);
   }
 
   // If we're draining, signal completion now because the drain can no longer
   // proceed.
   if (drain_type_ != DRAIN_TYPE_NONE)
     OnDrainCompleted();
 }
 
 void AndroidVideoDecodeAccelerator::InitializeCdm() {
@@ skipping 45 matching lines @@
     NotifyInitializationComplete(false);
     return;
   }
 
   DCHECK(!media_crypto->is_null());
 
   // We assume this is a part of the initialization process, thus MediaCodec
   // is not created yet.
   DCHECK(!media_codec_);
 
-  codec_config_->media_crypto_ = std::move(media_crypto);
-  codec_config_->needs_protected_surface_ = needs_protected_surface;
+  codec_config_->media_crypto = std::move(media_crypto);
+  codec_config_->needs_protected_surface = needs_protected_surface;
 
   // After receiving |media_crypto_| we can configure MediaCodec.
   ConfigureMediaCodecAsynchronously();
 }
 
 void AndroidVideoDecodeAccelerator::OnKeyAdded() {
   DVLOG(1) << __FUNCTION__;
 
   if (state_ == WAITING_FOR_KEY)
     state_ = NO_ERROR;
@@ skipping 148 matching lines @@
   }
 #endif
 
   return capabilities;
 }
 
 bool AndroidVideoDecodeAccelerator::IsMediaCodecSoftwareDecodingForbidden()
     const {
   // Prevent MediaCodec from using its internal software decoders when we have
   // more secure and up to date versions in the renderer process.
-  return !config_.is_encrypted && (codec_config_->codec_ == kCodecVP8 ||
-                                   codec_config_->codec_ == kCodecVP9);
+  return !config_.is_encrypted && (codec_config_->codec == kCodecVP8 ||
+                                   codec_config_->codec == kCodecVP9);
 }
 
 bool AndroidVideoDecodeAccelerator::UpdateSurface() {
   DCHECK(pending_surface_id_);
   DCHECK_NE(config_.surface_id, pending_surface_id_.value());
   DCHECK(config_.surface_id == SurfaceManager::kNoSurfaceID ||
          pending_surface_id_.value() == SurfaceManager::kNoSurfaceID);
 
   const int previous_surface_id = config_.surface_id;
   const int new_surface_id = pending_surface_id_.value();
   pending_surface_id_.reset();
   bool success = true;
 
   // TODO(watk): Fix this so we can wait for the new surface to be allocated.
   if (!AVDACodecAllocator::Instance()->AllocateSurface(this, new_surface_id)) {
     NOTIFY_ERROR(PLATFORM_FAILURE, "Failed to allocate the new surface");
     success = false;
   }
 
   // Ensure the current context is active when switching surfaces; we may need
   // to create a new texture.
   if (success && !make_context_current_cb_.Run()) {
     NOTIFY_ERROR(PLATFORM_FAILURE,
                  "Failed to make this decoder's GL context current when "
                  "switching surfaces.");
     success = false;
   }
 
   if (success) {
-    codec_config_->surface_ =
-        picture_buffer_manager_.Initialize(new_surface_id);
-    if (codec_config_->surface_.IsEmpty()) {
+    codec_config_->surface = picture_buffer_manager_.Initialize(new_surface_id);
+    if (codec_config_->surface.IsEmpty()) {
       NOTIFY_ERROR(PLATFORM_FAILURE, "Failed to switch surfaces.");
       success = false;
     }
   }
 
   if (success && media_codec_ &&
-      !media_codec_->SetSurface(codec_config_->surface_.j_surface().obj())) {
+      !media_codec_->SetSurface(codec_config_->surface.j_surface().obj())) {
     NOTIFY_ERROR(PLATFORM_FAILURE, "MediaCodec failed to switch surfaces.");
     success = false;
   }
 
   if (success) {
     config_.surface_id = new_surface_id;
   } else {
     // This might be called from OnSurfaceDestroyed(), so we have to release the
     // MediaCodec if we failed to switch the surface.
     if (media_codec_) {
       AVDACodecAllocator::Instance()->ReleaseMediaCodec(
-          std::move(media_codec_), codec_config_->task_type_,
+          std::move(media_codec_), codec_config_->task_type,
           previous_surface_id);
       picture_buffer_manager_.CodecChanged(nullptr);
     }
     AVDACodecAllocator::Instance()->DeallocateSurface(this, new_surface_id);
   }
 
   // Regardless of whether we succeeded, we no longer own the previous surface.
   AVDACodecAllocator::Instance()->DeallocateSurface(this, previous_surface_id);
 
   return success;
 }
 
 }  // namespace media