Revert 68094 - Refactoring BufferedDataSource to work with WebURLLoader inste...

webkit/glue/media/buffered_data_source_unittest.cc

 // Copyright (c) 2010 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/callback.h"
 #include "base/format_macros.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "media/base/filters.h"
 #include "media/base/mock_filter_host.h"
 #include "media/base/mock_filters.h"
 #include "net/base/net_errors.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebFrame.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebFrameClient.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebString.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebURLError.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebURLLoader.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebURLRequest.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebURLResponse.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebView.h"
+#include "net/http/http_response_headers.h"
 #include "webkit/glue/media/buffered_data_source.h"
-#include "webkit/glue/mock_webframe.h"
-#include "webkit/glue/mock_weburlloader_impl.h"
+#include "webkit/glue/media/mock_media_resource_loader_bridge_factory.h"
+#include "webkit/glue/mock_resource_loader_bridge.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::WebURLError;
-using WebKit::WebFrame;
-using WebKit::WebFrameClient;
-using WebKit::WebString;
-using WebKit::WebURLLoader;
-using WebKit::WebURLRequest;
-using WebKit::WebURLResponse;
-using WebKit::WebView;
-
 namespace {
 
 const char* kHttpUrl = "http://test";
 const char* kFileUrl = "file://test";
 const int kDataSize = 1024;
-const int kHttpOK = 200;
-const int kHttpPartialContent = 206;
 
 enum NetworkState {
   NONE,
   LOADED,
   LOADING
 };
 
 }  // namespace
 
 namespace webkit_glue {
 
 // Submit a request completed event to the resource loader due to request
 // being canceled. Pretending the event is from external.
 ACTION_P(RequestCanceled, loader) {
-  WebURLError error;
-  error.reason = net::ERR_ABORTED;
-  error.domain = WebString::fromUTF8(net::kErrorDomain);
-  loader->didFail(NULL, error);
+  URLRequestStatus status;
+  status.set_status(URLRequestStatus::CANCELED);
+  status.set_os_error(net::ERR_ABORTED);
+  loader->OnCompletedRequest(status, "", base::Time());
 }
 
 class BufferedResourceLoaderTest : public testing::Test {
  public:
   BufferedResourceLoaderTest() {
-    url_loader_ = new NiceMock<MockWebURLLoader>();
+    bridge_.reset(new StrictMock<MockResourceLoaderBridge>());
 
     for (int i = 0; i < kDataSize; ++i)
       data_[i] = i;
   }
 
-  virtual ~BufferedResourceLoaderTest() {
-    ignore_result(frame_.release());
+  ~BufferedResourceLoaderTest() {
+    if (bridge_.get())
+      EXPECT_CALL(*bridge_, OnDestroy());
+    EXPECT_CALL(bridge_factory_, OnDestroy());
   }
 
   void Initialize(const char* url, int first_position, int last_position) {
     gurl_ = GURL(url);
     first_position_ = first_position;
     last_position_ = last_position;
 
-    frame_.reset(new NiceMock<MockWebFrame>());
-
-    loader_ = new BufferedResourceLoader(gurl_,
+    loader_ = new BufferedResourceLoader(&bridge_factory_, gurl_,
                                          first_position_, last_position_);
-    loader_->SetURLLoaderForTest(url_loader_);
   }
 
   void SetLoaderBuffer(size_t forward_capacity, size_t backward_capacity) {
     loader_->buffer_.reset(
         new media::SeekableBuffer(backward_capacity, forward_capacity));
   }
 
   void Start() {
     InSequence s;
-    EXPECT_CALL(*url_loader_, loadAsynchronously(_, loader_.get()));
+    EXPECT_CALL(bridge_factory_,
+                CreateBridge(gurl_, _, first_position_, last_position_))
+        .WillOnce(Return(bridge_.get()));
+    EXPECT_CALL(*bridge_, Start(loader_.get()));
     loader_->Start(
         NewCallback(this, &BufferedResourceLoaderTest::StartCallback),
-        NewCallback(this, &BufferedResourceLoaderTest::NetworkCallback),
-        frame_.get());
+        NewCallback(this, &BufferedResourceLoaderTest::NetworkCallback));
   }
 
   void FullResponse(int64 instance_size) {
     EXPECT_CALL(*this, StartCallback(net::OK));
-
-    WebURLResponse response(gurl_);
-    response.setHTTPHeaderField(WebString::fromUTF8("Content-Length"),
-                                WebString::fromUTF8(base::StringPrintf("%"
-                                    PRId64, instance_size)));
-    response.setExpectedContentLength(instance_size);
-    response.setHTTPStatusCode(kHttpOK);
-    loader_->didReceiveResponse(url_loader_, response);
+    ResourceResponseInfo info;
+    std::string header = base::StringPrintf("HTTP/1.1 200 OK\n"
+                                            "Content-Length: %" PRId64,
+                                            instance_size);
+    replace(header.begin(), header.end(), '\n', '\0');
+    info.headers = new net::HttpResponseHeaders(header);
+    info.content_length = instance_size;
+    loader_->OnReceivedResponse(info, false);
     EXPECT_EQ(instance_size, loader_->content_length());
     EXPECT_EQ(instance_size, loader_->instance_size());
     EXPECT_FALSE(loader_->partial_response());
   }
 
   void PartialResponse(int64 first_position, int64 last_position,
                        int64 instance_size) {
     EXPECT_CALL(*this, StartCallback(net::OK));
     int64 content_length = last_position - first_position + 1;
-
-    WebURLResponse response(gurl_);
-    response.setHTTPHeaderField(WebString::fromUTF8("Content-Range"),
-                                WebString::fromUTF8(base::StringPrintf("bytes "
+    ResourceResponseInfo info;
+    std::string header = base::StringPrintf("HTTP/1.1 206 Partial Content\n"
+                                            "Content-Range: bytes "
                                             "%" PRId64 "-%" PRId64 "/%" PRId64,
                                             first_position,
                                             last_position,
-                                            instance_size)));
-    response.setExpectedContentLength(content_length);
-    response.setHTTPStatusCode(kHttpPartialContent);
-    loader_->didReceiveResponse(url_loader_, response);
+                                            instance_size);
+    replace(header.begin(), header.end(), '\n', '\0');
+    info.headers = new net::HttpResponseHeaders(header);
+    info.content_length = content_length;
+    loader_->OnReceivedResponse(info, false);
     EXPECT_EQ(content_length, loader_->content_length());
     EXPECT_EQ(instance_size, loader_->instance_size());
     EXPECT_TRUE(loader_->partial_response());
   }
 
   void StopWhenLoad() {
     InSequence s;
-    EXPECT_CALL(*url_loader_, cancel())
+    EXPECT_CALL(*bridge_, Cancel())
         .WillOnce(RequestCanceled(loader_));
+    EXPECT_CALL(*bridge_, OnDestroy())
+        .WillOnce(Invoke(this, &BufferedResourceLoaderTest::ReleaseBridge));
     loader_->Stop();
   }
 
+  void ReleaseBridge() {
+    ignore_result(bridge_.release());
+  }
+
   // Helper method to write to |loader_| from |data_|.
   void WriteLoader(int position, int size) {
     EXPECT_CALL(*this, NetworkCallback())
         .RetiresOnSaturation();
-    loader_->didReceiveData(url_loader_,
-                            reinterpret_cast<char*>(data_ + position), size);
+    loader_->OnReceivedData(reinterpret_cast<char*>(data_ + position), size);
   }
 
   // Helper method to read from |loader_|.
   void ReadLoader(int64 position, int size, uint8* buffer) {
     loader_->Read(position, size, buffer,
                   NewCallback(this, &BufferedResourceLoaderTest::ReadCallback));
   }
 
   // Verifis that data in buffer[0...size] is equal to data_[pos...pos+size].
   void VerifyBuffer(uint8* buffer, int pos, int size) {
     EXPECT_EQ(0, memcmp(buffer, data_ + pos, size));
   }
 
   // Helper method to disallow deferring in |loader_|.
   void DisallowLoaderDefer() {
     if (loader_->deferred_) {
-      EXPECT_CALL(*url_loader_, setDefersLoading(false));
+      EXPECT_CALL(*bridge_, SetDefersLoading(false));
       EXPECT_CALL(*this, NetworkCallback());
     }
     loader_->SetAllowDefer(false);
   }
 
   // Helper method to allow deferring in |loader_|.
   void AllowLoaderDefer() {
     loader_->SetAllowDefer(true);
   }
 
   MOCK_METHOD1(StartCallback, void(int error));
   MOCK_METHOD1(ReadCallback, void(int error));
   MOCK_METHOD0(NetworkCallback, void());
 
  protected:
   GURL gurl_;
   int64 first_position_;
   int64 last_position_;
 
   scoped_refptr<BufferedResourceLoader> loader_;
-  NiceMock<MockWebURLLoader>* url_loader_;
-  scoped_ptr<NiceMock<MockWebFrame> > frame_;
+  StrictMock<MockMediaResourceLoaderBridgeFactory> bridge_factory_;
+  scoped_ptr<StrictMock<MockResourceLoaderBridge> > bridge_;
 
   uint8 data_[kDataSize];
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BufferedResourceLoaderTest);
 };
 
 TEST_F(BufferedResourceLoaderTest, StartStop) {
   Initialize(kHttpUrl, -1, -1);
   Start();
   StopWhenLoad();
 }
 
+// Tests that HTTP header is missing in the response.
+TEST_F(BufferedResourceLoaderTest, MissingHttpHeader) {
+  Initialize(kHttpUrl, -1, -1);
+  Start();
+
+  EXPECT_CALL(*this, StartCallback(net::ERR_INVALID_RESPONSE));
+  EXPECT_CALL(*bridge_, Cancel())
+      .WillOnce(RequestCanceled(loader_));
+  EXPECT_CALL(*bridge_, OnDestroy())
+      .WillOnce(Invoke(this, &BufferedResourceLoaderTest::ReleaseBridge));
+
+  ResourceResponseInfo info;
+  loader_->OnReceivedResponse(info, false);
+}
+
 // Tests that a bad HTTP response is recived, e.g. file not found.
 TEST_F(BufferedResourceLoaderTest, BadHttpResponse) {
   Initialize(kHttpUrl, -1, -1);
   Start();
 
   EXPECT_CALL(*this, StartCallback(net::ERR_FAILED));
-  EXPECT_CALL(*url_loader_, cancel())
+  EXPECT_CALL(*bridge_, Cancel())
       .WillOnce(RequestCanceled(loader_));
+  EXPECT_CALL(*bridge_, OnDestroy())
+      .WillOnce(Invoke(this, &BufferedResourceLoaderTest::ReleaseBridge));
 
-  WebURLResponse response(gurl_);
-  response.setHTTPStatusCode(404);
-  response.setHTTPStatusText("Not Found\n");
-  loader_->didReceiveResponse(url_loader_, response);
+  ResourceResponseInfo info;
+  info.headers = new net::HttpResponseHeaders("HTTP/1.1 404 Not Found\n");
+  loader_->OnReceivedResponse(info, false);
 }
 
 // Tests that partial content is requested but not fulfilled.
 TEST_F(BufferedResourceLoaderTest, NotPartialResponse) {
   Initialize(kHttpUrl, 100, -1);
   Start();
   FullResponse(1024);
   StopWhenLoad();
 }
 
@@ skipping 12 matching lines @@
   PartialResponse(100, 200, 1024);
   StopWhenLoad();
 }
 
 // Tests that an invalid partial response is received.
 TEST_F(BufferedResourceLoaderTest, InvalidPartialResponse) {
   Initialize(kHttpUrl, 0, 10);
   Start();
 
   EXPECT_CALL(*this, StartCallback(net::ERR_INVALID_RESPONSE));
-  EXPECT_CALL(*url_loader_, cancel())
+  EXPECT_CALL(*bridge_, Cancel())
       .WillOnce(RequestCanceled(loader_));
+  EXPECT_CALL(*bridge_, OnDestroy())
+      .WillOnce(Invoke(this, &BufferedResourceLoaderTest::ReleaseBridge));
 
-  WebURLResponse response(gurl_);
-  response.setHTTPHeaderField(WebString::fromUTF8("Content-Range"),
-                              WebString::fromUTF8(base::StringPrintf("bytes "
-                                  "%d-%d/%d", 1, 10, 1024)));
-  response.setExpectedContentLength(10);
-  response.setHTTPStatusCode(kHttpPartialContent);
-  loader_->didReceiveResponse(url_loader_, response);
+  ResourceResponseInfo info;
+  std::string header = base::StringPrintf("HTTP/1.1 206 Partial Content\n"
+                                          "Content-Range: bytes %d-%d/%d",
+                                          1, 10, 1024);
+  replace(header.begin(), header.end(), '\n', '\0');
+  info.headers = new net::HttpResponseHeaders(header);
+  info.content_length = 10;
+  loader_->OnReceivedResponse(info, false);
 }
 
 // Tests the logic of sliding window for data buffering and reading.
 TEST_F(BufferedResourceLoaderTest, BufferAndRead) {
   Initialize(kHttpUrl, 10, 29);
   Start();
   PartialResponse(10, 29, 30);
 
   uint8 buffer[10];
   InSequence s;
@@ skipping 17 matching lines @@
   EXPECT_CALL(*this, ReadCallback(10));
   ReadLoader(10, 10, buffer);
   VerifyBuffer(buffer, 10, 10);
 
   // Read backward outside buffer.
   EXPECT_CALL(*this, ReadCallback(net::ERR_CACHE_MISS));
   ReadLoader(9, 10, buffer);
 
   // Response has completed.
   EXPECT_CALL(*this, NetworkCallback());
-  loader_->didFinishLoading(url_loader_, 0);
+  EXPECT_CALL(*bridge_, OnDestroy())
+      .WillOnce(Invoke(this, &BufferedResourceLoaderTest::ReleaseBridge));
+  URLRequestStatus status;
+  status.set_status(URLRequestStatus::SUCCESS);
+  loader_->OnCompletedRequest(status, "", base::Time());
 
   // Try to read 10 from position 25 will just return with 5 bytes.
   EXPECT_CALL(*this, ReadCallback(5));
   ReadLoader(25, 10, buffer);
   VerifyBuffer(buffer, 25, 5);
 
   // Try to read outside buffered range after request has completed.
   EXPECT_CALL(*this, ReadCallback(net::ERR_CACHE_MISS));
   ReadLoader(5, 10, buffer);
 
@@ skipping 21 matching lines @@
   // Writing to loader will fulfill the read request.
   EXPECT_CALL(*this, ReadCallback(10));
   WriteLoader(10, 20);
   VerifyBuffer(buffer, 10, 10);
 
   // The following call cannot be fulfilled now.
   ReadLoader(25, 10, buffer);
 
   EXPECT_CALL(*this, ReadCallback(5));
   EXPECT_CALL(*this, NetworkCallback());
-  loader_->didFinishLoading(url_loader_, 0);
+  EXPECT_CALL(*bridge_, OnDestroy())
+      .WillOnce(Invoke(this, &BufferedResourceLoaderTest::ReleaseBridge));
+  URLRequestStatus status;
+  status.set_status(URLRequestStatus::SUCCESS);
+  loader_->OnCompletedRequest(status, "", base::Time());
 }
 
 TEST_F(BufferedResourceLoaderTest, RequestFailedWhenRead) {
   Initialize(kHttpUrl, 10, 29);
   Start();
   PartialResponse(10, 29, 30);
 
   uint8 buffer[10];
   InSequence s;
 
   ReadLoader(10, 10, buffer);
   EXPECT_CALL(*this, ReadCallback(net::ERR_FAILED));
   EXPECT_CALL(*this, NetworkCallback());
-  WebURLError error;
-  error.reason = net::ERR_FAILED;
-  loader_->didFail(url_loader_, error);
+  EXPECT_CALL(*bridge_, OnDestroy())
+      .WillOnce(Invoke(this, &BufferedResourceLoaderTest::ReleaseBridge));
+  URLRequestStatus status;
+  status.set_status(URLRequestStatus::FAILED);
+  loader_->OnCompletedRequest(status, "", base::Time());
 }
 
 // Tests the logic of caching data to disk when media is paused.
 TEST_F(BufferedResourceLoaderTest, AllowDefer_NoDataReceived) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 20);
   Start();
   PartialResponse(10, 99, 100);
 
   // Start in undeferred state, then disallow defer, then allow defer
