Reverted the code for the non-interactive audible tab notification

media/base/android/media_source_player.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/media_source_player.h"
 
 #include <limits>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
@@ skipping 116 matching lines @@
 void MediaSourcePlayer::Pause(bool is_media_related_action) {
   DVLOG(1) << __FUNCTION__;
 
   // Since decoder jobs have their own thread, decoding is not fully paused
   // until all the decoder jobs call MediaDecoderCallback(). It is possible
   // that Start() is called while the player is waiting for
   // MediaDecoderCallback(). In that case, decoding will continue when
   // MediaDecoderCallback() is called.
   playing_ = false;
   start_time_ticks_ = base::TimeTicks();
-
-  SetAudible(false);
 }
 
 bool MediaSourcePlayer::IsPlaying() {
   return playing_;
 }
 
 int MediaSourcePlayer::GetVideoWidth() {
   return video_decoder_job_->output_width();
 }
 
@@ skipping 32 matching lines @@
   DVLOG(1) << __FUNCTION__;
 
   audio_decoder_job_->ReleaseDecoderResources();
   video_decoder_job_->ReleaseDecoderResources();
 
   // Prevent player restart, including job re-creation attempts.
   playing_ = false;
 
   decoder_starvation_callback_.Cancel();
 
-  SetAudible(false);
   DetachListener();
 }
 
 void MediaSourcePlayer::SetVolume(double volume) {
   audio_decoder_job_->SetVolume(volume);
 }
 
 bool MediaSourcePlayer::CanPause() {
   return Seekable();
 }
@@ skipping 286 matching lines @@
     PlaybackCompleted(is_audio);
     if (is_clock_manager)
       interpolator_.StopInterpolating();
   }
 
   if (pending_event_ != NO_EVENT_PENDING) {
     ProcessPendingEvents();
     return;
   }
 
-  if (status == MEDIA_CODEC_OUTPUT_END_OF_STREAM) {
-    if (is_audio)
-      SetAudible(false);
+  if (status == MEDIA_CODEC_OUTPUT_END_OF_STREAM)
     return;
-  }
 
   if (!playing_) {
     if (is_clock_manager)
       interpolator_.StopInterpolating();
 
-    if (is_audio)
-      SetAudible(false);
     return;
   }
 
   if (status == MEDIA_CODEC_NO_KEY) {
     if (key_added_while_decode_pending_) {
       DVLOG(2) << __FUNCTION__ << ": Key was added during decoding.";
       ResumePlaybackAfterKeyAdded();
     } else {
-      if (is_audio)
-        SetAudible(false);
-
       is_waiting_for_key_ = true;
       manager()->OnWaitingForDecryptionKey(player_id());
     }
     return;
   }
 
   // If |key_added_while_decode_pending_| is true and both audio and video
   // decoding succeeded, we should clear |key_added_while_decode_pending_| here.
   // But that would add more complexity into this function. If we don't clear it
   // here, the worst case would be we call ResumePlaybackAfterKeyAdded() when
   // we don't really have a new key. This should rarely happen and the
   // performance impact should be pretty small.
   // TODO(qinmin/xhwang): This class is complicated because we handle both audio
   // and video in one file. If we separate them, we should be able to remove a
   // lot of duplication.
 
   // If the status is MEDIA_CODEC_ABORT, stop decoding new data. The player is
   // in the middle of a seek or stop event and needs to wait for the IPCs to
   // come.
-  if (status == MEDIA_CODEC_ABORT) {
-    if (is_audio)
-      SetAudible(false);
+  if (status == MEDIA_CODEC_ABORT)
     return;
-  }
 
   if (prerolling_ && IsPrerollFinished(is_audio)) {
     if (IsPrerollFinished(!is_audio)) {
       prerolling_ = false;
       StartInternal();
     }
     return;
   }
 
-  // We successfully decoded a frame and going to the next one.
-  // Set the audible state.
-  if (is_audio) {
-    bool is_audible = !prerolling_ && audio_decoder_job_->volume() > 0;
-    SetAudible(is_audible);
-  }
-
   if (is_clock_manager) {
     // If we have a valid timestamp, start the starvation callback. Otherwise,
     // reset the |start_time_ticks_| so that the next frame will not suffer
     // from the decoding delay caused by the current frame.
     if (current_presentation_timestamp != kNoTimestamp())
       StartStarvationCallback(current_presentation_timestamp,
                               max_presentation_timestamp);
     else
       start_time_ticks_ = base::TimeTicks::Now();
   }
@@ skipping 92 matching lines @@
   return audio_decoder_job_->OutputEOSReached() || !HasAudio();
 }
 
 bool MediaSourcePlayer::VideoFinished() {
   return video_decoder_job_->OutputEOSReached() || !HasVideo();
 }
 
 void MediaSourcePlayer::OnDecoderStarved() {
   DVLOG(1) << __FUNCTION__;
 
-  if (HasAudio()) {
-    // If the starvation timer fired but there are no encoded frames
-    // in the queue we believe the demuxer (i.e. renderer process) froze.
-    if (!audio_decoder_job_->HasData())
-      SetAudible(false);
-  }
-
   SetPendingEvent(PREFETCH_REQUEST_EVENT_PENDING);
   ProcessPendingEvents();
 }
 
 void MediaSourcePlayer::StartStarvationCallback(
     base::TimeDelta current_presentation_timestamp,
     base::TimeDelta max_presentation_timestamp) {
   // 20ms was chosen because it is the typical size of a compressed audio frame.
   // Anything smaller than this would likely cause unnecessary cycling in and
   // out of the prefetch state.
@@ skipping 150 matching lines @@
   // support setMediaKeys(0) (see http://crbug.com/330324), or when we release
   // MediaDrm when the video is paused, or when the device goes to sleep (see
   // http://crbug.com/272421).
   audio_decoder_job_->SetDrmBridge(NULL);
   video_decoder_job_->SetDrmBridge(NULL);
   cdm_registration_id_ = 0;
   drm_bridge_ = NULL;
 }
 
 }  // namespace media