Throttle media decoding after excessive Android media server crashes

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 27 matching lines @@
 
 // TODO(wolenetz/qinmin): Simplify tests with more effective mock usage, and
 // 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),
         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,
@@ skipping 14 matching lines @@
   }
   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 OnWaitingForDecryptionKey(int player_id) override {}
   MediaPlayerAndroid* GetFullscreenPlayer() override { return NULL; }
   MediaPlayerAndroid* GetPlayer(int player_id) override { return NULL; }
+  void OnDecorderResourcesReleased(int player_id) {}
 
   bool RequestPlay(int player_id, base::TimeDelta duration) override {
     return allow_play_;
   }
 
   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;
   }
 
   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_;
   // Whether the manager will allow players that request playing.
   bool allow_play_;
 
   DISALLOW_COPY_AND_ASSIGN(MockMediaPlayerManager);
 };
 
@@ skipping 37 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(MockDemuxerAndroid);
 };
 
 class MediaSourcePlayerTest : public testing::Test {
  public:
   MediaSourcePlayerTest()
       : manager_(&message_loop_),
         demuxer_(new MockDemuxerAndroid(&message_loop_)),
         player_(0, &manager_,
-                base::Bind(&MockMediaPlayerManager::OnMediaResourcesRequested,
+                base::Bind(&MockMediaPlayerManager::OnDecorderResourcesReleased,
                            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
@@ skipping 870 matching lines @@
   WaitForVideoDecodeDone();
 }
 
 TEST_F(MediaSourcePlayerTest, ReleaseVideoDecoderResourcesWhileDecoding) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that if video decoder is released while decoding, the resources will
   // not be immediately released.
   CreateNextTextureAndSetVideoSurface();
   StartVideoDecoderJob();
-  // No resource is requested since there is no data to decode.
-  EXPECT_EQ(0, manager_.num_resources_requested());
   ReleasePlayer();
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo(false));
 
   // Recreate the video decoder.
   CreateNextTextureAndSetVideoSurface();
   player_.Start();
   while (!GetMediaDecoderJob(false)->is_decoding())
     message_loop_.RunUntilIdle();
   EXPECT_EQ(0, demuxer_->num_browser_seek_requests());
-  EXPECT_EQ(1, manager_.num_resources_requested());
   ReleasePlayer();
   // Wait for the media codec bridge to finish decoding and be reset.
   while (GetMediaDecoderJob(false)->is_decoding())
     message_loop_.RunUntilIdle();
 }
 
 TEST_F(MediaSourcePlayerTest, AudioOnlyStartAfterSeekFinish) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test audio decoder job will not start until pending seek event is handled.
@@ skipping 841 matching lines @@
 
   // Test that video config change notification results in creating a new
   // video codec without any browser seek.
   StartConfigChange(false, true, 1, false);
 
   // New video codec should have been created and configured, without any
   // browser seek.
   EXPECT_TRUE(GetMediaCodecBridge(false));
   EXPECT_EQ(3, demuxer_->num_data_requests());
   EXPECT_EQ(0, demuxer_->num_seek_requests());
-
-  // 2 codecs should have been created, one before the config change, and one
-  // after it.
-  EXPECT_EQ(2, manager_.num_resources_requested());
   WaitForVideoDecodeDone();
 }
 
 TEST_F(MediaSourcePlayerTest, VideoDemuxerConfigChangeWithAdaptivePlayback) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that if codec supports adaptive playback, no new codec should be
   // created beyond the one used to decode the prefetch media data prior to
   // the kConfigChanged.
   StartConfigChange(false, true, 1, true);
 
   // No browser seek should be needed.
   EXPECT_TRUE(GetMediaCodecBridge(false));
   EXPECT_EQ(3, demuxer_->num_data_requests());
   EXPECT_EQ(0, demuxer_->num_seek_requests());
-
-  // Only 1 codec should have been created so far.
-  EXPECT_EQ(1, manager_.num_resources_requested());
   WaitForVideoDecodeDone();
 }
 
 TEST_F(MediaSourcePlayerTest, DecoderDrainInterruptedBySeek) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test if a decoder is being drained while receiving a seek request, draining
   // is canceled.
   SendConfigChangeToDecoder(true, false, 0, false);
   EXPECT_TRUE(IsDrainingDecoder(true));
@@ skipping 432 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