@@ skipping 46 matching lines @@
 TEST_F(BufferedResourceLoaderTest, AllowDefer_DeferredNoDataReceived) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 20);
   Start();
   PartialResponse(10, 99, 100);
 
   uint8 buffer[10];
 
   // Start in deferred state, then disallow defer, receive no data, and
   // allow defer and read.
-  EXPECT_CALL(*url_loader_, setDefersLoading(true));
+  EXPECT_CALL(*bridge_, SetDefersLoading(true));
   EXPECT_CALL(*this, NetworkCallback());
   WriteLoader(10, 40);
 
   DisallowLoaderDefer();
   AllowLoaderDefer();
 
   EXPECT_CALL(*this, ReadCallback(10));
   ReadLoader(20, 10, buffer);
   VerifyBuffer(buffer, 20, 10);
   StopWhenLoad();
 }
 
 TEST_F(BufferedResourceLoaderTest, AllowDefer_DeferredReadSameWindow) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 20);
   Start();
   PartialResponse(10, 99, 100);
 
   uint8 buffer[10];
 
   // Start in deferred state, disallow defer, receive data and shift buffer
   // window, allow defer, and read in a place that's still in the window.
-  EXPECT_CALL(*url_loader_, setDefersLoading(true));
+  EXPECT_CALL(*bridge_, SetDefersLoading(true));
   EXPECT_CALL(*this, NetworkCallback());
   WriteLoader(10, 30);
 
   DisallowLoaderDefer();
   WriteLoader(40, 5);
   AllowLoaderDefer();
 
   EXPECT_CALL(*this, ReadCallback(10));
   ReadLoader(20, 10, buffer);
   VerifyBuffer(buffer, 20, 10);
   StopWhenLoad();
 }
 
 TEST_F(BufferedResourceLoaderTest, AllowDefer_DeferredReadPastWindow) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 20);
   Start();
   PartialResponse(10, 99, 100);
 
   uint8 buffer[10];
 
   // Start in deferred state, disallow defer, receive data and shift buffer
   // window, allow defer, and read outside of the buffer window.
