Remove OnMediaResourcesReleased callback passed to MediaPlayerAndroid

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_resources_released_(0),
         timestamp_updated_(false) {}
   virtual ~MockMediaPlayerManager() {}
 
   // MediaPlayerManager implementation.
   virtual MediaResourceGetter* GetMediaResourceGetter() OVERRIDE {
     return NULL;
   }
   virtual MediaUrlInterceptor* GetMediaUrlInterceptor() OVERRIDE {
     return NULL;
   }
@@ skipping 26 matching lines @@
 #endif  // defined(VIDEO_HOLE)
 
   bool playback_completed() const {
     return playback_completed_;
   }
 
   int num_resources_requested() const {
     return num_resources_requested_;
   }
 
-  int num_resources_released() const {
-    return num_resources_released_;
-  }
-
   void OnMediaResourcesRequested(int player_id) {
     num_resources_requested_++;
   }
 
-  void OnMediaResourcesReleased(int player_id) {
-    num_resources_released_++;
-  }
-
   bool timestamp_updated() const {
     return timestamp_updated_;
   }
 
   void ResetTimestampUpdated() {
     timestamp_updated_ = false;
   }
 
  private:
   base::MessageLoop* message_loop_;
   bool playback_completed_;
   // The number of resource requests this object has seen.
   int num_resources_requested_;
-  // The number of released resources.
-  int num_resources_released_;
   // Playback timestamp was updated.
   bool timestamp_updated_;
 
   DISALLOW_COPY_AND_ASSIGN(MockMediaPlayerManager);
 };
 
 class MockDemuxerAndroid : public DemuxerAndroid {
  public:
   explicit MockDemuxerAndroid(base::MessageLoop* message_loop)
       : message_loop_(message_loop),
@@ skipping 35 matching lines @@
 };
 
 class MediaSourcePlayerTest : public testing::Test {
  public:
   MediaSourcePlayerTest()
       : manager_(&message_loop_),
         demuxer_(new MockDemuxerAndroid(&message_loop_)),
         player_(0, &manager_,
                 base::Bind(&MockMediaPlayerManager::OnMediaResourcesRequested,
                            base::Unretained(&manager_)),
-                base::Bind(&MockMediaPlayerManager::OnMediaResourcesReleased,
-                           base::Unretained(&manager_)),
                 scoped_ptr<DemuxerAndroid>(demuxer_),
                 GURL()),
         decoder_callback_hook_executed_(false),
         surface_texture_a_is_next_(true) {}
   virtual ~MediaSourcePlayerTest() {}
 
  protected:
   // Get the decoder job from the MediaSourcePlayer. The return value must not
   // be NULL.
   MediaDecoderJob* GetMediaDecoderJob(bool is_audio) {
@@ skipping 842 matching lines @@
 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();
-  EXPECT_EQ(0, manager_.num_resources_released());
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
 
   // 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();
-  // The resource is still held by the video decoder until it finishes decoding.
-  EXPECT_EQ(0, manager_.num_resources_released());
   // Wait for the media codec bridge to finish decoding and be reset.
-  while (manager_.num_resources_released() != 1)
+  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.
   DemuxerConfigs configs = CreateAudioDemuxerConfigs(kCodecVorbis, false);
   player_.OnDemuxerConfigsAvailable(configs);
 
@@ skipping 730 matching lines @@
 
   // 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());
-  EXPECT_EQ(1, manager_.num_resources_released());
 }
 
 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);
 
@@ skipping 382 matching lines @@
 
   DemuxerConfigs configs = CreateAudioDemuxerConfigs(kCodecVorbis, true);
   DemuxerData data = CreateReadFromDemuxerAckWithConfigChanged(
       true, 0, configs);
   player_.OnDemuxerDataAvailable(data);
   WaitForAudioDecodeDone();
   DecodeAudioDataUntilOutputBecomesAvailable();
 }
 
 }  // namespace media