Retry requests that has timed out in BufferedDataSource

webkit/glue/media/buffered_data_source_unittest.cc

 // Copyright (c) 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 <algorithm>
 
 #include "base/string_util.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 "net/http/http_response_headers.h"
 #include "webkit/glue/media/buffered_data_source.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::DeleteArg;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::Invoke;
+using ::testing::InvokeWithoutArgs;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::SetArgumentPointee;
 using ::testing::StrictMock;
 using ::testing::WithArgs;
 
 namespace {
 
 const char* kHttpUrl = "http://test";
 const int kDataSize = 1024;
@@ skipping 308 matching lines @@
   static media::FilterFactory* CreateFactory(
       MessageLoop* message_loop,
       MediaResourceLoaderBridgeFactory* bridge_factory) {
     return new media::FilterFactoryImpl2<
         MockBufferedDataSource,
         MessageLoop*,
         MediaResourceLoaderBridgeFactory*>(message_loop,
                                            bridge_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(CreateLoader, BufferedResourceLoader*(int64 first_position,
                                                      int64 last_position));
 
  protected:
   MockBufferedDataSource(
       MessageLoop* message_loop,
       MediaResourceLoaderBridgeFactory* factory)
       : BufferedDataSource(message_loop, factory) {
   }
 
@@ skipping 17 matching lines @@
                                                      bridge_factory_.get());
 
     // Prepare test data.
     for (size_t i = 0; i < sizeof(data_); ++i) {
       data_[i] = i;
     }
   }
 
   ~BufferedDataSourceTest() {
     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));
     }
 
     // We don't own the message loop so release it.
     message_loop_.release();
   }
 
@@ skipping 164 matching lines @@
     // 4. The the loader is destroyed.
     EXPECT_CALL(*loader_, Stop());
 
     data_source_->Read(
         position, size, buffer_,
         NewCallback(this, &BufferedDataSourceTest::ReadCallback));
 
     message_loop_->RunAllPending();
   }
 
+  void ReadDataSourceTimesOut(int64 position, int size) {
+    InSequence s;
+    // 1. Drop the request and let it times out.
+    EXPECT_CALL(*loader_, Read(position, size, NotNull(), NotNull()))
+        .WillOnce(DeleteArg<3>());
+    
+    // 2. Then the current loader will be stop and destroyed.
+    StrictMock<MockBufferedResourceLoader> *new_loader =
+        new StrictMock<MockBufferedResourceLoader>();
+    EXPECT_CALL(*loader_, Stop());
+    EXPECT_CALL(*data_source_, CreateLoader(position, -1))
+        .WillOnce(Return(new_loader));
+    EXPECT_CALL(*loader_, OnDestroy())
+        .WillOnce(Invoke(this, &BufferedDataSourceTest::ReleaseLoader));
+    
+    // 3. Then the new loader will be started.
+    EXPECT_CALL(*new_loader, Start(NotNull()))
+        .WillOnce(DoAll(Assign(&error_, net::OK),
+                        Invoke(this,
+                               &BufferedDataSourceTest::InvokeStartCallback)));
+    
+    // 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,
+                               &BufferedDataSourceTest::InvokeReadCallback),
+                        InvokeWithoutArgs(message_loop_.get(),
+                                          &MessageLoop::Quit)));
+
+    EXPECT_CALL(*this, ReadCallback(size));
+    
+    data_source_->Read(
+        position, size, buffer_,
+        NewCallback(this, &BufferedDataSourceTest::ReadCallback));
+
+    // This blocks the current thread until the watch task is executed and
+    // triggers a read callback to quit this message loop.
+    message_loop_->Run();
+
+    // Make sure data is correct.
+    EXPECT_EQ(0, memcmp(buffer_, data_ + static_cast<int>(position), size));
+    
+    EXPECT_TRUE(loader_.get() == NULL);
+    loader_.reset(new_loader);
+  }
+
   MOCK_METHOD1(ReadCallback, void(size_t size));
 
   scoped_ptr<StrictMock<MockMediaResourceLoaderBridgeFactory> >
       bridge_factory_;
   scoped_ptr<StrictMock<MockBufferedResourceLoader> > loader_;
   scoped_refptr<MockBufferedDataSource > data_source_;
   scoped_refptr<media::FilterFactory> factory_;
 
   StrictMock<media::MockFilterHost> host_;
   GURL gurl_;
@@ skipping 36 matching lines @@
   StopDataSource();
 }
 
 TEST_F(BufferedDataSourceTest, ReadFailed) {
   InitializeDataSource(kHttpUrl, net::OK, 1024);
   ReadDataSourceHit(10, 10, 10);
   ReadDataSourceFailed(10, 10, net::ERR_CONNECTION_RESET);
   StopDataSource();
 }
 
+TEST_F(BufferedDataSourceTest, ReadTimesOut) {
+  InitializeDataSource(kHttpUrl, net::OK, 1024);
+  ReadDataSourceTimesOut(20, 10);
+  StopDataSource();
+}
+
 }  // namespace webkit_glue