Fire canplaythrough as soon as download defers to fix autoplay

webkit/media/buffered_data_source_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 "base/bind.h"
 #include "media/base/media_log.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_data_source_host.h"
 #include "media/base/mock_filters.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURLResponse.h"
 #include "webkit/media/buffered_data_source.h"
 #include "webkit/mocks/mock_webframeclient.h"
 #include "webkit/mocks/mock_weburlloader.h"
 #include "webkit/media/test_response_generator.h"
 
 using ::testing::_;
 using ::testing::Assign;
+using ::testing::AtLeast;
 using ::testing::Invoke;
-using ::testing::StrictMock;
 using ::testing::NiceMock;
 
 using WebKit::WebFrame;
 using WebKit::WebURLLoader;
 using WebKit::WebURLResponse;
 using WebKit::WebView;
 
 using webkit_glue::MockWebFrameClient;
 using webkit_glue::MockWebURLLoader;
 
@@ skipping 45 matching lines @@
 class BufferedDataSourceTest : public testing::Test {
  public:
   BufferedDataSourceTest()
       : response_generator_(GURL("http://localhost/foo.webm"), kFileSize),
         view_(WebView::create(NULL)),
         message_loop_(MessageLoop::current()) {
     view_->initializeMainFrame(&client_);
 
     data_source_ = new MockBufferedDataSource(message_loop_,
                                               view_->mainFrame());
-    data_source_->set_host(&host_);
   }
 
   virtual ~BufferedDataSourceTest() {
     view_->close();
   }
 
   void Initialize(media::PipelineStatus expected) {
+    Initialize(expected, true);
+  }
+
+  void Initialize(media::PipelineStatus expected, bool set_host) {
+    if (set_host)
+      data_source_->set_host(&host_);
+
     ExpectCreateResourceLoader();
     data_source_->Initialize(response_generator_.gurl().spec(),
                              media::NewExpectedStatusCB(expected));
     message_loop_->RunAllPending();
   }
 
   // Helper to initialize tests with a valid 206 response.
   void InitializeWith206Response() {
     Initialize(media::PIPELINE_OK);
 
-    EXPECT_CALL(host_, SetTotalBytes(response_generator_.content_length()));
-    EXPECT_CALL(host_, SetBufferedBytes(0));
+    EXPECT_CALL(host_, SetTotalBytes(response_generator_.content_length()))
+        .Times(AtLeast(1));
+    EXPECT_CALL(host_, SetBufferedBytes(0))
+        .Times(AtLeast(1));
     Respond(response_generator_.Generate206(0));
   }
 
   // Stops any active loaders and shuts down the data source.
   //
   // This typically happens when the page is closed and for our purposes is
   // appropriate to do when tearing down a test.
   void Stop() {
     if (data_source_->loading()) {
       loader()->didFail(url_loader(), response_generator_.GenerateError());
@@ skipping 53 matching lines @@
   int loader_bitrate() { return loader()->bitrate_; }
   int loader_playback_rate() { return loader()->playback_rate_; }
 
 
   scoped_refptr<MockBufferedDataSource> data_source_;
 
   TestResponseGenerator response_generator_;
   MockWebFrameClient client_;
   WebView* view_;
 
-  StrictMock<media::MockDataSourceHost> host_;
+  NiceMock<media::MockDataSourceHost> host_;
   MessageLoop* message_loop_;
 
  private:
   // Used for calling BufferedDataSource::Read().
   uint8 buffer_[kDataSize];
 
   // Used for calling BufferedResourceLoader::didReceiveData().
   char data_[kDataSize];
 
   DISALLOW_COPY_AND_ASSIGN(BufferedDataSourceTest);
@@ skipping 244 matching lines @@
   EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, Read) {
   InitializeWith206Response();
 
   ReadAt(0);
 
   // When the read completes we'll update our network status.
-  EXPECT_CALL(host_, SetBufferedBytes(kDataSize));
-  EXPECT_CALL(host_, SetNetworkActivity(true));
+  EXPECT_CALL(host_, SetBufferedBytes(kDataSize))
+      .Times(AtLeast(1));
+  EXPECT_CALL(host_, SetNetworkActivity(true))
+      .Times(AtLeast(1));
   EXPECT_CALL(*this, ReadCallback(kDataSize));
   FinishRead();
 
   // During teardown we'll also report our final network status.
   EXPECT_CALL(host_, SetBufferedBytes(kDataSize));
   //EXPECT_CALL(host_, SetNetworkActivity(false));
 
   EXPECT_TRUE(data_source_->loading());
   Stop();
 }
 
+// Make sure information regarding loaded data propogates to the host even if it
+// gets initialized before the host is set.
+TEST_F(BufferedDataSourceTest, HostSetAfterResponse) {
+  Initialize(media::PIPELINE_OK, false);
+  Respond(response_generator_.Generate206(0));
+
+  EXPECT_CALL(host_, SetNetworkActivity(_));
+  EXPECT_CALL(host_, SetTotalBytes(_));
+  EXPECT_CALL(host_, SetBufferedBytes(_));
+  data_source_->set_host(&host_);
+
+  Stop();
+}
+
 }  // namespace webkit_media