Fix MediaSourcePlayer unittests and minor code cleanup.

media/base/android/media_decoder_job.cc

 // Copyright 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/media_decoder_job.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "media/base/android/media_codec_bridge.h"
@@ skipping 35 matching lines @@
   if (stop_decode_pending_) {
     OnDecodeCompleted(MEDIA_CODEC_STOPPED, kNoTimestamp(), 0);
     return;
   }
 
   access_unit_index_ = 0;
   received_data_ = data;
   done_cb.Run();
 }
 
-bool MediaDecoderJob::HasData() const {
-  DCHECK(ui_loop_->BelongsToCurrentThread());
-  return access_unit_index_ < received_data_.access_units.size();
-}
-
 void MediaDecoderJob::Prefetch(const base::Closure& prefetch_cb) {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   DCHECK(on_data_received_cb_.is_null());
   DCHECK(decode_cb_.is_null());
 
   if (HasData()) {
     ui_loop_->PostTask(FROM_HERE, prefetch_cb);
     return;
   }
 
@@ skipping 78 matching lines @@
         media_codec_bridge_->DequeueInputBuffer(timeout, &input_buf_index);
     if (status != MEDIA_CODEC_OK) {
       DVLOG(1) << "DequeueInputBuffer fails: " << status;
       return status;
     }
   }
 
   // TODO(qinmin): skip frames if video is falling far behind.
   DCHECK_GE(input_buf_index, 0);
   if (unit.end_of_stream || unit.data.empty()) {
-    media_codec_bridge_->QueueEOS(input_buf_index_);
+    media_codec_bridge_->QueueEOS(input_buf_index);
     return MEDIA_CODEC_INPUT_END_OF_STREAM;
   }
 
   if (unit.key_id.empty()) {
     return media_codec_bridge_->QueueInputBuffer(
         input_buf_index, &unit.data[0], unit.data.size(), unit.timestamp);
   }
 
   if (unit.iv.empty() || unit.subsamples.empty()) {
     DVLOG(1) << "The access unit doesn't have iv or subsamples while it "
                << "has key IDs!";
     return MEDIA_CODEC_ERROR;
   }
 
   MediaCodecStatus status = media_codec_bridge_->QueueSecureInputBuffer(
       input_buf_index, &unit.data[0], unit.data.size(),
       reinterpret_cast<const uint8*>(&unit.key_id[0]), unit.key_id.size(),
       reinterpret_cast<const uint8*>(&unit.iv[0]), unit.iv.size(),
       &unit.subsamples[0], unit.subsamples.size(), unit.timestamp);
 
   // In case of MEDIA_CODEC_NO_KEY, we must reuse the |input_buf_index_|.
   // Otherwise MediaDrm will report errors.
   if (status == MEDIA_CODEC_NO_KEY)
     input_buf_index_ = input_buf_index;
 
   return status;
 }
 
+bool MediaDecoderJob::HasData() const {
+  DCHECK(ui_loop_->BelongsToCurrentThread());
+  DCHECK(!input_eos_encountered_ ||
+         (received_data_.access_units.size() > 0 &&
+          access_unit_index_ < received_data_.access_units.size()))
+      << "access_unit_index_.size() " << received_data_.access_units.size()
+      << " access_unit_index_ " << access_unit_index_;
+  return access_unit_index_ < received_data_.access_units.size() ||
+      input_eos_encountered_;
+}
+
 void MediaDecoderJob::RequestData(const base::Closure& done_cb) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(ui_loop_->BelongsToCurrentThread());
   DCHECK(on_data_received_cb_.is_null());
+  DCHECK(!input_eos_encountered_);
 
   received_data_ = DemuxerData();
   access_unit_index_ = 0;
   on_data_received_cb_ = done_cb;
 
   request_data_cb_.Run();
 }
 
 void MediaDecoderJob::DecodeNextAccessUnit(
     const base::TimeTicks& start_time_ticks,
@@ skipping 43 matching lines @@
   bool output_eos_encountered = false;
 
   base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(
       kMediaCodecTimeoutInMilliseconds);
 
   MediaCodecStatus status = media_codec_bridge_->DequeueOutputBuffer(
       timeout, &buffer_index, &offset, &size, &presentation_timestamp,
       &output_eos_encountered);
 
   if (status != MEDIA_CODEC_OK) {
-    DCHECK(!(status == MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED ||
-             status == MEDIA_CODEC_OUTPUT_FORMAT_CHANGED) ||
-           (input_status != MEDIA_CODEC_INPUT_END_OF_STREAM));
-
     if (status == MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED) {
         media_codec_bridge_->GetOutputBuffers();
         status = MEDIA_CODEC_OK;
     }
     callback.Run(status, start_presentation_timestamp, 0);
     return;
   }
 
   // TODO(xhwang/qinmin): This logic is correct but strange. Clean it up.
   if (output_eos_encountered)
@@ skipping 31 matching lines @@
     size_t audio_output_bytes) {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   DCHECK(status != MEDIA_CODEC_STOPPED || received_data_.access_units.empty());
 
   if (destroy_pending_) {
     delete this;
     return;
   }
 
   DCHECK(!decode_cb_.is_null());
+  switch (status) {
+    case MEDIA_CODEC_OK:
+    case MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER:
+    case MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED:
+    case MEDIA_CODEC_OUTPUT_FORMAT_CHANGED:
+    case MEDIA_CODEC_OUTPUT_END_OF_STREAM:
+      if (!input_eos_encountered_)
+        access_unit_index_++;
+      break;
 
-  if (status != MEDIA_CODEC_ERROR &&
-      status != MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER &&
-      status != MEDIA_CODEC_INPUT_END_OF_STREAM &&
-      status != MEDIA_CODEC_NO_KEY &&
-      status != MEDIA_CODEC_STOPPED) {
-    access_unit_index_++;
-  }
+    case MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER:
+    case MEDIA_CODEC_INPUT_END_OF_STREAM:
+    case MEDIA_CODEC_NO_KEY:
+    case MEDIA_CODEC_STOPPED:
+    case MEDIA_CODEC_ERROR:
+      // Do nothing.
+      break;
+  };
 
   stop_decode_pending_ = false;
   base::ResetAndReturn(&decode_cb_).Run(status, presentation_timestamp,
                                         audio_output_bytes);
 }
 
 }  // namespace media