Refcounting BufferedResourceLoader

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"
@@ skipping 18 matching lines @@
 
 namespace {
 
 const char* kHttpUrl = "http://test";
 const int kDataSize = 1024;
 
 }  // 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) {
+  URLRequestStatus status;
+  status.set_status(URLRequestStatus::CANCELED);
+  loader->OnCompletedRequest(status, "");
+}
+
 class BufferedResourceLoaderTest : public testing::Test {
  public:
   BufferedResourceLoaderTest() {
     bridge_.reset(new StrictMock<MockResourceLoaderBridge>());
 
     for (int i = 0; i < kDataSize; ++i)
       data_[i] = i;
   }
 
   ~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;
 
-    loader_.reset(new BufferedResourceLoader(&bridge_factory_, gurl_,
-                                             first_position_, last_position_));
+    loader_ = new BufferedResourceLoader(&bridge_factory_, gurl_,
+                                         first_position_, last_position_);
     EXPECT_EQ(gurl_.spec(), loader_->GetURLForDebugging());
   }
 
   void Start() {
     InSequence s;
     EXPECT_CALL(bridge_factory_,
                 CreateBridge(gurl_, _, first_position_, last_position_))
         .WillOnce(Return(bridge_.get()));
     EXPECT_CALL(*bridge_, Start(loader_.get()));
     loader_->Start(NewCallback(this,
@@ skipping 25 matching lines @@
     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());
   }
 
   void StopWhenLoad() {
     InSequence s;
-    EXPECT_CALL(*bridge_, Cancel());
+    EXPECT_CALL(*bridge_, Cancel())
+        .WillOnce(RequestCanceled(loader_));
     EXPECT_CALL(*bridge_, OnDestroy())
-      .WillOnce(Invoke(this, &BufferedResourceLoaderTest::ReleaseBridge));
+        .WillOnce(Invoke(this, &BufferedResourceLoaderTest::ReleaseBridge));
     loader_->Stop();
   }
 
   void ReleaseBridge() {
     bridge_.release();
   }
 
   // Helper method to write to |loader_| from |data_|.
   void WriteLoader(int position, int size) {
     loader_->OnReceivedData(reinterpret_cast<char*>(data_ + position), size);
@@ skipping 11 matching lines @@
   }
 
   MOCK_METHOD1(StartCallback, void(int error));
   MOCK_METHOD1(ReadCallback, void(int error));
 
  protected:
   GURL gurl_;
   int64 first_position_;
   int64 last_position_;
 
-  scoped_ptr<BufferedResourceLoader> loader_;
+  scoped_refptr<BufferedResourceLoader> loader_;
   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());
+  EXPECT_CALL(*bridge_, Cancel())
+      .WillOnce(RequestCanceled(loader_));
   EXPECT_CALL(*bridge_, OnDestroy())
       .WillOnce(Invoke(this, &BufferedResourceLoaderTest::ReleaseBridge));
 
   ResourceLoaderBridge::ResponseInfo 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(*bridge_, Cancel());
