Merge 22087 - Missing buffered attribute for <video>/<audio>...

media/base/pipeline_impl_unittest.cc

 // Copyright (c) 2006-2009 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/waitable_event.h"
 #include "media/base/pipeline_impl.h"
 #include "media/base/media_format.h"
 #include "media/base/filters.h"
 #include "media/base/factory.h"
 #include "media/base/filter_host.h"
 #include "media/base/mock_filters.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::DoAll;
 using ::testing::Invoke;
 using ::testing::Mock;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::StrictMock;
 
+namespace {
+
+// Total bytes of the data source.
+const int kTotalBytes = 1024;
+
+// Buffered bytes of the data source.
+const int kBufferedBytes = 1024;
+
+}  // namespace
+
 namespace media {
 
 // Used for setting expectations on pipeline callbacks.  Using a StrictMock
 // also lets us test for missing callbacks.
 class CallbackHelper {
  public:
   CallbackHelper() {}
   virtual ~CallbackHelper() {}
 
   MOCK_METHOD0(OnStart, void());
@@ skipping 30 matching lines @@
     EXPECT_CALL(callbacks_, OnStop());
     pipeline_->Stop(NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
                                 &CallbackHelper::OnStop));
     message_loop_.RunAllPending();
   }
 
  protected:
   // Sets up expectations to allow the data source to initialize.
   void InitializeDataSource() {
     EXPECT_CALL(*mocks_->data_source(), Initialize("", NotNull()))
-        .WillOnce(Invoke(&RunFilterCallback));
+        .WillOnce(DoAll(SetTotalBytes(mocks_->data_source(), kTotalBytes),
+                        SetBufferedBytes(mocks_->data_source(), kBufferedBytes),
+                        Invoke(&RunFilterCallback)));
     EXPECT_CALL(*mocks_->data_source(), SetPlaybackRate(0.0f));
     EXPECT_CALL(*mocks_->data_source(), Seek(base::TimeDelta(), NotNull()))
         .WillOnce(Invoke(&RunFilterCallback));
     EXPECT_CALL(*mocks_->data_source(), Stop());
   }
 
   // Sets up expectations to allow the demuxer to initialize.
   typedef std::vector<MockDemuxerStream*> MockDemuxerStreamVector;
   void InitializeDemuxer(MockDemuxerStreamVector* streams,
                          const base::TimeDelta& duration) {
@@ skipping 313 matching lines @@
 
   // The audio renderer should receive a call to SetVolume().
   float expected = 0.5f;
   EXPECT_CALL(*mocks_->audio_renderer(), SetVolume(expected));
 
   // Initialize then set volume!
   InitializePipeline();
   pipeline_->SetVolume(expected);
 }
 
+TEST_F(PipelineImplTest, Properties) { 
+  scoped_refptr<StrictMock<MockDemuxerStream> > stream =
+      new StrictMock<MockDemuxerStream>("video/x-foo");
+  MockDemuxerStreamVector streams;
+  streams.push_back(stream);
+
+  InitializeDataSource();
+  base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
+  InitializeDemuxer(&streams, kDuration);
+  InitializeVideoDecoder(stream);
+  InitializeVideoRenderer();
+
+  InitializePipeline();
+  EXPECT_TRUE(pipeline_->IsInitialized());
+  EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
+  EXPECT_EQ(kDuration.ToInternalValue(),
+            pipeline_->GetDuration().ToInternalValue());
+  EXPECT_EQ(kTotalBytes, pipeline_->GetTotalBytes());
+  EXPECT_EQ(kBufferedBytes, pipeline_->GetBufferedBytes());
+  EXPECT_EQ(kDuration.ToInternalValue(),
+            pipeline_->GetBufferedTime().ToInternalValue());
+}
+
 }  // namespace media