Determine the audible state in MediaSourcePlayer

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 28 matching lines @@
 // fix flaky pointer-based MDJ inequality testing. See http://crbug.com/327839.
 
 // 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) {}
+        timestamp_updated_(false),
+        is_audible_(false),
+        is_audible_idle_timeout_expired_(false) {}
   ~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;
   }
   void OnMediaMetadataChanged(int player_id,
                               base::TimeDelta duration,
                               int width,
                               int height,
                               bool success) override {
     num_metadata_changes_++;
   }
   void OnPlaybackComplete(int player_id) override {
     playback_completed_ = true;
     if (message_loop_->is_running())
       message_loop_->Quit();
   }
   void OnMediaInterrupted(int player_id) override {}
   void OnBufferingUpdate(int player_id, int percentage) override {}
   void OnSeekComplete(int player_id,
                       const base::TimeDelta& current_time) override {}
   void OnError(int player_id, int error) override {}
   void OnVideoSizeChanged(int player_id, int width, int height) override {}
-  void OnAudibleStateChanged(int player_id, bool is_audible_now) override {}
   void OnWaitingForDecryptionKey(int player_id) override {}
   MediaPlayerAndroid* GetFullscreenPlayer() override { return NULL; }
   MediaPlayerAndroid* GetPlayer(int player_id) override { return NULL; }
   void RequestFullScreen(int player_id) override {}
 #if defined(VIDEO_HOLE)
   bool ShouldUseVideoOverlayForEmbeddedEncryptedVideo() override {
     return false;
   }
 #endif  // defined(VIDEO_HOLE)
 
+  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_audible_idle_timeout_expired() const {
+    return is_audible_idle_timeout_expired_;
+  }
+
+  void SetAudibleIdleTimeoutExpired(bool value) {
+    is_audible_idle_timeout_expired_ = 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 before we check
+  // the audible state
+  bool is_audible_idle_timeout_expired_;
 
   DISALLOW_COPY_AND_ASSIGN(MockMediaPlayerManager);
 };
 
 class MockDemuxerAndroid : public DemuxerAndroid {
  public:
   explicit MockDemuxerAndroid(base::MessageLoop* message_loop)
       : message_loop_(message_loop),
         num_data_requests_(0),
         num_seek_requests_(0),
@@ skipping 37 matching lines @@
   MediaSourcePlayerTest()
       : manager_(&message_loop_),
         demuxer_(new MockDemuxerAndroid(&message_loop_)),
         player_(0, &manager_,
                 base::Bind(&MockMediaPlayerManager::OnMediaResourcesRequested,
                            base::Unretained(&manager_)),
                 scoped_ptr<DemuxerAndroid>(demuxer_),
                 GURL()),
         decoder_callback_hook_executed_(false),
         surface_texture_a_is_next_(true) {}
+
   ~MediaSourcePlayerTest() override {}
 
  protected:
   // Get the decoder job from the MediaSourcePlayer. The return value must not
   // be NULL.
   MediaDecoderJob* GetMediaDecoderJob(bool is_audio) {
     if (is_audio) {
       return reinterpret_cast<MediaDecoderJob*>(
           player_.audio_decoder_job_.get());
     }
@@ skipping 646 matching lines @@
   }
 
   bool IsRequestingDemuxerData(bool is_audio) {
     return GetMediaDecoderJob(is_audio)->is_requesting_demuxer_data_;
   }
 
   bool IsDrainingDecoder(bool is_audio) {
     return GetMediaDecoderJob(is_audio)->drain_decoder_;
   }
 
+ protected:
   base::MessageLoop message_loop_;
   MockMediaPlayerManager manager_;
   MockDemuxerAndroid* demuxer_;  // Owned by |player_|.
   MediaSourcePlayer player_;
 
   // Track whether a possibly async decoder callback test hook has run.
   bool decoder_callback_hook_executed_;
 
   // We need to keep the surface texture while the decoder is actively decoding.
   // Otherwise, it may trigger unexpected crashes on some devices. To switch
   // 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());
+
+  StartAudioDecoderJob();
+  player_.SetVolume(1.0);
+
+  // The first decoded frame should report the audio state
+  // to the manager
+  DecodeAudioDataUntilOutputBecomesAvailable();
+  EXPECT_TRUE(manager_.is_audible());
+
+  // The player release should report a non-audible state.
+  ReleasePlayer();
+  EXPECT_FALSE(manager_.is_audible());
+}
+
+TEST_F(MediaSourcePlayerTest, AudioDecoderRemovesAudibleStateWhenIdle) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // No data arrived yet
+  EXPECT_FALSE(manager_.is_audible());
+
+  StartAudioDecoderJob();
+  player_.SetVolume(1.0);
+
+  // Shorten the idle period for the test to 300 ms
+  const int kDelay = 300; // milliseconds
+  player_.SetAudibleStateIdlePeriod(base::TimeDelta::FromMilliseconds(kDelay));
+
+  // The first decoded frame should report the audio state
+  // to the manager
+  DecodeAudioDataUntilOutputBecomesAvailable();
+  EXPECT_TRUE(manager_.is_audible());
+
+  // Wait till more than 300 ms pass (we wait 400 ms in this case)
+  manager_.SetAudibleIdleTimeoutExpired(false);
+  message_loop_.PostDelayedTask(

[Tima Vaisburd, 2015/03/18 01:35:02]

I wanted to guarantee that this delayed task arrives after the delayed task in
the MediaSourcePlayer that actually changes the status. That's why I used
PostDelayedTask() instead of Sleep(). Please let me know if there is a better
way.

+      FROM_HERE,
+      base::Bind(&MockMediaPlayerManager::SetAudibleIdleTimeoutExpired,
+                 base::Unretained(&manager_),
+                 true),
+      base::TimeDelta::FromMilliseconds(kDelay + 100));
+
+  while (!manager_.is_audible_idle_timeout_expired())
+    message_loop_.RunUntilIdle();
+
+  // The player should have reported that there is no audio
+  // by this time.
+  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 1449 matching lines @@
   // Wait for the metadata change.
   while(manager_.num_metadata_changes() == 1) {
     player_.OnDemuxerDataAvailable(data);
     WaitForVideoDecodeDone();
   }
   EXPECT_EQ(2, manager_.num_metadata_changes());
   WaitForVideoDecodeDone();
 }
 
 }  // namespace media