media: Delete VDA specific code from MCVD

media/gpu/android/media_codec_video_decoder.cc

-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Copyright 2016 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/media_codec_video_decoder.h"
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/android/build_info.h"
@@ skipping 37 matching lines @@
 #define NOTIFY_ERROR(error_code, error_message)      \
   do {                                               \
     DLOG(ERROR) << error_message;                    \
     NotifyError(VideoDecodeAccelerator::error_code); \
   } while (0)
 
 namespace media {
 
 namespace {
 
-enum { kNumPictureBuffers = limits::kMaxVideoFrames + 1 };
-
 // Max number of bitstreams notified to the client with
 // NotifyEndOfBitstreamBuffer() before getting output from the bitstream.
 enum { kMaxBitstreamsNotifiedInAdvance = 32 };
 
 // MediaCodec is only guaranteed to support baseline, but some devices may
 // support others. Advertise support for all H264 profiles and let the
 // MediaCodec fail when decoding if it's not actually supported. It's assumed
 // that consumers won't have software fallback for H264 on Android anyway.
 constexpr VideoCodecProfile kSupportedH264Profiles[] = {
     H264PROFILE_BASELINE,
@@ skipping 151 matching lines @@
 
 MediaCodecVideoDecoder::BitstreamRecord::~BitstreamRecord() {}
 
 MediaCodecVideoDecoder::MediaCodecVideoDecoder(
     const MakeGLContextCurrentCallback& make_context_current_cb,
     const GetGLES2DecoderCallback& get_gles2_decoder_cb)
     : client_(NULL),
       make_context_current_cb_(make_context_current_cb),
       get_gles2_decoder_cb_(get_gles2_decoder_cb),
       state_(NO_ERROR),
-      picturebuffers_requested_(false),
       picture_buffer_manager_(get_gles2_decoder_cb),
       drain_type_(DRAIN_TYPE_NONE),
       media_drm_bridge_cdm_context_(nullptr),
       cdm_registration_id_(0),
       pending_input_buf_index_(-1),
       deferred_initialization_pending_(false),
       codec_needs_reset_(false),
       defer_surface_creation_(false),
       weak_this_factory_(this) {}
 
@@ skipping 10 matching lines @@
 
   // Cancel previously registered callback (if any).
   media_drm_bridge_cdm_context_->SetMediaCryptoReadyCB(
       MediaDrmBridgeCdmContext::MediaCryptoReadyCB());
 
   media_drm_bridge_cdm_context_->UnregisterPlayer(cdm_registration_id_);
 #endif  // defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
 }
 
 bool MediaCodecVideoDecoder::Initialize(const Config& config, Client* client) {
-  DVLOG(1) << __FUNCTION__ << ": " << config.AsHumanReadableString();
+  DVLOG(1) << __func__ << ": " << config.AsHumanReadableString();
   TRACE_EVENT0("media", "MCVD::Initialize");
   DCHECK(!media_codec_);
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (make_context_current_cb_.is_null() || get_gles2_decoder_cb_.is_null()) {
     DLOG(ERROR) << "GL callbacks are required for this VDA";
     return false;
   }
 
   if (config.output_mode != Config::OutputMode::ALLOCATE) {
@@ skipping 103 matching lines @@
   if (config_.is_encrypted) {
     InitializeCdm();
     return true;
   }
 
   if (deferred_initialization_pending_ || defer_surface_creation_) {
     defer_surface_creation_ = false;
     ConfigureMediaCodecAsynchronously();
     return true;
   }
-
-  // If the client doesn't support deferred initialization (WebRTC), then we
-  // should complete it now and return a meaningful result.  Note that it would
-  // be nice if we didn't have to worry about starting codec configuration at
-  // all (::Initialize or the wrapper can do it), but then they have to remember
-  // not to start codec config if we have to wait for the cdm.  It's somewhat
-  // clearer for us to handle both cases.
-  return ConfigureMediaCodecSynchronously();
 }
 
 void MediaCodecVideoDecoder::DoIOTask(bool start_timer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "MCVD::DoIOTask");
   if (state_ == ERROR || state_ == WAITING_FOR_CODEC ||
       state_ == SURFACE_DESTROYED) {
     return;
   }
 
@@ skipping 95 matching lines @@
   if (key_id.empty() || iv.empty()) {
     status = media_codec_->QueueInputBuffer(input_buf_index, memory,
                                             bitstream_buffer.size(),
                                             presentation_timestamp);
   } else {
     status = media_codec_->QueueSecureInputBuffer(
         input_buf_index, memory, bitstream_buffer.size(), key_id, iv,
         subsamples, presentation_timestamp);
   }
 
-  DVLOG(2) << __FUNCTION__
+  DVLOG(2) << __func__
            << ": Queue(Secure)InputBuffer: pts:" << presentation_timestamp
            << " status:" << status;
 
   if (status == MEDIA_CODEC_NO_KEY) {
     // Keep trying to enqueue the same input buffer.
     // The buffer is owned by us (not the MediaCodec) and is filled with data.
     DVLOG(1) << "QueueSecureInputBuffer failed: NO_KEY";
     pending_input_buf_index_ = input_buf_index;
     state_ = WAITING_FOR_KEY;
     return false;
@@ skipping 22 matching lines @@
   }
 
   return true;
 }
 
 bool MediaCodecVideoDecoder::DequeueOutput() {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "MCVD::DequeueOutput");
   if (state_ == ERROR || state_ == WAITING_FOR_CODEC)
     return false;
-  // If we're draining for reset or destroy, then we don't need picture buffers
-  // since we won't send any decoded frames anyway.  There might not be any,
-  // since the pipeline might not be sending them back and / or they don't
-  // exist anymore.  From the pipeline's point of view, for Destroy at least,
-  // the VDA is already gone.
-  if (picturebuffers_requested_ && output_picture_buffers_.empty() &&
-      !IsDrainingForResetOrDestroy()) {
-    return false;
-  }
   if (!output_picture_buffers_.empty() && free_picture_ids_.empty() &&
       !IsDrainingForResetOrDestroy()) {
     // Don't have any picture buffer to send. Need to wait.
     return false;
   }
 
   // If we're waiting to switch surfaces pause output release until we have all
   // picture buffers returned. This is so we can ensure the right flags are set
   // on the picture buffers returned to the client.
   if (pending_surface_id_) {
@@ skipping 16 matching lines @@
         &eos, NULL);
     TRACE_EVENT_END2("media", "MCVD::DequeueOutput", "status", status,
                      "presentation_timestamp (ms)",
                      presentation_timestamp.InMilliseconds());
 
     switch (status) {
       case MEDIA_CODEC_ERROR:
         // Do not post an error if we are draining for reset and destroy.
         // Instead, run the drain completion task.
         if (IsDrainingForResetOrDestroy()) {
-          DVLOG(1) << __FUNCTION__ << ": error while codec draining";
+          DVLOG(1) << __func__ << ": error while codec draining";
           state_ = ERROR;
           OnDrainCompleted();
         } else {
           NOTIFY_ERROR(PLATFORM_FAILURE, "DequeueOutputBuffer failed.");
         }
         return false;
 
       case MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER:
         return false;
 
       case MEDIA_CODEC_OUTPUT_FORMAT_CHANGED: {
         // An OUTPUT_FORMAT_CHANGED is not reported after flush() if the frame
         // size does not change. Therefore we have to keep track on the format
         // even if draining, unless we are draining for destroy.
         if (drain_type_ == DRAIN_FOR_DESTROY)
           return true;  // ignore
 
         if (media_codec_->GetOutputSize(&size_) != MEDIA_CODEC_OK) {
           NOTIFY_ERROR(PLATFORM_FAILURE, "GetOutputSize failed.");
           return false;
         }
 
-        DVLOG(3) << __FUNCTION__
+        DVLOG(3) << __func__
                  << " OUTPUT_FORMAT_CHANGED, new size: " << size_.ToString();
-
-        // Don't request picture buffers if we already have some. This avoids
-        // having to dismiss the existing buffers which may actively reference
-        // decoded images. Breaking their connection to the decoded image will
-        // cause rendering of black frames. Instead, we let the existing
-        // PictureBuffers live on and we simply update their size the next time
-        // they're attached to an image of the new resolution. See the
-        // size update in |SendDecodedFrameToClient| and https://crbug/587994.
-        if (output_picture_buffers_.empty() && !picturebuffers_requested_) {
-          picturebuffers_requested_ = true;
-          base::ThreadTaskRunnerHandle::Get()->PostTask(
-              FROM_HERE,
-              base::Bind(&MediaCodecVideoDecoder::RequestPictureBuffers,
-                         weak_this_factory_.GetWeakPtr()));
-          return false;
-        }
-
         return true;
       }
 
       case MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED:
         break;
 
       case MEDIA_CODEC_OK:
         DCHECK_GE(buf_index, 0);
-        DVLOG(3) << __FUNCTION__ << ": pts:" << presentation_timestamp
+        DVLOG(3) << __func__ << ": pts:" << presentation_timestamp
                  << " buf_index:" << buf_index << " offset:" << offset
                  << " size:" << size << " eos:" << eos;
         break;
 
       default:
         NOTREACHED();
         break;
     }
   } while (buf_index < 0);
 
   if (eos) {
     OnDrainCompleted();
     return false;
   }
 
   if (IsDrainingForResetOrDestroy()) {
     media_codec_->ReleaseOutputBuffer(buf_index, false);
     return true;
   }
 
-  if (!picturebuffers_requested_) {
-    // In 0.01% of playbacks MediaCodec returns a frame before FORMAT_CHANGED.
-    // Occurs on JB and M. (See the Media.MCVD.MissingFormatChanged histogram.)
-    media_codec_->ReleaseOutputBuffer(buf_index, false);
-    NOTIFY_ERROR(PLATFORM_FAILURE, "Dequeued buffers before FORMAT_CHANGED.");
-    return false;
-  }
+  // TODO(watk): Handle the case where we get a decoded buffer before
+  // FORMAT_CHANGED.
+  // In 0.01% of playbacks MediaCodec returns a frame before FORMAT_CHANGED.
+  // Occurs on JB and M. (See the Media.MCVD.MissingFormatChanged histogram.)
 
   // Get the bitstream buffer id from the timestamp.
   auto it = bitstream_buffers_in_decoder_.find(presentation_timestamp);
 
   if (it != bitstream_buffers_in_decoder_.end()) {
     const int32_t bitstream_buffer_id = it->second;
     bitstream_buffers_in_decoder_.erase(bitstream_buffers_in_decoder_.begin(),
                                         ++it);
     SendDecodedFrameToClient(buf_index, bitstream_buffer_id);
 
     // Removes ids former or equal than the id from decoder. Note that
     // |bitstreams_notified_in_advance_| does not mean bitstream ids in decoder
     // because of frame reordering issue. We just maintain this roughly and use
     // it for throttling.
     for (auto bitstream_it = bitstreams_notified_in_advance_.begin();
          bitstream_it != bitstreams_notified_in_advance_.end();
          ++bitstream_it) {
       if (*bitstream_it == bitstream_buffer_id) {
         bitstreams_notified_in_advance_.erase(
             bitstreams_notified_in_advance_.begin(), ++bitstream_it);
         break;
       }
     }
   } else {
     // Normally we assume that the decoder makes at most one output frame for
     // each distinct input timestamp. However MediaCodecBridge uses timestamp
     // correction and provides a non-decreasing timestamp sequence, which might
     // result in timestamp duplicates. Discard the frame if we cannot get the
     // corresponding buffer id.
-    DVLOG(3) << __FUNCTION__ << ": Releasing buffer with unexpected PTS: "
+    DVLOG(3) << __func__ << ": Releasing buffer with unexpected PTS: "
              << presentation_timestamp;
     media_codec_->ReleaseOutputBuffer(buf_index, false);
   }
 
   // We got a decoded frame, so try for another.
   return true;
 }
 
 void MediaCodecVideoDecoder::SendDecodedFrameToClient(
     int32_t codec_buffer_index,
@@ skipping 82 matching lines @@
 
 void MediaCodecVideoDecoder::DecodeBuffer(
     const BitstreamBuffer& bitstream_buffer) {
   pending_bitstream_records_.push(BitstreamRecord(bitstream_buffer));
   TRACE_COUNTER1("media", "MCVD::PendingBitstreamBufferCount",
                  pending_bitstream_records_.size());
 
   DoIOTask(true);
 }
 
-void MediaCodecVideoDecoder::RequestPictureBuffers() {
-  if (client_) {
-    // Allocate a picture buffer that is the actual frame size.  Note that it
-    // will be an external texture anyway, so it doesn't allocate an image of
-    // that size.  It's important to get the coded size right, so that
-    // VideoLayerImpl doesn't try to scale the texture when building the quad
-    // for it.
-    client_->ProvidePictureBuffers(kNumPictureBuffers, PIXEL_FORMAT_UNKNOWN, 1,
-                                   size_,
-                                   AVDAPictureBufferManager::kTextureTarget);
-  }
-}
-
-void MediaCodecVideoDecoder::AssignPictureBuffers(
-    const std::vector<PictureBuffer>& buffers) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(output_picture_buffers_.empty());
-  DCHECK(free_picture_ids_.empty());
-
-  if (buffers.size() < kNumPictureBuffers) {
-    NOTIFY_ERROR(INVALID_ARGUMENT, "Not enough picture buffers assigned.");
-    return;
-  }
-
-  const bool have_context = make_context_current_cb_.Run();
-  LOG_IF(WARNING, !have_context)
-      << "Failed to make GL context current for Assign, continuing.";
-
-  for (size_t i = 0; i < buffers.size(); ++i) {
-    DCHECK(buffers[i].size() == size_);
-    int32_t id = buffers[i].id();
-    output_picture_buffers_.insert(std::make_pair(id, buffers[i]));
-    free_picture_ids_.push(id);
-
-    picture_buffer_manager_.AssignPictureBuffer(buffers[i], size_,
-                                                have_context);
-  }
-  TRACE_COUNTER1("media", "MCVD::FreePictureIds", free_picture_ids_.size());
-  DoIOTask(true);
-}
-
-void MediaCodecVideoDecoder::ReusePictureBuffer(int32_t picture_buffer_id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  free_picture_ids_.push(picture_buffer_id);
-  TRACE_COUNTER1("media", "MCVD::FreePictureIds", free_picture_ids_.size());
-
-  auto it = output_picture_buffers_.find(picture_buffer_id);
-  if (it == output_picture_buffers_.end()) {
-    NOTIFY_ERROR(PLATFORM_FAILURE, "Can't find PictureBuffer id "
-                                       << picture_buffer_id);
-    return;
-  }
-
-  picture_buffer_manager_.ReusePictureBuffer(it->second);
-  DoIOTask(true);
-}
-
 void MediaCodecVideoDecoder::Flush() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (state_ == SURFACE_DESTROYED || defer_surface_creation_)
     NotifyFlushDone();
   else
     StartCodecDrain(DRAIN_FOR_FLUSH);
 }
 
 void MediaCodecVideoDecoder::ConfigureMediaCodecAsynchronously() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 20 matching lines @@
   if (codec_config_->task_type_ == TaskType::SW_CODEC &&
       IsMediaCodecSoftwareDecodingForbidden()) {
     OnCodecConfigured(nullptr);
     return;
   }
 
   AVDACodecAllocator::Instance()->CreateMediaCodecAsync(
       weak_this_factory_.GetWeakPtr(), codec_config_);
 }
 
