Reverted the code for the non-interactive audible tab notification

media/base/android/media_source_player_unittest.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 <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
@@ skipping 29 matching lines @@
 
 // Mock of MediaPlayerManager for testing purpose.
 class MockMediaPlayerManager : public MediaPlayerManager {
  public:
   explicit MockMediaPlayerManager(base::MessageLoop* message_loop)
       : message_loop_(message_loop),
         playback_completed_(false),
         num_resources_requested_(0),
         num_metadata_changes_(0),
         timestamp_updated_(false),
-        is_audible_(false),
-        is_delay_expired_(false),
         allow_play_(true) {}
   ~MockMediaPlayerManager() override {}
 
   // MediaPlayerManager implementation.
   MediaResourceGetter* GetMediaResourceGetter() override { return NULL; }
   MediaUrlInterceptor* GetMediaUrlInterceptor() override { return NULL; }
   void OnTimeUpdate(int player_id,
                     base::TimeDelta current_time,
                     base::TimeTicks current_time_ticks) override {
     timestamp_updated_ = true;
@@ skipping 17 matching lines @@
   void OnError(int player_id, int error) override {}
   void OnVideoSizeChanged(int player_id, int width, int height) override {}
   void OnWaitingForDecryptionKey(int player_id) override {}
   MediaPlayerAndroid* GetFullscreenPlayer() override { return NULL; }
   MediaPlayerAndroid* GetPlayer(int player_id) override { return NULL; }
 
   bool RequestPlay(int player_id) override {
     return allow_play_;
   }
 
-  void OnAudibleStateChanged(int player_id, bool is_audible_now) override {
-    is_audible_ = is_audible_now;
-  }
-
   bool playback_completed() const {
     return playback_completed_;
   }
 
   int num_resources_requested() const {
     return num_resources_requested_;
   }
 
   int num_metadata_changes() const {
     return num_metadata_changes_;
   }
 
   void OnMediaResourcesRequested(int player_id) {
     num_resources_requested_++;
   }
 
   bool timestamp_updated() const {
     return timestamp_updated_;
   }
 
   void ResetTimestampUpdated() {
     timestamp_updated_ = false;
   }
 
-  bool is_audible() const {
-    return is_audible_;
-  }
-
-  bool is_delay_expired() const {
-    return is_delay_expired_;
-  }
-
-  void SetDelayExpired(bool value) {
-    is_delay_expired_ = value;
-  }
-
   void set_allow_play(bool value) {
     allow_play_ = value;
   }
 
  private:
   base::MessageLoop* message_loop_;
   bool playback_completed_;
   // The number of resource requests this object has seen.
   int num_resources_requested_;
   // The number of metadata changes reported by the player.
   int num_metadata_changes_;
   // Playback timestamp was updated.
   bool timestamp_updated_;
-  // Audible state of the pipeline
-  bool is_audible_;
-  // Helper flag to ensure delay for WaitForDelay().
-  bool is_delay_expired_;
   // Whether the manager will allow players that request playing.
   bool allow_play_;
 
   DISALLOW_COPY_AND_ASSIGN(MockMediaPlayerManager);
 };
 
 class MockDemuxerAndroid : public DemuxerAndroid {
  public:
   explicit MockDemuxerAndroid(base::MessageLoop* message_loop)
       : message_loop_(message_loop),
@@ skipping 403 matching lines @@
       EXPECT_TRUE(GetMediaDecoderJob(is_audio)->is_decoding());
       EXPECT_TRUE(GetMediaCodecBridge(is_audio));
       EXPECT_TRUE(!is_clock_manager ||
                   target_timestamp == player_.GetCurrentTime());
       current_timestamp += 30;
       WaitForDecodeDone(is_audio, !is_audio);
     }
     EXPECT_LE(target_timestamp, player_.GetCurrentTime());
   }
 
-  void PlayAudioForTimeInterval(const base::TimeDelta& start_timestamp,
-                                const base::TimeDelta& target_timestamp ) {
-
-    DemuxerData data = CreateReadFromDemuxerAckForAudio(1);
-    int current_timestamp = start_timestamp.InMilliseconds();
-    int stop_timestamp = target_timestamp.InMilliseconds();
-    while (current_timestamp < stop_timestamp) {
-      data.access_units[0].timestamp =
-          base::TimeDelta::FromMilliseconds(current_timestamp);
-      player_.OnDemuxerDataAvailable(data);
-      current_timestamp += 30;
-      WaitForAudioDecodeDone();
-    }
-  }
-
-  void WaitForDelay(const base::TimeDelta& delay) {
-    // Let the message_loop_ process events.
-    // We post delayed task and RunUnitilIdle() until it signals.
-
-    manager_.SetDelayExpired(false);
-    message_loop_.PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&MockMediaPlayerManager::SetDelayExpired,
-                   base::Unretained(&manager_),
-                   true),
-        delay);
-
-    while (!manager_.is_delay_expired())
-      message_loop_.RunUntilIdle();
-  }
-
   DemuxerData CreateReadFromDemuxerAckWithConfigChanged(
       bool is_audio,
       int config_unit_index,
       const DemuxerConfigs& configs) {
     DemuxerData data;
     data.type = is_audio ? DemuxerStream::AUDIO : DemuxerStream::VIDEO;
     data.access_units.resize(config_unit_index + 1);
 
     for (int i = 0; i < config_unit_index; ++i)
       data.access_units[i] = CreateAccessUnitWithData(is_audio, i, false);
@@ skipping 304 matching lines @@
   // surfaces, tests need to create a new surface texture without releasing
   // their previous one. In CreateNextTextureAndSetVideoSurface(), we toggle
   // between two surface textures, only replacing the N-2 texture. Assumption is
   // that no more than N-1 texture is in use by decoder when
   // CreateNextTextureAndSetVideoSurface() is called.
   scoped_refptr<gfx::SurfaceTexture> surface_texture_a_;
   scoped_refptr<gfx::SurfaceTexture> surface_texture_b_;
   bool surface_texture_a_is_next_;
   int next_texture_id_;
 
-  bool verify_not_audible_is_called_;
-
   DISALLOW_COPY_AND_ASSIGN(MediaSourcePlayerTest);
 };
 
 TEST_F(MediaSourcePlayerTest, StartAudioDecoderWithValidConfig) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test audio codec will be created when valid configs and data are passed to
   // the audio decoder job.
   StartAudioDecoderJob();
   EXPECT_EQ(0, demuxer_->num_seek_requests());
