Refcounting BufferedResourceLoader

webkit/glue/media/buffered_data_source.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 "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "chrome/common/extensions/url_pattern.h"
@@ skipping 104 matching lines @@
     offset_ = first_byte_position_;
   }
 
   // Creates the bridge on render thread since we can only access
   // ResourceDispatcher on this thread.
   bridge_.reset(bridge_factory_->CreateBridge(url_,
                                               net::LOAD_BYPASS_CACHE,
                                               first_byte_position_,
                                               last_byte_position_));
 
+  // Increment the reference count right before we start the request. This
+  // reference will be release when this request has ended.
+  AddRef();
+
   // And start the resource loading.
   bridge_->Start(this);
 }
 
 void BufferedResourceLoader::Stop() {
   // Reset callbacks.
   start_callback_.reset();
   read_callback_.reset();
 
   // Destroy internal buffer.
   buffer_.reset();
 
   if (bridge_.get()) {
-    // Cancel the resource request.
+    // Cancel the request. This method call will cancel the request
+    // asynchronously. We may still get data or messages until we receive
+    // a response completed message.
+    if (deferred_)
+      bridge_->SetDefersLoading(false);
+    deferred_ = false;
     bridge_->Cancel();
-    bridge_.reset();
   }
 }
 
 void BufferedResourceLoader::Read(int64 position,
                                   int read_size,
                                   uint8* buffer,
                                   net::CompletionCallback* read_callback) {
   DCHECK(!read_callback_.get());
   DCHECK(buffer_.get());
   DCHECK(read_callback);
@@ skipping 40 matching lines @@
   DoneRead(net::ERR_CACHE_MISS);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // BufferedResourceLoader,
 //     webkit_glue::ResourceLoaderBridge::Peer implementations
 bool BufferedResourceLoader::OnReceivedRedirect(
     const GURL& new_url,
     const webkit_glue::ResourceLoaderBridge::ResponseInfo& info) {
   DCHECK(bridge_.get());
-  DCHECK(start_callback_.get());
 
   // Saves the new URL.
   url_ = new_url;
 
+  // The load may have been stopped and |start_callback| is destroyed.
+  // In this case we shouldn't do anything.
+  if (!start_callback_.get())
+    return true;
+
   // If we got redirected to an unsupported protocol then stop.
   if (!IsSchemeSupported(new_url)) {
     DoneStart(net::ERR_ADDRESS_INVALID);
     Stop();
   }
 
   return true;
 }
 
 void BufferedResourceLoader::OnReceivedResponse(
     const webkit_glue::ResourceLoaderBridge::ResponseInfo& info,
     bool content_filtered) {
   DCHECK(bridge_.get());
-  DCHECK(start_callback_.get());
+
+  // The loader may have been stopped and |start_callback| is destroyed.
+  // In this case we shouldn't do anything.
+  if (!start_callback_.get())
+    return;
 
   int64 first_byte_position = -1;
   int64 last_byte_position = -1;
   int64 instance_size = -1;
 
   // The file:// protocol should be able to serve any request we want, so we
   // take an exception for file protocol.
   if (!url_.SchemeIsFile()) {
     int error = net::OK;
     if (!info.headers) {
@@ skipping 31 matching lines @@
   // here.
   if (first_byte_position != kPositionNotSpecified)
     offset_ = first_byte_position;
 
   // Calls with a successful response.
   DoneStart(net::OK);
 }
 
 void BufferedResourceLoader::OnReceivedData(const char* data, int len) {
   DCHECK(bridge_.get());
-  DCHECK(buffer_.get());
+
+  // If this loader has been stopped, |buffer_| would be destroyed.
+  // In this case we shouldn't do anything.
+  if (!buffer_.get())
+    return;
 
   // Writes more data to |buffer_|.
   buffer_->Append(len, reinterpret_cast<const uint8*>(data));
 
   // If there is an active read request, try to fulfill the request.
   if (HasPendingRead() && CanFulfillRead()) {
     ReadInternal();
   }
 
   // At last see if the buffer is full and we need to defer the downloading.
   EnableDeferIfNeeded();
 }
 
 void BufferedResourceLoader::OnCompletedRequest(
     const URLRequestStatus& status, const std::string& security_info) {
   DCHECK(bridge_.get());
-  DCHECK(buffer_.get());
 
   // Saves the information that the request has completed.
   completed_ = true;
 
-  // After the response has completed, we don't need the bridge any more.
-  bridge_.reset();
-
   // If there is a start callback, calls it.
   if (start_callback_.get()) {
     DoneStart(status.os_error());
   }
 
-  // If there is a pending read but the request has ended, returns with what we
-  // have.
+  // If there is a pending read but the request has ended, returns with what
+  // we have.
   if (HasPendingRead()) {
-    // If the request has failed, then fail the read.
-    if (!status.is_success()) {
+    // Make sure we have a valid buffer before we satisfy a read request.
+    DCHECK(buffer_.get());
+
+    if (status.is_success()) {
+      // Try to fulfill with what is in the buffer.
+      if (CanFulfillRead())
+        ReadInternal();
+      else
+        DoneRead(net::ERR_CACHE_MISS);
+    } else {
+      // If the request has failed, then fail the read.
       DoneRead(net::ERR_FAILED);
-      return;
     }
-
-    // Otherwise try to fulfill with what is in the buffer.
-    if (CanFulfillRead())
-      ReadInternal();
-    else
-      DoneRead(net::ERR_CACHE_MISS);
   }
 
   // There must not be any outstanding read request.
-  DCHECK(!read_callback_.get());
+  DCHECK(!HasPendingRead());
+
+  // We incremented the reference count when the loader was started. We balance
+  // that reference here so that we get destroyed. This is also the only safe
+  // place to destroy the ResourceLoaderBridge.
+  bridge_.reset();
+  Release();
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // BufferedResourceLoader, private
 void BufferedResourceLoader::EnableDeferIfNeeded() {
   if (!deferred_ &&
       buffer_->forward_bytes() >= buffer_->forward_capacity()) {
     deferred_ = true;
 
     if (bridge_.get())
@@ skipping 221 matching lines @@
       GetTimeoutMilliseconds() / 2,
       this,
       &BufferedDataSource::WatchDogTask);
 
   // Creates a new resource loader with the full range and a probe resource
   // loader. Creates a probe resource loader to make sure the server supports
   // partial range request.
   // TODO(hclam): Only request 1 byte for this probe request, it may be useful
   // that we perform a suffix range request and fetch the index. That way we
   // can minimize the number of requests made.
-  loader_.reset(CreateLoader(-1, -1));
-  probe_loader_.reset(CreateLoader(1, 1));
+  loader_ = CreateLoader(-1, -1);
+  probe_loader_ = CreateLoader(1, 1);
 
   loader_->Start(NewCallback(this, &BufferedDataSource::InitialStartCallback));
   probe_loader_->Start(
       NewCallback(this, &BufferedDataSource::ProbeStartCallback));
 }
 
 void BufferedDataSource::ReadTask(
      int64 position, int read_size, uint8* buffer,
      media::DataSource::ReadCallback* read_callback) {
   DCHECK(MessageLoop::current() == render_loop_);
@@ skipping 39 matching lines @@
   read_position_ = 0;
   read_size_ = 0;
   read_buffer_ = 0;
   read_submitted_time_ = base::Time();
   read_attempts_ = 0;
 
   // Signal that stop task has finished execution.
   stop_task_finished_ = true;
 }
 
-void BufferedDataSource::SwapLoaderTask(BufferedResourceLoader* loader) {
+void BufferedDataSource::SwapLoaderTask(
+    scoped_refptr<BufferedResourceLoader> loader) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader);
 
-  loader_.reset(loader);
+  loader_ = loader;
   loader_->Start(NewCallback(this,
                              &BufferedDataSource::PartialReadStartCallback));
 }
 
 void BufferedDataSource::WatchDogTask() {
   DCHECK(MessageLoop::current() == render_loop_);
 
   // We only care if there is an active read request.
   if (!read_callback_.get())
     return;
@@ skipping 200 matching lines @@
     render_loop_->PostTask(FROM_HERE,
         NewRunnableMethod(this, &BufferedDataSource::SwapLoaderTask,
                           CreateLoader(read_position_, -1)));
   } else {
     loader_->Stop();
     DoneRead(error);
   }
 }
 
 }  // namespace webkit_glue