-bool MediaCodecVideoDecoder::ConfigureMediaCodecSynchronously() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!media_codec_);
-  DCHECK_NE(state_, WAITING_FOR_CODEC);
-  state_ = WAITING_FOR_CODEC;
-
-  codec_config_->task_type_ =
-      AVDACodecAllocator::Instance()->TaskTypeForAllocation();
-  if (codec_config_->task_type_ == TaskType::FAILED_CODEC) {
-    OnCodecConfigured(nullptr);
-    return false;
-  }
-
-  std::unique_ptr<VideoCodecBridge> media_codec =
-      AVDACodecAllocator::Instance()->CreateMediaCodecSync(codec_config_);
-  OnCodecConfigured(std::move(media_codec));
-  return !!media_codec_;
-}
-
 void MediaCodecVideoDecoder::OnCodecConfigured(
     std::unique_ptr<VideoCodecBridge> media_codec) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(state_ == WAITING_FOR_CODEC || state_ == SURFACE_DESTROYED);
 
   // If we are supposed to notify that initialization is complete, then do so
   // now.  Otherwise, this is a reconfiguration.
   if (deferred_initialization_pending_) {
     // Losing the output surface is not considered an error state, so notify
     // success. The client will destroy this soon.
@@ skipping 14 matching lines @@
     NOTIFY_ERROR(PLATFORM_FAILURE, "Failed to create MediaCodec");
     return;
   }
 
   state_ = NO_ERROR;
 
   ManageTimer(true);
 }
 
 void MediaCodecVideoDecoder::StartCodecDrain(DrainType drain_type) {
-  DVLOG(2) << __FUNCTION__ << " drain_type:" << drain_type;
+  DVLOG(2) << __func__ << " drain_type:" << drain_type;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // We assume that DRAIN_FOR_FLUSH and DRAIN_FOR_RESET cannot come while
   // another drain request is present, but DRAIN_FOR_DESTROY can.
   DCHECK_NE(drain_type, DRAIN_TYPE_NONE);
   DCHECK(drain_type_ == DRAIN_TYPE_NONE || drain_type == DRAIN_FOR_DESTROY)
       << "Unexpected StartCodecDrain() with drain type " << drain_type
       << " while already draining with drain type " << drain_type_;
 
   const bool enqueue_eos = drain_type_ == DRAIN_TYPE_NONE;
   drain_type_ = drain_type;
 
   if (enqueue_eos)
     DecodeBuffer(BitstreamBuffer(-1, base::SharedMemoryHandle(), 0));
 }
 
 bool MediaCodecVideoDecoder::IsDrainingForResetOrDestroy() const {
   return drain_type_ == DRAIN_FOR_RESET || drain_type_ == DRAIN_FOR_DESTROY;
 }
 
 void MediaCodecVideoDecoder::OnDrainCompleted() {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // If we were waiting for an EOS, clear the state and reset the MediaCodec
   // as normal.
   //
   // Some Android platforms seem to send an EOS buffer even when we're not
   // expecting it. In this case, destroy and reset the codec but don't notify
   // flush done since it violates the state machine. http://crbug.com/585959.
 
   switch (drain_type_) {
@@ skipping 52 matching lines @@
   // frames that might be out for display at end of stream.
   codec_needs_reset_ = false;
   if (drain_type_ == DRAIN_FOR_FLUSH && !did_codec_error_happen) {
     codec_needs_reset_ = true;
     return;
   }
 
   // Flush the codec if possible, or create a new one if not.
   if (!did_codec_error_happen &&
       !MediaCodecUtil::CodecNeedsFlushWorkaround(media_codec_.get())) {
-    DVLOG(3) << __FUNCTION__ << " Flushing MediaCodec.";
+    DVLOG(3) << __func__ << " Flushing MediaCodec.";
     media_codec_->Flush();
     // Since we just flushed all the output buffers, make sure that nothing is
     // using them.
     picture_buffer_manager_.CodecChanged(media_codec_.get());
   } else {
-    DVLOG(3) << __FUNCTION__
-             << " Deleting the MediaCodec and creating a new one.";
+    DVLOG(3) << __func__ << " Deleting the MediaCodec and creating a new one.";
     g_mcvd_manager.Get().StopTimer(this);
     ConfigureMediaCodecAsynchronously();
   }
 }
 
 void MediaCodecVideoDecoder::Reset() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "MCVD::Reset");
 
   if (defer_surface_creation_) {
     DCHECK(!media_codec_);
     DCHECK(pending_bitstream_records_.empty());
     DCHECK_EQ(state_, NO_ERROR);
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&MediaCodecVideoDecoder::NotifyResetDone,
                               weak_this_factory_.GetWeakPtr()));
