media: Remove the unused NdkMediaCodecBridge

media/base/android/media_codec_loop.cc

 // 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/base/android/media_codec_loop.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/timestamp_constants.h"
 
 namespace media {
+namespace {
 
-// Declaring these as constexpr variables doesn't work in windows -- they
-// always are 0.  The exception is FromMicroseconds, which doesn't do any
-// conversion.  However, declaring these as constexpr functions seesm to work
-// fine everywhere.  We care that this works in windows because our unit tests
-// run on non-android platforms.
-constexpr base::TimeDelta DecodePollDelay() {
-  return base::TimeDelta::FromMilliseconds(10);
-}
+constexpr base::TimeDelta kDecodePollDelay =
+    base::TimeDelta::FromMilliseconds(10);
+constexpr base::TimeDelta kNoWaitTimeout = base::TimeDelta::FromMicroseconds(0);
+constexpr base::TimeDelta kIdleTimerTimeout = base::TimeDelta::FromSeconds(1);
 
-constexpr base::TimeDelta NoWaitTimeout() {
-  return base::TimeDelta::FromMicroseconds(0);
-}
-
-constexpr base::TimeDelta IdleTimerTimeout() {
-  return base::TimeDelta::FromSeconds(1);
-}
+}  // namespace
 
 MediaCodecLoop::InputData::InputData() {}
 
 MediaCodecLoop::InputData::InputData(const InputData& other)
     : memory(other.memory),
       length(other.length),
       key_id(other.key_id),
       iv(other.iv),
       subsamples(other.subsamples),
       presentation_time(other.presentation_time),
@@ skipping 109 matching lines @@
   // MediaCodec's QueueSecureInputBuffer().
   if (pending_input_buf_index_ != kInvalidBufferIndex) {
     InputBuffer result(pending_input_buf_index_, true);
     pending_input_buf_index_ = kInvalidBufferIndex;
     return result;
   }
 
   int input_buf_index = kInvalidBufferIndex;
 
   media::MediaCodecStatus status =
-      media_codec_->DequeueInputBuffer(NoWaitTimeout(), &input_buf_index);
+      media_codec_->DequeueInputBuffer(kNoWaitTimeout, &input_buf_index);
   switch (status) {
     case media::MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER:
       break;
 
     case media::MEDIA_CODEC_ERROR:
       DLOG(ERROR) << __func__ << ": MEDIA_CODEC_ERROR from DequeInputBuffer";
       SetState(STATE_ERROR);
       break;
 
     case media::MEDIA_CODEC_OK:
@@ skipping 79 matching lines @@
 
 bool MediaCodecLoop::ProcessOneOutputBuffer() {
   // TODO(liberato): When merging AVDA, we will also have to ask the client if
   // it can accept another output buffer.
 
   if (state_ == STATE_ERROR)
     return false;
 
   OutputBuffer out;
   MediaCodecStatus status = media_codec_->DequeueOutputBuffer(
-      NoWaitTimeout(), &out.index, &out.offset, &out.size, &out.pts,
-      &out.is_eos, &out.is_key_frame);
+      kNoWaitTimeout, &out.index, &out.offset, &out.size, &out.pts, &out.is_eos,
+      &out.is_key_frame);
 
   bool did_work = false;
   switch (status) {
     case MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED:
       // Output buffers are replaced in MediaCodecBridge, nothing to do.
       did_work = true;
       break;
 
     case MEDIA_CODEC_OUTPUT_FORMAT_CHANGED:
       if (!client_->OnOutputFormatChanged())
@@ skipping 45 matching lines @@
 void MediaCodecLoop::ManageTimer(bool did_work) {
   bool should_be_running = true;
 
   // One might also use DefaultTickClock, but then ownership becomes harder.
   base::TimeTicks now = (test_tick_clock_ ? test_tick_clock_->NowTicks()
                                           : base::TimeTicks::Now());
   if (did_work || idle_time_begin_ == base::TimeTicks()) {
     idle_time_begin_ = now;
   } else {
     // Make sure that we have done work recently enough, else stop the timer.
-    if (now - idle_time_begin_ > IdleTimerTimeout())
+    if (now - idle_time_begin_ > kIdleTimerTimeout)
       should_be_running = false;
   }
 
   if (should_be_running && !io_timer_.IsRunning()) {
-    io_timer_.Start(FROM_HERE, DecodePollDelay(), this,
+    io_timer_.Start(FROM_HERE, kDecodePollDelay, this,
                     &MediaCodecLoop::DoPendingWork);
   } else if (!should_be_running && io_timer_.IsRunning()) {
     io_timer_.Stop();
   }
 }
 
 void MediaCodecLoop::SetState(State new_state) {
   const State old_state = state_;
   state_ = new_state;
   if (old_state != new_state && new_state == STATE_ERROR)
@@ skipping 26 matching lines @@
     RETURN_STRING(STATE_DRAINED);
     RETURN_STRING(STATE_ERROR);
   }
 #undef RETURN_STRING
 
   NOTREACHED() << "Unknown state " << state;
   return nullptr;
 }
 
 }  // namespace media