-  EXPECT_CALL(*url_loader_, setDefersLoading(true));
+  EXPECT_CALL(*bridge_, SetDefersLoading(true));
   EXPECT_CALL(*this, NetworkCallback());
   WriteLoader(10, 40);
 
   DisallowLoaderDefer();
   WriteLoader(50, 20);
   WriteLoader(70, 40);
   AllowLoaderDefer();
 
   EXPECT_CALL(*this, ReadCallback(net::ERR_CACHE_MISS));
   ReadLoader(20, 5, buffer);
   StopWhenLoad();
 }
+
 // TODO(hclam): add unit test for defer loading.
 
 class MockBufferedResourceLoader : public BufferedResourceLoader {
  public:
-  MockBufferedResourceLoader() : BufferedResourceLoader(GURL(), 0, 0) {
+  MockBufferedResourceLoader() : BufferedResourceLoader(NULL, GURL(), 0, 0) {
   }
 
-  MOCK_METHOD3(Start, void(net::CompletionCallback* read_callback,
-                           NetworkEventCallback* network_callback,
-                           WebFrame* frame));
+  MOCK_METHOD2(Start, void(net::CompletionCallback* read_callback,
+                           NetworkEventCallback* network_callback));
   MOCK_METHOD0(Stop, void());
   MOCK_METHOD4(Read, void(int64 position, int read_size, uint8* buffer,
                           net::CompletionCallback* callback));
   MOCK_METHOD0(content_length, int64());
   MOCK_METHOD0(instance_size, int64());
   MOCK_METHOD0(partial_response, bool());
   MOCK_METHOD0(network_activity, bool());
   MOCK_METHOD0(url, const GURL&());
   MOCK_METHOD0(GetBufferedFirstBytePosition, int64());
   MOCK_METHOD0(GetBufferedLastBytePosition, int64());
 
  protected:
   ~MockBufferedResourceLoader() {}
 
   DISALLOW_COPY_AND_ASSIGN(MockBufferedResourceLoader);
 };
 
 // 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) {
+      MessageLoop* message_loop, MediaResourceLoaderBridgeFactory* factory)
+      : BufferedDataSource(message_loop, factory) {
   }
 
   virtual base::TimeDelta GetTimeoutMilliseconds() {
     // It is 100 ms because we don't want the test to run too long.
     return base::TimeDelta::FromMilliseconds(100);
   }
 
   MOCK_METHOD2(CreateResourceLoader, BufferedResourceLoader*(
       int64 first_position, int64 last_position));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockBufferedDataSource);
 };
 
 class BufferedDataSourceTest : public testing::Test {
  public:
   BufferedDataSourceTest() {
     message_loop_ = MessageLoop::current();
+    bridge_factory_.reset(
+        new StrictMock<MockMediaResourceLoaderBridgeFactory>());
 
     // Prepare test data.
     for (size_t i = 0; i < sizeof(data_); ++i) {
       data_[i] = i;
     }
   }
 
   virtual ~BufferedDataSourceTest() {
-    ignore_result(frame_.release());
+    if (data_source_) {
+      // Release the bridge factory because we don't own it.
+      // Expects bridge factory to be destroyed along with data source.
+      EXPECT_CALL(*bridge_factory_, OnDestroy())
+          .WillOnce(Invoke(this,
+                           &BufferedDataSourceTest::ReleaseBridgeFactory));
+    }
   }
 
   void ExpectCreateAndStartResourceLoader(int start_error) {
     EXPECT_CALL(*data_source_, CreateResourceLoader(_, _))
         .WillOnce(Return(loader_.get()));
 
-    EXPECT_CALL(*loader_, Start(NotNull(), NotNull(), NotNull()))
+    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) {
     // Saves the url first.
     gurl_ = GURL(url);
 
-    frame_.reset(new NiceMock<MockWebFrame>());
+    media::MediaFormat url_format;
+    url_format.SetAsString(media::MediaFormat::kMimeType,
+                           media::mime_type::kURL);
+    url_format.SetAsString(media::MediaFormat::kURL, url);
+    data_source_ = new MockBufferedDataSource(MessageLoop::current(),
+                                              bridge_factory_.get());
+    CHECK(data_source_);
 
-    data_source_ = new MockBufferedDataSource(MessageLoop::current(),
-                                              frame_.get());
+    // There is no need to provide a message loop to data source.
     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;
     {
       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_));
         EXPECT_CALL(*loader_, Stop());
 
         // Replace loader_ with a new instance.
         loader_ = new NiceMock<MockBufferedResourceLoader>();
 
-        // Create and start. Make sure Start() is called on the new loader.
+        // Create and start Make sure Start() is called the new loader.
         ExpectCreateAndStartResourceLoader(net::OK);
 
         // Update initialization variable since we know the second loader will
         // return OK.
         initialized_ok = true;
       }
     }
 
     // Attach a static function that deletes the memory referred by the
     // "callback" parameter.
