Numerous fixes to audio/video buffered resource loading.

webkit/glue/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"
 #include "media/base/mock_filter_host.h"
 #include "media/base/mock_filters.h"
 #include "net/base/net_errors.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebURLResponse.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "webkit/glue/media/buffered_data_source.h"
 #include "webkit/mocks/mock_webframeclient.h"
+#include "webkit/mocks/mock_weburlloader.h"
 
 using ::testing::_;
 using ::testing::Assign;
 using ::testing::AtLeast;
 using ::testing::DeleteArg;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::Invoke;
 using ::testing::InvokeWithoutArgs;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::ReturnRef;
 using ::testing::SetArgumentPointee;
 using ::testing::StrictMock;
 using ::testing::NiceMock;
 using ::testing::WithArgs;
 
 using WebKit::WebFrame;
+using WebKit::WebString;
+using WebKit::WebURLResponse;
 using WebKit::WebView;
 
 namespace webkit_glue {
 
 static const char* kHttpUrl = "http://test";
 static const char* kFileUrl = "file://test";
 static const int kDataSize = 1024;
 static const int kMaxCacheMissesBeforeFailTest = 20;
 
 enum NetworkState {
@@ skipping 19 matching lines @@
                BufferedResourceLoader*(int64 first_position,
                                        int64 last_position));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockBufferedDataSource);
 };
 
 class MockBufferedResourceLoader : public BufferedResourceLoader {
  public:
   MockBufferedResourceLoader()
-      : BufferedResourceLoader(GURL(), 0, 0, new media::MediaLog()) {
+      : BufferedResourceLoader(GURL(), 0, 0, kThresholdDefer,
+                               0, 0, new media::MediaLog()) {
   }
 
   MOCK_METHOD3(Start, void(net::OldCompletionCallback* read_callback,
                            const base::Closure& network_callback,
                            WebFrame* frame));
   MOCK_METHOD0(Stop, void());
   MOCK_METHOD4(Read, void(int64 position, int read_size, uint8* buffer,
                           net::OldCompletionCallback* callback));
   MOCK_METHOD0(content_length, int64());
   MOCK_METHOD0(instance_size, int64());
@@ skipping 498 matching lines @@
 // 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);
 
   ReadDataSourceAlwaysCacheMiss(0, 10);
 
   StopDataSource();
 }
 
+// A more realistic BufferedDataSource that uses BufferedResourceLoader instead
+// of a mocked version but injects a MockWebURLLoader.
+//
+// TODO(scherkus): re-write these tests to use this class then drop the "2"
+// suffix.
+class MockBufferedDataSource2 : public BufferedDataSource {
+ public:
+  MockBufferedDataSource2(MessageLoop* message_loop, WebFrame* frame)
+      : BufferedDataSource(message_loop, frame, new media::MediaLog()),
+        url_loader_(NULL) {
+  }
+
+  virtual base::TimeDelta GetTimeoutMilliseconds() {
+    return base::TimeDelta::FromMilliseconds(
+                            TestTimeouts::tiny_timeout_ms());
+  }
+
+  virtual BufferedResourceLoader* CreateResourceLoader(int64 first_position,
+                                                       int64 last_position) {
+    loader_ = BufferedDataSource::CreateResourceLoader(first_position,
+                                                       last_position);
+    url_loader_ = new NiceMock<MockWebURLLoader>();
+    loader_->SetURLLoaderForTest(url_loader_);
+    return loader_;
+  }
+
+  scoped_refptr<BufferedResourceLoader> loader() { return loader_; }
+  NiceMock<MockWebURLLoader>* url_loader() { return url_loader_; }
+
+ private:
+  scoped_refptr<BufferedResourceLoader> loader_;
+  NiceMock<MockWebURLLoader>* url_loader_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockBufferedDataSource2);
+};
+
+class BufferedDataSourceTest2 : public testing::Test {
+ public:
+  BufferedDataSourceTest2()
+      : view_(WebView::create(NULL)),
+        message_loop_(MessageLoop::current()) {
+    view_->initializeMainFrame(&client_);
+  }
+
+  virtual ~BufferedDataSourceTest2() {
+    view_->close();
+  }
+
+  void InitializeDataSource(const char* url) {
+    gurl_ = GURL(url);
+
+    data_source_ = new MockBufferedDataSource2(message_loop_,
+                                               view_->mainFrame());
+    data_source_->set_host(&host_);
+    data_source_->Initialize(url,
+                             media::NewExpectedStatusCB(media::PIPELINE_OK));
+    message_loop_->RunAllPending();
+
+    // Simulate 206 response for a 5,000,000 byte length file.
+    WebURLResponse response(gurl_);
+    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_, SetTotalBytes(5000000));
+    EXPECT_CALL(host_, SetBufferedBytes(0));
+
+    data_source_->loader()->didReceiveResponse(data_source_->url_loader(),
+                                               response);
+
+    message_loop_->RunAllPending();
+  }
+
+  void StopDataSource() {
+    data_source_->Stop(media::NewExpectedClosure());
+    message_loop_->RunAllPending();
+  }
+
+  MOCK_METHOD1(ReadCallback, void(size_t size));
+  media::DataSource::ReadCallback NewReadCallback(size_t size) {
+    EXPECT_CALL(*this, ReadCallback(size));
+    return base::Bind(&BufferedDataSourceTest2::ReadCallback,
+                      base::Unretained(this));
+  }
+
+  // Accessors for private variables on |data_source_|.
+  media::Preload preload() { return data_source_->preload_; }
+  BufferedResourceLoader::DeferStrategy defer_strategy() {
+    return data_source_->loader()->defer_strategy_;
+  }
+  int data_source_bitrate() { return data_source_->bitrate_; }
+  int data_source_playback_rate() { return data_source_->playback_rate_; }
+  int loader_bitrate() { return data_source_->loader()->bitrate_; }
+  int loader_playback_rate() { return data_source_->loader()->playback_rate_; }
+
+  scoped_refptr<MockBufferedDataSource2> data_source_;
+
+  GURL gurl_;
+  MockWebFrameClient client_;
+  WebView* view_;
+
+  StrictMock<media::MockFilterHost> host_;
+  MessageLoop* message_loop_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(BufferedDataSourceTest2);
+};
+
+TEST_F(BufferedDataSourceTest2, Default) {
+  InitializeDataSource("http://localhost/foo.webm");
+
+  // Ensure we have sane values for default loading scenario.
+  EXPECT_EQ(media::AUTO, preload());
+  EXPECT_EQ(BufferedResourceLoader::kThresholdDefer, defer_strategy());
+
+  EXPECT_EQ(0, data_source_bitrate());
+  EXPECT_EQ(0.0f, data_source_playback_rate());
+  EXPECT_EQ(0, loader_bitrate());
+  EXPECT_EQ(0.0f, loader_playback_rate());
+
+  StopDataSource();
+}
+
+TEST_F(BufferedDataSourceTest2, SetBitrate) {
+  InitializeDataSource("http://localhost/foo.webm");
+
+  data_source_->SetBitrate(1234);
+  message_loop_->RunAllPending();
+  EXPECT_EQ(1234, data_source_bitrate());
+  EXPECT_EQ(1234, loader_bitrate());
+
+  // Read so far ahead to cause the loader to get recreated.
+  BufferedResourceLoader* old_loader = data_source_->loader();
+
+  uint8 buffer[1024];
+  data_source_->Read(4000000, 1024, buffer,
+                     NewReadCallback(media::DataSource::kReadError));
+  message_loop_->RunAllPending();
+
+  // Verify loader changed but still has same bitrate.
+  EXPECT_NE(old_loader, data_source_->loader().get());
+  EXPECT_EQ(1234, loader_bitrate());
+
+  StopDataSource();
+}
+
+TEST_F(BufferedDataSourceTest2, SetPlaybackRate) {
+  InitializeDataSource("http://localhost/foo.webm");
+
+  data_source_->SetPlaybackRate(2.0f);
+  message_loop_->RunAllPending();
+  EXPECT_EQ(2.0f, data_source_playback_rate());
+  EXPECT_EQ(2.0f, loader_playback_rate());
+
+  // Read so far ahead to cause the loader to get recreated.
+  BufferedResourceLoader* old_loader = data_source_->loader();
+
+  uint8 buffer[1024];
+  data_source_->Read(4000000, 1024, buffer,
+                     NewReadCallback(media::DataSource::kReadError));
+  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_glue