Update media duration if data is appended after the previous duration

media/base/pipeline_unittest.cc

 // Copyright (c) 2012 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 <vector>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/threading/simple_thread.h"
@@ skipping 44 matching lines @@
 class CallbackHelper {
  public:
   CallbackHelper() {}
   virtual ~CallbackHelper() {}
 
   MOCK_METHOD1(OnStart, void(PipelineStatus));
   MOCK_METHOD1(OnSeek, void(PipelineStatus));
   MOCK_METHOD0(OnStop, void());
   MOCK_METHOD1(OnEnded, void(PipelineStatus));
   MOCK_METHOD1(OnError, void(PipelineStatus));
+  MOCK_METHOD0(OnNewDuration, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CallbackHelper);
 };
 
 // TODO(scherkus): even though some filters are initialized on separate
 // threads these test aren't flaky... why?  It's because filters' Initialize()
 // is executed on |message_loop_| and the mock filters instantly call
 // InitializationComplete(), which keeps the pipeline humming along.  If
 // either filters don't call InitializationComplete() immediately or filter
@@ skipping 139 matching lines @@
     EXPECT_CALL(*mocks_->audio_renderer(), Preroll(base::TimeDelta(), _))
         .WillOnce(RunPipelineStatusCB1());
     EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
         .WillOnce(RunClosure());
   }
 
   // Sets up expectations on the callback and initializes the pipeline.  Called
   // after tests have set expectations any filters they wish to use.
   void InitializePipeline(PipelineStatus start_status) {
     EXPECT_CALL(callbacks_, OnStart(start_status));
+    if (start_status == PIPELINE_OK)
+      EXPECT_CALL(callbacks_, OnNewDuration());
 
     pipeline_->Start(
         mocks_->Create().Pass(),
         base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
-        base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)));
+        base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)),
+        base::Bind(&CallbackHelper::OnNewDuration,
+                   base::Unretained(&callbacks_)));
     message_loop_.RunAllPending();
   }
 
   void CreateAudioStream() {
     audio_stream_ = CreateStream(DemuxerStream::AUDIO);
   }
 
   void CreateVideoStream() {
     video_stream_ = CreateStream(DemuxerStream::VIDEO);
   }
@@ skipping 104 matching lines @@
   EXPECT_CALL(*mocks_->demuxer(), Stop(_))
       .WillOnce(RunClosure());
 
   // This test hangs during initialization by never calling
   // InitializationComplete().  StrictMock<> will ensure that the callback is
   // never executed.
   pipeline_->Start(
         mocks_->Create().Pass(),
         base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
-        base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)));
+        base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)),
+        base::Bind(&CallbackHelper::OnNewDuration,
+                   base::Unretained(&callbacks_)));
   message_loop_.RunAllPending();
 
   EXPECT_FALSE(pipeline_->IsInitialized());
 
   // Because our callback will get executed when the test tears down, we'll
   // verify that nothing has been called, then set our expectation for the call
   // made during tear down.
   Mock::VerifyAndClear(&callbacks_);
   EXPECT_CALL(callbacks_, OnStart(PIPELINE_OK));
 }
 
 TEST_F(PipelineTest, RequiredFilterMissing) {
   // Create a filter collection with missing filter.
   scoped_ptr<FilterCollection> collection(mocks_->Create());
   collection->SetDemuxer(NULL);
 
   EXPECT_CALL(callbacks_, OnStart(PIPELINE_ERROR_REQUIRED_FILTER_MISSING));
   pipeline_->Start(
       collection.Pass(),
       base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
       base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
-      base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)));
+      base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)),
+      base::Bind(&CallbackHelper::OnNewDuration,
+                 base::Unretained(&callbacks_)));
   message_loop_.RunAllPending();
   EXPECT_FALSE(pipeline_->IsInitialized());
 }
 
 TEST_F(PipelineTest, URLNotFound) {
   EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
       .WillOnce(RunPipelineStatusCB1WithStatus(PIPELINE_ERROR_URL_NOT_FOUND));
   EXPECT_CALL(*mocks_->demuxer(), Stop(_))
       .WillOnce(RunClosure());
 
@@ skipping 569 matching lines @@
   TestPipelineStatusNotification(base::TimeDelta::FromMilliseconds(0));
 }
 
 // Test that different-thread, some-delay callback (the expected common case)
 // works correctly.
 TEST(PipelineStatusNotificationTest, DelayedCallback) {
   TestPipelineStatusNotification(base::TimeDelta::FromMilliseconds(20));
 }
 
 }  // namespace media