@@ skipping 53 matching lines @@
       EXPECT_CALL(*loader_, Stop());
     }
 
     StrictMock<media::MockFilterCallback> callback;
     EXPECT_CALL(callback, OnFilterCallback());
     EXPECT_CALL(callback, OnCallbackDestroyed());
     data_source_->Stop(callback.NewCallback());
     message_loop_->RunAllPending();
   }
 
+  void ReleaseBridgeFactory() {
+    ignore_result(bridge_factory_.release());
+  }
+
   void InvokeStartCallback(
       net::CompletionCallback* callback,
-      BufferedResourceLoader::NetworkEventCallback* network_callback,
-      WebFrame* frame) {
+      BufferedResourceLoader::NetworkEventCallback* network_callback) {
     callback->RunWithParams(Tuple1<int>(error_));
     delete callback;
     // TODO(hclam): Save this callback.
     delete network_callback;
   }
 
   void InvokeReadCallback(int64 position, int size, uint8* buffer,
                           net::CompletionCallback* callback) {
     if (error_ > 0)
       memcpy(buffer, data_ + static_cast<int>(position), error_);
@@ skipping 58 matching lines @@
       EXPECT_CALL(*loader_, Stop());
     }
 
     // 2. Then the current loader will be stop and destroyed.
     NiceMock<MockBufferedResourceLoader> *new_loader =
         new NiceMock<MockBufferedResourceLoader>();
     EXPECT_CALL(*data_source_, CreateResourceLoader(position, -1))
         .WillOnce(Return(new_loader));
 
     // 3. Then the new loader will be started.