+  EXPECT_CALL(*bridge_, Cancel())
+      .WillOnce(RequestCanceled(loader_));
   EXPECT_CALL(*bridge_, OnDestroy())
       .WillOnce(Invoke(this, &BufferedResourceLoaderTest::ReleaseBridge));
 
   ResourceLoaderBridge::ResponseInfo info;
   info.headers = new net::HttpResponseHeaders("HTTP/1.1 404 Bot Found\n");
   loader_->OnReceivedResponse(info, false);
 }
 
 // Tests that partial content is requested but not fulfilled.
 TEST_F(BufferedResourceLoaderTest, NotPartialRange) {
   Initialize(kHttpUrl, 100, -1);
   Start();
 
   EXPECT_CALL(*this, StartCallback(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE));
-  EXPECT_CALL(*bridge_, Cancel());
+  EXPECT_CALL(*bridge_, Cancel())
+      .WillOnce(RequestCanceled(loader_));
   EXPECT_CALL(*bridge_, OnDestroy())
       .WillOnce(Invoke(this, &BufferedResourceLoaderTest::ReleaseBridge));
 
   ResourceLoaderBridge::ResponseInfo info;
   info.headers = new net::HttpResponseHeaders("HTTP/1.1 200 OK\n");
   loader_->OnReceivedResponse(info, false);
 }
 
 // Tests that a 200 response is received.
 TEST_F(BufferedResourceLoaderTest, FullResponse) {
@@ skipping 82 matching lines @@
   ReadLoader(10, 10, buffer);
 
   // 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(*bridge_, OnDestroy())
       .WillOnce(Invoke(this, &BufferedResourceLoaderTest::ReleaseBridge));
-  EXPECT_CALL(*this, ReadCallback(5));
   URLRequestStatus status;
   status.set_status(URLRequestStatus::SUCCESS);
   loader_->OnCompletedRequest(status, "");
 }
 
 TEST_F(BufferedResourceLoaderTest, RequestFailedWhenRead) {
   Initialize(kHttpUrl, 10, 29);
   Start();
   PartialResponse(30);
 
   uint8 buffer[10];
   InSequence s;
 
   ReadLoader(10, 10, buffer);
+  EXPECT_CALL(*this, ReadCallback(net::ERR_FAILED));
   EXPECT_CALL(*bridge_, OnDestroy())
       .WillOnce(Invoke(this, &BufferedResourceLoaderTest::ReleaseBridge));
-  EXPECT_CALL(*this, ReadCallback(net::ERR_FAILED));
   URLRequestStatus status;
   status.set_status(URLRequestStatus::FAILED);
   loader_->OnCompletedRequest(status, "");
 }
 
 // TODO(hclam): add unit test for defer loading.
 
 class MockBufferedResourceLoader : public BufferedResourceLoader {
  public:
   MockBufferedResourceLoader() : BufferedResourceLoader() {
   }
 
-  ~MockBufferedResourceLoader() {
-    OnDestroy();
-  }
-
   MOCK_METHOD1(Start, void(net::CompletionCallback* read_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(OnDestroy, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockBufferedResourceLoader);
 };
 
 // A mock BufferedDataSource to inject mock BufferedResourceLoader through
 // CreateLoader() method.
 class MockBufferedDataSource : public BufferedDataSource {
  public:
   // Static methods for creating this class.
@@ skipping 30 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(MockBufferedDataSource);
 };
 
 class BufferedDataSourceTest : public testing::Test {
  public:
   BufferedDataSourceTest() {
     message_loop_.reset(MessageLoop::current());
     bridge_factory_.reset(
         new StrictMock<MockMediaResourceLoaderBridgeFactory>());
-    ReleaseLoader();
     factory_ = MockBufferedDataSource::CreateFactory(message_loop_.get(),
                                                      bridge_factory_.get());
 
     // Prepare test data.
     for (size_t i = 0; i < sizeof(data_); ++i) {
       data_[i] = i;
     }
   }
 
   ~BufferedDataSourceTest() {
@@ skipping 18 matching lines @@
     url_format.SetAsString(media::MediaFormat::kMimeType,
                            media::mime_type::kURL);
     url_format.SetAsString(media::MediaFormat::kURL, url);
     data_source_ = factory_->Create<MockBufferedDataSource>(url_format);
     CHECK(data_source_);
 
     // There is no need to provide a message loop to data source.
     data_source_->set_host(&host_);
 
     // Creates the first mock loader to be injected.
-    loader_.reset(new StrictMock<MockBufferedResourceLoader>());
-    probe_loader_.reset(new StrictMock<MockBufferedResourceLoader>());
+    loader_ = new StrictMock<MockBufferedResourceLoader>();
+    probe_loader_ = new StrictMock<MockBufferedResourceLoader>();
 
     InSequence s;
     StrictMock<media::MockFilterCallback> callback;
 
     // There is one resource loader with full range will be created.
     EXPECT_CALL(*data_source_, CreateLoader(-1, -1))
         .WillOnce(Return(loader_.get()));
 
     // Then another resource loader with a small partial range is created.
     EXPECT_CALL(*data_source_, CreateLoader(1, 1))
@@ skipping 58 matching lines @@
       }
 
       // Verify the data source is streamed if the probe has received an error.
       if (probe_error != net::OK) {
         EXPECT_TRUE(data_source_->IsStreaming());
       }
     }
   }
 
   void StopDataSource() {
-    if (loader_.get()) {
+    if (loader_) {
       InSequence s;
       EXPECT_CALL(*loader_, Stop());
       EXPECT_CALL(*probe_loader_, Stop());
     }
 
-    EXPECT_CALL(*loader_, OnDestroy())
-       .WillOnce(Invoke(this, &BufferedDataSourceTest::ReleaseLoader));
-    EXPECT_CALL(*probe_loader_, OnDestroy())
-       .WillOnce(Invoke(this, &BufferedDataSourceTest::ReleaseProbeLoader));
-
     data_source_->Stop();
     message_loop_->RunAllPending();
   }
 
   void ReleaseBridgeFactory() {
     bridge_factory_.release();
   }
 
-  void ReleaseLoader() {
-    loader_.release();
-  }
-
-  void ReleaseProbeLoader() {
-    probe_loader_.release();
-  }
-
   void InvokeStartCallback(net::CompletionCallback* callback) {
     callback->RunWithParams(Tuple1<int>(error_));
     delete callback;
   }
 
   void InvokeReadCallback(int64 position, int size, uint8* buffer,
                           net::CompletionCallback* callback) {
     if (error_ > 0)
       memcpy(buffer, data_ + static_cast<int>(position), error_);
     callback->RunWithParams(Tuple1<int>(error_));
     delete callback;
   }
 
   void ReadDataSourceHit(int64 position, int size, int read_size) {
-    EXPECT_TRUE(loader_.get() != NULL);
+    EXPECT_TRUE(loader_);
 
     InSequence s;
     // Expect the read is delegated to the resource loader.
     EXPECT_CALL(*loader_, Read(position, size, NotNull(), NotNull()))
         .WillOnce(DoAll(Assign(&error_, read_size),
                         Invoke(this,
                                &BufferedDataSourceTest::InvokeReadCallback)));
 
     // The read has succeeded, so read callback will be called.
     EXPECT_CALL(*this, ReadCallback(read_size));
 
     data_source_->Read(
         position, size, buffer_,
         NewCallback(this, &BufferedDataSourceTest::ReadCallback));
     message_loop_->RunAllPending();
 
     // Make sure data is correct.
     EXPECT_EQ(0,
               memcmp(buffer_, data_ + static_cast<int>(position), read_size));
   }
 
   void ReadDataSourceMiss(int64 position, int size) {
-    EXPECT_TRUE(loader_.get() != NULL);
+    EXPECT_TRUE(loader_);
 
     InSequence s;
     // 1. Reply with a cache miss for the read.
     EXPECT_CALL(*loader_, Read(position, size, NotNull(), NotNull()))
         .WillOnce(DoAll(Assign(&error_, net::ERR_CACHE_MISS),
                         Invoke(this,
                                &BufferedDataSourceTest::InvokeReadCallback)));
 
     // 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)));
 
     EXPECT_CALL(*this, ReadCallback(size));
 
     data_source_->Read(
         position, size, buffer_,
         NewCallback(this, &BufferedDataSourceTest::ReadCallback));
     message_loop_->RunAllPending();
 
     // 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);
+    loader_ = new_loader;
   }
 
   void ReadDataSourceFailed(int64 position, int size, int error) {
-    EXPECT_TRUE(loader_.get() != NULL);
+    EXPECT_TRUE(loader_);
 
     InSequence s;
     // 1. Expect the read is delegated to the resource loader.
     EXPECT_CALL(*loader_, Read(position, size, NotNull(), NotNull()))
         .WillOnce(DoAll(Assign(&error_, error),
                         Invoke(this,
                                &BufferedDataSourceTest::InvokeReadCallback)));
 
     // 2. Host will then receive an error.
     EXPECT_CALL(*loader_, Stop());
@@ skipping 13 matching lines @@
     // 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);
+    loader_ = new_loader;
   }
 
   MOCK_METHOD1(ReadCallback, void(size_t size));
 
   scoped_ptr<StrictMock<MockMediaResourceLoaderBridgeFactory> >
       bridge_factory_;
-  scoped_ptr<StrictMock<MockBufferedResourceLoader> > loader_;
-  scoped_ptr<StrictMock<MockBufferedResourceLoader> > probe_loader_;
+  scoped_refptr<StrictMock<MockBufferedResourceLoader> > loader_;
+  scoped_refptr<StrictMock<MockBufferedResourceLoader> > probe_loader_;
   scoped_refptr<MockBufferedDataSource > data_source_;
   scoped_refptr<media::FilterFactory> factory_;
 
   StrictMock<media::MockFilterHost> host_;
   GURL gurl_;
   scoped_ptr<MessageLoop> message_loop_;
 
   int error_;
   uint8 buffer_[1024];
   uint8 data_[1024];
@@ skipping 57 matching lines @@
   StopDataSource();
 }
 
 TEST_F(BufferedDataSourceTest, ReadTimesOut) {
   InitializeDataSource(kHttpUrl, net::OK, net::OK, 1024);
   ReadDataSourceTimesOut(20, 10);
   StopDataSource();
 }
 
 }  // namespace webkit_glue