@@ skipping 40 matching lines @@
     return;
   }
 
   // Surface changes never take effect immediately, they will be handled during
   // DequeOutput() once we get to a good switch point or immediately during an
   // OnSurfaceDestroyed() call.
   pending_surface_id_ = surface_id;
 }
 
 void MediaCodecVideoDecoder::Destroy() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   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) {
     // Clear |pending_bitstream_records_|.
     while (!pending_bitstream_records_.empty())
       pending_bitstream_records_.pop();
 
     StartCodecDrain(DRAIN_FOR_DESTROY);
   } else {
     ActualDestroy();
   }
 }
 
 void MediaCodecVideoDecoder::ActualDestroy() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   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_mcvd_manager.Get().StopTimer(this);
   if (media_codec_) {
     AVDACodecAllocator::Instance()->ReleaseMediaCodec(
         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 MediaCodecVideoDecoder::TryToSetupDecodeOnSeparateThread(
-    const base::WeakPtr<Client>& decode_client,
-    const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner) {
-  return false;
-}
-
 void MediaCodecVideoDecoder::OnSurfaceDestroyed() {
   DVLOG(1) << __func__;
   TRACE_EVENT0("media", "MCVD::OnSurfaceDestroyed");
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // If the API is available avoid having to restart the decoder in order to
   // leave fullscreen. If we don't clear the surface immediately during this
   // callback, the MediaCodec will throw an error as the surface is destroyed.
   if (base::android::BuildInfo::GetInstance()->sdk_int() >= 23) {
     // Since we can't wait for a transition, we must invalidate all outstanding
@@ skipping 22 matching lines @@
     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 MediaCodecVideoDecoder::InitializeCdm() {
-  DVLOG(2) << __FUNCTION__ << ": " << config_.cdm_id;
+  DVLOG(2) << __func__ << ": " << config_.cdm_id;
 
 #if !defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
   NOTIMPLEMENTED();
   NotifyInitializationComplete(false);
 #else
   // Store the CDM to hold a reference to it.
   cdm_for_reference_holding_only_ =
       MojoCdmService::LegacyGetCdm(config_.cdm_id);
   DCHECK(cdm_for_reference_holding_only_);
 
@@ skipping 18 matching lines @@
   // Deferred initialization will continue in OnMediaCryptoReady().
   media_drm_bridge_cdm_context_->SetMediaCryptoReadyCB(
       BindToCurrentLoop(base::Bind(&MediaCodecVideoDecoder::OnMediaCryptoReady,
                                    weak_this_factory_.GetWeakPtr())));
 #endif  // !defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
 }
 
 void MediaCodecVideoDecoder::OnMediaCryptoReady(
     MediaDrmBridgeCdmContext::JavaObjectPtr media_crypto,
     bool needs_protected_surface) {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
 
   if (!media_crypto) {
     LOG(ERROR) << "MediaCrypto is not available, can't play encrypted stream.";
     cdm_for_reference_holding_only_ = nullptr;
     media_drm_bridge_cdm_context_ = nullptr;
     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;
 
   // After receiving |media_crypto_| we can configure MediaCodec.
   ConfigureMediaCodecAsynchronously();
 }
 
 void MediaCodecVideoDecoder::OnKeyAdded() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
 
   if (state_ == WAITING_FOR_KEY)
     state_ = NO_ERROR;
 
   DoIOTask(true);
 }
 
-void MediaCodecVideoDecoder::NotifyInitializationComplete(bool success) {
-  if (client_)
-    client_->NotifyInitializationComplete(success);
-}
-
-void MediaCodecVideoDecoder::NotifyPictureReady(const Picture& picture) {
-  if (client_)
-    client_->PictureReady(picture);
-}
-
-void MediaCodecVideoDecoder::NotifyEndOfBitstreamBuffer(int input_buffer_id) {
-  if (client_)
-    client_->NotifyEndOfBitstreamBuffer(input_buffer_id);
-}
-
-void MediaCodecVideoDecoder::NotifyFlushDone() {
-  if (client_)
-    client_->NotifyFlushDone();
-}
-
-void MediaCodecVideoDecoder::NotifyResetDone() {
-  if (client_)
-    client_->NotifyResetDone();
-}
-
 void MediaCodecVideoDecoder::NotifyError(Error error) {
   state_ = ERROR;
   if (client_)
     client_->NotifyError(error);
 }
 
 void MediaCodecVideoDecoder::ManageTimer(bool did_work) {
   bool should_be_running = true;
 
   base::TimeTicks now = base::TimeTicks::Now();
@@ skipping 172 matching lines @@
     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