Fire CanPlayThrough immediately for local and streaming media files

webkit/media/buffered_data_source_unittest.cc

 // Copyright (c) 2011 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 <algorithm>
 
 #include "base/bind.h"
 #include "base/test/test_timeouts.h"
 #include "media/base/media_log.h"
 #include "media/base/mock_callback.h"
@@ skipping 32 matching lines @@
 using webkit_glue::MockWebFrameClient;
 using webkit_glue::MockWebURLLoader;
 
 namespace webkit_media {
 
 static const char* kHttpUrl = "http://test";
 static const char* kFileUrl = "file://test";
 static const int kDataSize = 1024;
 static const int kMaxCacheMissesBeforeFailTest = 20;
 
-enum NetworkState {
+enum SourceType {
   NONE,
-  LOADED,
-  LOADING
+  LOCAL,
+  REMOTE
 };
 
 // A mock BufferedDataSource to inject mock BufferedResourceLoader through
 // CreateResourceLoader() method.
 class MockBufferedDataSource : public BufferedDataSource {
  public:
   MockBufferedDataSource(MessageLoop* message_loop, WebFrame* frame)
       : BufferedDataSource(message_loop, frame, new media::MediaLog()) {
   }
 
@@ skipping 59 matching lines @@
 
     EXPECT_CALL(*loader_, Start(NotNull(), _, NotNull()))
         .WillOnce(
             DoAll(Assign(&error_, start_error),
                   Invoke(this,
                          &BufferedDataSourceTest::InvokeStartCallback)));
   }
 
   void InitializeDataSource(const char* url, int error,
                             bool partial_response, int64 instance_size,
-                            NetworkState networkState) {
+                            SourceType source_type) {
     // Saves the url first.
     gurl_ = GURL(url);
 
     data_source_ = new MockBufferedDataSource(MessageLoop::current(),
                                               view_->mainFrame());
     data_source_->set_host(&host_);
 
     scoped_refptr<NiceMock<MockBufferedResourceLoader> > first_loader(
         new NiceMock<MockBufferedResourceLoader>());
 
     // Creates the mock loader to be injected.
     loader_ = first_loader;
 
     bool initialized_ok = (error == net::OK);
-    bool loaded = networkState == LOADED;
+    bool local_source = source_type == LOCAL;
     {
       InSequence s;
       ExpectCreateAndStartResourceLoader(error);
 
       // In the case of an invalid partial response we expect a second loader
       // to be created.
       if (partial_response && (error == net::ERR_INVALID_RESPONSE)) {
         // Verify that the initial loader is stopped.
         EXPECT_CALL(*loader_, url())
             .WillRepeatedly(ReturnRef(gurl_));
@@ skipping 20 matching lines @@
         .WillByDefault(Return(instance_size));
 
     // range_supported() return true if we expect to get a partial response.
     ON_CALL(*loader_, range_supported())
         .WillByDefault(Return(partial_response));
 
     ON_CALL(*loader_, url())
         .WillByDefault(ReturnRef(gurl_));
     media::PipelineStatus expected_init_status = media::PIPELINE_OK;
     if (initialized_ok) {
-      // Expected loaded or not.
-      EXPECT_CALL(host_, SetLoaded(loaded));
+      // Media is a local file or not.
+      EXPECT_CALL(host_, SetLocalSourceFromFilter(local_source));
 
       if (instance_size != -1)
         EXPECT_CALL(host_, SetTotalBytes(instance_size));
 
-      if (loaded)
+      if (local_source)
         EXPECT_CALL(host_, SetBufferedBytes(instance_size));
       else
         EXPECT_CALL(host_, SetBufferedBytes(0));
 
       if (!partial_response || instance_size == -1)
         EXPECT_CALL(host_, SetStreaming(true));
 
     } else {
       expected_init_status = media::PIPELINE_ERROR_NETWORK;
       EXPECT_CALL(*loader_, Stop());
     }
 
     // Actual initialization of the data source.
     data_source_->Initialize(url,
         media::NewExpectedStatusCB(expected_init_status));
     message_loop_->RunAllPending();
 
     if (initialized_ok) {
       // Verify the size of the data source.
       int64 size;
-      if (instance_size != -1 && (loaded || partial_response)) {
+      if (instance_size != -1 && (local_source || partial_response)) {
         EXPECT_TRUE(data_source_->GetSize(&size));
         EXPECT_EQ(instance_size, size);
       } else {
         EXPECT_TRUE(data_source_->IsStreaming());
       }
     }
   }
 
   void StopDataSource() {
     if (loader_) {
@@ skipping 215 matching lines @@
   uint8 buffer_[1024];
   uint8 data_[1024];
 
   int cache_miss_count_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BufferedDataSourceTest);
 };
 
 TEST_F(BufferedDataSourceTest, InitializationSuccess) {
-  InitializeDataSource(kHttpUrl, net::OK, true, 1024, LOADING);
+  InitializeDataSource(kHttpUrl, net::OK, true, 1024, REMOTE);
   StopDataSource();
 }
 
 TEST_F(BufferedDataSourceTest, InitiailizationFailed) {
   InitializeDataSource(kHttpUrl, net::ERR_FILE_NOT_FOUND, false, 0, NONE);
   StopDataSource();
 }
 
 TEST_F(BufferedDataSourceTest, MissingContentLength) {
-  InitializeDataSource(kHttpUrl, net::OK, true, -1, LOADING);
+  InitializeDataSource(kHttpUrl, net::OK, true, -1, REMOTE);
   StopDataSource();
 }
 
 TEST_F(BufferedDataSourceTest, RangeRequestNotSupported) {
-  InitializeDataSource(kHttpUrl, net::OK, false, 1024, LOADING);
+  InitializeDataSource(kHttpUrl, net::OK, false, 1024, REMOTE);
   StopDataSource();
 }
 
 // Test the case where we get a 206 response, but no Content-Range header.
 TEST_F(BufferedDataSourceTest, MissingContentRange) {
   InitializeDataSource(kHttpUrl, net::ERR_INVALID_RESPONSE, true, 1024,
-                       LOADING);
+                       REMOTE);
   StopDataSource();
 }
 
 TEST_F(BufferedDataSourceTest,
        MissingContentLengthAndRangeRequestNotSupported) {
-  InitializeDataSource(kHttpUrl, net::OK, false, -1, LOADING);
+  InitializeDataSource(kHttpUrl, net::OK, false, -1, REMOTE);
   StopDataSource();
 }
 
 TEST_F(BufferedDataSourceTest, ReadCacheHit) {
-  InitializeDataSource(kHttpUrl, net::OK, true, 25, LOADING);
+  InitializeDataSource(kHttpUrl, net::OK, true, 25, REMOTE);
 
   // Performs read with cache hit.
   ReadDataSourceHit(10, 10, 10);
 
   // Performs read with cache hit but partially filled.
   ReadDataSourceHit(20, 10, 5);
 
   StopDataSource();
 }
 
 TEST_F(BufferedDataSourceTest, ReadCacheMiss) {
-  InitializeDataSource(kHttpUrl, net::OK, true, 1024, LOADING);
+  InitializeDataSource(kHttpUrl, net::OK, true, 1024, REMOTE);
   ReadDataSourceMiss(1000, 10, net::OK);
   ReadDataSourceMiss(20, 10, net::OK);
   StopDataSource();
 }
 
 // Test the case where the initial response from the server indicates that
 // Range requests are supported, but a later request prove otherwise.
 TEST_F(BufferedDataSourceTest, ServerLiesAboutRangeSupport) {
-  InitializeDataSource(kHttpUrl, net::OK, true, 1024, LOADING);
+  InitializeDataSource(kHttpUrl, net::OK, true, 1024, REMOTE);
   ReadDataSourceHit(10, 10, 10);
   ReadDataSourceMiss(1000, 10, net::ERR_INVALID_RESPONSE);
   StopDataSource();
 }
 
 TEST_F(BufferedDataSourceTest, ReadHang) {
-  InitializeDataSource(kHttpUrl, net::OK, true, 25, LOADING);
+  InitializeDataSource(kHttpUrl, net::OK, true, 25, REMOTE);
   ReadDataSourceHang(10, 10);
   StopDataSource();
 }
 
 TEST_F(BufferedDataSourceTest, ReadFailed) {
-  InitializeDataSource(kHttpUrl, net::OK, true, 1024, LOADING);
+  InitializeDataSource(kHttpUrl, net::OK, true, 1024, REMOTE);
   ReadDataSourceHit(10, 10, 10);
   ReadDataSourceFailed(10, 10, net::ERR_CONNECTION_RESET);
   StopDataSource();
 }
 
 // Helper that sets |*value| to true.  Useful for binding into a Closure.
 static void SetTrue(bool* value) {
   *value = true;
 }
 
 // This test makes sure that Stop() does not require a task to run on
 // |message_loop_| before it calls its callback. This prevents accidental
 // introduction of a pipeline teardown deadlock. The pipeline owner blocks
 // the render message loop while waiting for Stop() to complete. Since this
 // object runs on the render message loop, Stop() will not complete if it
 // requires a task to run on the the message loop that is being blocked.
 TEST_F(BufferedDataSourceTest, StopDoesNotUseMessageLoopForCallback) {
-  InitializeDataSource(kFileUrl, net::OK, true, 1024, LOADED);
+  InitializeDataSource(kFileUrl, net::OK, true, 1024, LOCAL);
 
   // Stop() the data source, using a callback that lets us verify that it was
   // called before Stop() returns. This is to make sure that the callback does
   // not require |message_loop_| to execute tasks before being called.
   bool stop_done_called = false;
   data_source_->Stop(base::Bind(&SetTrue, &stop_done_called));
 
   // Verify that the callback was called inside the Stop() call.
   EXPECT_TRUE(stop_done_called);
 
   message_loop_->RunAllPending();
 }
 
 TEST_F(BufferedDataSourceTest, AbortDuringPendingRead) {
-  InitializeDataSource(kFileUrl, net::OK, true, 1024, LOADED);
+  InitializeDataSource(kFileUrl, net::OK, true, 1024, LOCAL);
 
   // Setup a way to verify that Read() is not called on the loader.
   // We are doing this to make sure that the ReadTask() is still on
   // the message loop queue when Abort() is called.
   bool read_called = false;
   ON_CALL(*loader_, Read(_, _, _ , _))
       .WillByDefault(DoAll(Assign(&read_called, true),
                            DeleteArg<3>()));
 
   // Initiate a Read() on the data source, but don't allow the
@@ skipping 21 matching lines @@
   // Allow cleanup task to run.
   message_loop_->RunAllPending();
 
   // Verify that Read() was not called on the loader.
   EXPECT_FALSE(read_called);
 }
 
 // Test that we only allow a limited number of cache misses for a
 // single Read() request.
 TEST_F(BufferedDataSourceTest, BoundedCacheMisses) {
-  InitializeDataSource(kHttpUrl, net::OK, true, 1024, LOADING);
+  InitializeDataSource(kHttpUrl, net::OK, true, 1024, REMOTE);
 
   ReadDataSourceAlwaysCacheMiss(0, 10);
 
   StopDataSource();
 }
 
 // TODO(scherkus): de-dupe from buffered_resource_loader_unittest.cc
 ACTION_P(RequestCanceled, loader) {
   WebURLError error;
   error.reason = net::ERR_ABORTED;
@@ skipping 68 matching lines @@
     response.setHTTPHeaderField(WebString::fromUTF8("Accept-Ranges"),
                                 WebString::fromUTF8("bytes"));
     response.setHTTPHeaderField(WebString::fromUTF8("Content-Range"),
                                 WebString::fromUTF8("bytes 0-4999999/5000000"));
     response.setHTTPHeaderField(WebString::fromUTF8("Content-Length"),
                                 WebString::fromUTF8("5000000"));
     response.setExpectedContentLength(5000000);
     response.setHTTPStatusCode(206);
 
     // We should receive corresponding information about the media resource.
-    EXPECT_CALL(host_, SetLoaded(false));
+    EXPECT_CALL(host_, SetLocalSourceFromFilter(false));
     EXPECT_CALL(host_, SetTotalBytes(5000000));
     EXPECT_CALL(host_, SetBufferedBytes(0));
 
     data_source_->loader()->didReceiveResponse(data_source_->url_loader(),
                                                response);
 
     message_loop_->RunAllPending();
   }
 
   void StopDataSource() {
@@ skipping 86 matching lines @@
   message_loop_->RunAllPending();
 
   // Verify loader changed but still has same bitrate.
   EXPECT_NE(old_loader, data_source_->loader().get());
   EXPECT_EQ(2.0f, loader_playback_rate());
 
   StopDataSource();
 }
 
 }  // namespace webkit_media