Send metadata change to renderer after decoder is drained

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) {}
   virtual ~MockMediaPlayerManager() {}
 
   // MediaPlayerManager implementation.
   virtual MediaResourceGetter* GetMediaResourceGetter() override {
     return NULL;
   }
   virtual MediaUrlInterceptor* GetMediaUrlInterceptor() override {
     return NULL;
   }
   virtual void OnTimeUpdate(int player_id,
                             base::TimeDelta current_time,
                             base::TimeTicks current_time_ticks) override {
     timestamp_updated_ = true;
   }
   virtual void OnMediaMetadataChanged(
       int player_id, base::TimeDelta duration, int width, int height,
-      bool success) override {}
+      bool success) override {
+    num_metadata_changes_++;
+  }
   virtual void OnPlaybackComplete(int player_id) override {
     playback_completed_ = true;
     if (message_loop_->is_running())
       message_loop_->Quit();
   }
   virtual void OnMediaInterrupted(int player_id) override {}
   virtual void OnBufferingUpdate(int player_id, int percentage) override {}
   virtual void OnSeekComplete(int player_id,
                               const base::TimeDelta& current_time) override {}
   virtual void OnError(int player_id, int error) override {}
   virtual void OnVideoSizeChanged(int player_id, int width,
                                   int height) override {}
   virtual MediaPlayerAndroid* GetFullscreenPlayer() override { return NULL; }
   virtual MediaPlayerAndroid* GetPlayer(int player_id) override { return NULL; }
   virtual void RequestFullScreen(int player_id) override {}
 #if defined(VIDEO_HOLE)
   virtual bool ShouldUseVideoOverlayForEmbeddedEncryptedVideo() override {
     return false;
   }
 #endif  // defined(VIDEO_HOLE)
 
   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;
   }
 
  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_;
 
   DISALLOW_COPY_AND_ASSIGN(MockMediaPlayerManager);
 };
 
 class MockDemuxerAndroid : public DemuxerAndroid {
  public:
   explicit MockDemuxerAndroid(base::MessageLoop* message_loop)
       : message_loop_(message_loop),
@@ skipping 143 matching lines @@
     configs.audio_extra_data = std::vector<uint8>(
         aac_extra_data,
         aac_extra_data + 2);
     return configs;
   }
 
   DemuxerConfigs CreateVideoDemuxerConfigs(bool use_larger_size) {
     DemuxerConfigs configs;
     configs.video_codec = kCodecVP8;
     configs.video_size =
-        use_larger_size ? gfx::Size(640, 480) : gfx::Size(320, 240);
+        use_larger_size ? gfx::Size(640, 240) : gfx::Size(320, 240);
     configs.is_video_encrypted = false;
     configs.duration = kDefaultDuration;
     return configs;
   }
 
   DemuxerConfigs CreateAudioVideoDemuxerConfigs() {
     DemuxerConfigs configs = CreateAudioDemuxerConfigs(kCodecVorbis, false);
     configs.video_codec = kCodecVP8;
     configs.video_size = gfx::Size(320, 240);
     configs.is_video_encrypted = false;
@@ skipping 1982 matching lines @@
   DecodeAudioDataUntilOutputBecomesAvailable();
 
   DemuxerConfigs configs = CreateAudioDemuxerConfigs(kCodecVorbis, true);
   DemuxerData data = CreateReadFromDemuxerAckWithConfigChanged(
       true, 0, configs);
   player_.OnDemuxerDataAvailable(data);
   WaitForAudioDecodeDone();
   DecodeAudioDataUntilOutputBecomesAvailable();
 }
 
+TEST_F(MediaSourcePlayerTest, VideoMetadataChangeAfterConfigChange) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test that after a config change, metadata change will be happen
+  // after decoder is drained.
+  StartConfigChange(false, true, 2, false);
+  EXPECT_EQ(1, manager_.num_metadata_changes());
+  EXPECT_FALSE(IsDrainingDecoder(false));
+
+  // Create video data with new resolutions.
+  DemuxerData data = CreateReadFromDemuxerAckForVideo();
+  AccessUnit unit;
+  unit.status = DemuxerStream::kOk;
+  scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile("vp8-I-frame-640x240");
+  unit.data = std::vector<uint8>(
+      buffer->data(), buffer->data() + buffer->data_size());
+  data.access_units[0] = unit;
+
+  // Wait for the metadata change.
+  while(manager_.num_metadata_changes() == 1) {
+    player_.OnDemuxerDataAvailable(data);
+    WaitForVideoDecodeDone();
+  }
+  EXPECT_EQ(2, manager_.num_metadata_changes());
+}
+
 }  // namespace media