-    EXPECT_CALL(*new_loader, Start(NotNull(), NotNull(), NotNull()))
+    EXPECT_CALL(*new_loader, Start(NotNull(), NotNull()))
         .WillOnce(DoAll(Assign(&error_, net::OK),
                         Invoke(this,
                                &BufferedDataSourceTest::InvokeStartCallback)));
     EXPECT_CALL(*new_loader, partial_response())
         .WillRepeatedly(Return(loader_->partial_response()));
 
     // 4. Then again a read request is made to the new loader.
     EXPECT_CALL(*new_loader, Read(position, size, NotNull(), NotNull()))
         .WillOnce(DoAll(Assign(&error_, size),
                         Invoke(this,
@@ skipping 45 matching lines @@
 
     // 2. Then the current loader will be stop and destroyed.
     NiceMock<MockBufferedResourceLoader> *new_loader =
         new NiceMock<MockBufferedResourceLoader>();
     EXPECT_CALL(*data_source_, CreateResourceLoader(position, -1))
         .WillOnce(Return(new_loader));
 
     // 3. Then the new loader will be started and respond to queries about
     //    whether this is a partial response using the value of the previous
     //    loader.
-    EXPECT_CALL(*new_loader, Start(NotNull(), NotNull(), NotNull()))
+    EXPECT_CALL(*new_loader, Start(NotNull(), NotNull()))
         .WillOnce(DoAll(Assign(&error_, net::OK),
                         Invoke(this,
                                &BufferedDataSourceTest::InvokeStartCallback)));
     EXPECT_CALL(*new_loader, partial_response())
         .WillRepeatedly(Return(loader_->partial_response()));
 
     // 4. Then again a read request is made to the new loader.
     EXPECT_CALL(*new_loader, Read(position, size, NotNull(), NotNull()))
         .WillOnce(DoAll(Assign(&error_, size),
                         Invoke(this,
@@ skipping 12 matching lines @@
     message_loop_->Run();
 
     // Make sure data is correct.
     EXPECT_EQ(0, memcmp(buffer_, data_ + static_cast<int>(position), size));
 
     loader_ = new_loader;
   }
 
   MOCK_METHOD1(ReadCallback, void(size_t size));
 
+  scoped_ptr<StrictMock<MockMediaResourceLoaderBridgeFactory> >
+      bridge_factory_;
   scoped_refptr<NiceMock<MockBufferedResourceLoader> > loader_;
   scoped_refptr<MockBufferedDataSource> data_source_;
-  scoped_ptr<NiceMock<MockWebFrame> > frame_;
 
   StrictMock<media::MockFilterHost> host_;
   GURL gurl_;
   MessageLoop* message_loop_;
 
   int error_;
   uint8 buffer_[1024];
   uint8 data_[1024];
 
  private:
@@ skipping 71 matching lines @@
   StopDataSource();
 }
 
 TEST_F(BufferedDataSourceTest, FileHasLoadedState) {
   InitializeDataSource(kFileUrl, net::OK, true, 1024, LOADED);
   ReadDataSourceTimesOut(20, 10);
   StopDataSource();
 }
 
 }  // namespace webkit_glue