Fix a teardown hang caused by an Abort() call while there is a pending read.

webkit/glue/media/buffered_data_source.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 "webkit/glue/media/buffered_data_source.h"
 
 #include "media/base/filter_host.h"
 #include "net/base/net_errors.h"
 #include "webkit/glue/webkit_glue.h"
 
@@ skipping 119 matching lines @@
 void BufferedDataSource::SetPlaybackRate(float playback_rate) {
   render_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &BufferedDataSource::SetPlaybackRateTask,
                         playback_rate));
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // media::DataSource implementation.
 void BufferedDataSource::Read(int64 position, size_t size, uint8* data,
                               media::DataSource::ReadCallback* read_callback) {
+  DCHECK(read_callback);
+
+  {
+    base::AutoLock auto_lock(lock_);
+    DCHECK(!read_callback_.get());
+
+    if (stop_signal_received_ || stopped_on_render_loop_) {
+      read_callback->RunWithParams(
+          Tuple1<size_t>(static_cast<size_t>(media::DataSource::kReadError)));
+      delete read_callback;
+      return;
+    }
+
+    read_callback_.reset(read_callback);
+  }
+
   render_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &BufferedDataSource::ReadTask,
-                        position, static_cast<int>(size), data, read_callback));
+                        position, static_cast<int>(size), data));
 }
 
 bool BufferedDataSource::GetSize(int64* size_out) {
   if (total_bytes_ != kPositionNotSpecified) {
     *size_out = total_bytes_;
     return true;
   }
   *size_out = 0;
   return false;
 }
 
 bool BufferedDataSource::IsStreaming() {
   return streaming_;
 }
 
 bool BufferedDataSource::HasSingleOrigin() {
   DCHECK(MessageLoop::current() == render_loop_);
   return single_origin_;
 }
 
 void BufferedDataSource::Abort() {
   DCHECK(MessageLoop::current() == render_loop_);
 
-  // If we are told to abort, immediately return from any pending read
-  // with an error.
-  if (read_callback_.get()) {
-      base::AutoLock auto_lock(lock_);
+  {
+    base::AutoLock auto_lock(lock_);
+
+    // If we are told to abort, immediately return from any pending read
+    // with an error.
+    if (read_callback_.get())
       DoneRead_Locked(net::ERR_FAILED);
   }
 
   CleanupTask();
   frame_ = NULL;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // Render thread tasks.
 void BufferedDataSource::InitializeTask() {
@@ skipping 25 matching lines @@
     loader_ = CreateResourceLoader(kPositionNotSpecified,
                                    kPositionNotSpecified);
     loader_->Start(
         NewCallback(this, &BufferedDataSource::NonHttpInitialStartCallback),
         NewCallback(this, &BufferedDataSource::NetworkEventCallback),
         frame_);
   }
 }
 
 void BufferedDataSource::ReadTask(
-     int64 position, int read_size, uint8* buffer,
-     media::DataSource::ReadCallback* read_callback) {
+    int64 position,
+    int read_size,
+    uint8* buffer) {
   DCHECK(MessageLoop::current() == render_loop_);
-  if (stopped_on_render_loop_)
-    return;
+  {
+    base::AutoLock auto_lock(lock_);
+    if (stopped_on_render_loop_)
+      return;
 
-  DCHECK(!read_callback_.get());
-  DCHECK(read_callback);
+    DCHECK(read_callback_.get());
+  }
 
   // Saves the read parameters.
   read_position_ = position;
   read_size_ = read_size;
-  read_callback_.reset(read_callback);
   read_buffer_ = buffer;
   read_submitted_time_ = base::Time::Now();
   read_attempts_ = 0;
 
   // Call to read internal to perform the actual read.
   ReadInternal();
 }
 
 void BufferedDataSource::CleanupTask() {
   DCHECK(MessageLoop::current() == render_loop_);
-  if (stopped_on_render_loop_)
-    return;
+
+  {
+    base::AutoLock auto_lock(lock_);
+    if (stopped_on_render_loop_)
+      return;
+
+    read_callback_.reset();
+  }
 
   // Stop the watch dog.
   watch_dog_timer_.Stop();
 
   // We just need to stop the loader, so it stops activity.
   if (loader_.get())
     loader_->Stop();
 
   // Reset the parameters of the current read request.
-  read_callback_.reset();
   read_position_ = 0;
   read_size_ = 0;
   read_buffer_ = 0;
   read_submitted_time_ = base::Time();
   read_attempts_ = 0;
 
   // Signal that stop task has finished execution.
   stopped_on_render_loop_ = true;
 }
 
 void BufferedDataSource::RestartLoadingTask() {
   DCHECK(MessageLoop::current() == render_loop_);
   if (stopped_on_render_loop_)
     return;
 
-  // If there's no outstanding read then return early.
-  if (!read_callback_.get())
-    return;
+  {
+    // If there's no outstanding read then return early.
+    base::AutoLock auto_lock(lock_);
+    if (!read_callback_.get())
+      return;
+  }
 
   loader_ = CreateResourceLoader(read_position_, kPositionNotSpecified);
   loader_->SetAllowDefer(!media_is_paused_);
   loader_->Start(
       NewCallback(this, &BufferedDataSource::PartialReadStartCallback),
       NewCallback(this, &BufferedDataSource::NetworkEventCallback),
       frame_);
 }
 
 void BufferedDataSource::WatchDogTask() {
   DCHECK(MessageLoop::current() == render_loop_);
   if (stopped_on_render_loop_)
     return;
 
   // We only care if there is an active read request.
-  if (!read_callback_.get())
-    return;
+  {
+    base::AutoLock auto_lock(lock_);
+    if (!read_callback_.get())
+      return;
+  }
 
   DCHECK(loader_.get());
   base::TimeDelta delta = base::Time::Now() - read_submitted_time_;
   if (delta < GetTimeoutMilliseconds())
     return;
 
   // TODO(hclam): Maybe raise an error here. But if an error is reported
   // the whole pipeline may get destroyed...
   if (read_attempts_ >= kReadTrials)
     return;
@@ skipping 280 matching lines @@
     return;
 
   if (network_activity != network_activity_) {
     network_activity_ = network_activity;
     host()->SetNetworkActivity(network_activity);
   }
   host()->SetBufferedBytes(buffered_position + 1);
 }
 
 }  // namespace webkit_glue