@@ skipping 11 matching lines @@
   uint8 invalid_codec_data[] = { 0x00, 0xff, 0xff, 0xff, 0xff };
   configs.audio_extra_data.insert(configs.audio_extra_data.begin(),
                                  invalid_codec_data, invalid_codec_data + 4);
   Start(configs);
 
   // Decoder is not created after data is received.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
   EXPECT_FALSE(GetMediaCodecBridge(true));
 }
 
-// timav
-TEST_F(MediaSourcePlayerTest, AudioDecoderSetsAudibleState) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
-
-  // No data arrived yet
-  EXPECT_FALSE(manager_.is_audible());
-
-  // Initialize decoder
-  StartAudioDecoderJob();
-  player_.SetVolume(1.0);
-
-  // Process frames until prerolling is done.
-  SeekPlayerWithAbort(true, base::TimeDelta::FromMilliseconds(100));
-  EXPECT_TRUE(IsPrerolling(true));
-  PrerollDecoderToTime(
-      true, base::TimeDelta(), base::TimeDelta::FromMilliseconds(100), false);
-  EXPECT_TRUE(IsPrerolling(false));
-
-  // Send more packets
-  PlayAudioForTimeInterval(base::TimeDelta::FromMilliseconds(150),
-                           base::TimeDelta::FromMilliseconds(220));
-
-  // The player should trigger audible status
-  EXPECT_TRUE(manager_.is_audible());
-
-  // The player release should report a non-audible state.
-  ReleasePlayer();
-  EXPECT_FALSE(manager_.is_audible());
-}
-
-TEST_F(MediaSourcePlayerTest, AudioDecoderRemovesAudibleStateWhenPaused) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
-
-  // No data arrived yet
-  EXPECT_FALSE(manager_.is_audible());
-
-  // Initialize decoder
-  StartAudioDecoderJob();
-  player_.SetVolume(1.0);
-
-  // Process frames until prerolling is done.
-  SeekPlayerWithAbort(true, base::TimeDelta::FromMilliseconds(100));
-  EXPECT_TRUE(IsPrerolling(true));
-  PrerollDecoderToTime(
-      true, base::TimeDelta(), base::TimeDelta::FromMilliseconds(100), false);
-  EXPECT_TRUE(IsPrerolling(false));
-
-  // Send more packets
-  PlayAudioForTimeInterval(base::TimeDelta::FromMilliseconds(150),
-                           base::TimeDelta::FromMilliseconds(220));
-
-  // The player should trigger audible status
-  EXPECT_TRUE(manager_.is_audible());
-
-  // Pause the player
-  player_.Pause(true);
-
-  // Send more packets
-  PlayAudioForTimeInterval(base::TimeDelta::FromMilliseconds(240),
-                           base::TimeDelta::FromMilliseconds(280));
-
-  // The player should trigger audible status again
-  EXPECT_FALSE(manager_.is_audible());
-
-  player_.Release();
-}
-
-TEST_F(MediaSourcePlayerTest, AudioDecoderRemovesAudibleStateWhenIdle) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
-
-  // No data arrived yet
-  EXPECT_FALSE(manager_.is_audible());
-
-  // Initialize decoder
-  StartAudioDecoderJob();
-  player_.SetVolume(1.0);
-
-  // Process frames until prerolling is done.
-  SeekPlayerWithAbort(true, base::TimeDelta::FromMilliseconds(100));
-  EXPECT_TRUE(IsPrerolling(true));
-  PrerollDecoderToTime(
-      true, base::TimeDelta(), base::TimeDelta::FromMilliseconds(100), false);
-  EXPECT_TRUE(IsPrerolling(false));
-
-  // Send more packets
-  PlayAudioForTimeInterval(base::TimeDelta::FromMilliseconds(150),
-                           base::TimeDelta::FromMilliseconds(220));
-
-  // The player should trigger audible status
-  EXPECT_TRUE(manager_.is_audible());
-
-  // Simulate the freeze on demuxer: wait for 300 ms
-  WaitForDelay(base::TimeDelta::FromMilliseconds(300));
-
-  // By this time the player should have reported
-  // that there is no audio.
-  EXPECT_FALSE(manager_.is_audible());
-
-  ReleasePlayer();
-}
-
 TEST_F(MediaSourcePlayerTest, StartVideoCodecWithValidSurface) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test video codec will not be created until data is received.
   StartVideoDecoderJob();
 
   // Set both an initial and a later video surface without receiving any
   // demuxed data yet.
   CreateNextTextureAndSetVideoSurface();
   EXPECT_FALSE(GetMediaCodecBridge(false));
@@ skipping 1493 matching lines @@
 
   EXPECT_EQ(demuxer_->num_data_requests(), 0);
   player_.OnDemuxerConfigsAvailable(CreateDemuxerConfigs(true, true));
 
   manager_.set_allow_play(true);
   player_.Start();
   EXPECT_TRUE(player_.IsPlaying());
 }
 
 }  // namespace media