Use stopped_on_render_loop_ to prevent further work from executing in BufferedDataSource.

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 "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/stl_util-inl.h"
@@ skipping 720 matching lines @@
   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()) {
-      AutoLock auto_lock(lock_);
-      DoneRead_Locked(net::ERR_FAILED);
+    AutoLock auto_lock(lock_);
+    DoneRead_Locked(net::ERR_FAILED);
   }
 
   CleanupTask();
   frame_ = NULL;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // BufferedDataSource, render thread tasks
 void BufferedDataSource::InitializeTask() {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(!loader_.get());
-  DCHECK(!stopped_on_render_loop_);
+  if (stopped_on_render_loop_)
+    return;
 
   // Kick starts the watch dog task that will handle connection timeout.
   // We run the watch dog 2 times faster the actual timeout so as to catch
   // the timeout more accurately.
   watch_dog_timer_.Start(
       GetTimeoutMilliseconds() / 2,
       this,
       &BufferedDataSource::WatchDogTask);
 
   if (IsHttpProtocol(url_)) {
@@ skipping 16 matching lines @@
         NewCallback(this, &BufferedDataSource::NonHttpInitialStartCallback),
         NewCallback(this, &BufferedDataSource::NetworkEventCallback),
         frame_);
   }
 }
 
 void BufferedDataSource::ReadTask(
      int64 position, int read_size, uint8* buffer,
      media::DataSource::ReadCallback* read_callback) {
   DCHECK(MessageLoop::current() == render_loop_);
-
-  // If CleanupTask() was executed we should return immediately. We check this
-  // variable to prevent doing any actual work after clean up was done. We do
-  // not check |stop_signal_received_| because anything use of it has to be
-  // within |lock_| which is not desirable.
   if (stopped_on_render_loop_)
     return;
 
   DCHECK(!read_callback_.get());
   DCHECK(read_callback);
 
   // 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 we have already stopped, do nothing.
   if (stopped_on_render_loop_)
     return;
 
   // 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_);
-
-  // This variable is set in CleanupTask(). We check this and do an early
-  // return. The sequence of actions which enable this conditions is:
-  // 1. Stop() is called from the pipeline.
-  // 2. ReadCallback() is called from the resource loader.
-  // 3. CleanupTask() is executed.
-  // 4. RestartLoadingTask() is executed.
   if (stopped_on_render_loop_)
     return;
 
   // If there's no outstanding read then return early.
   if (!read_callback_.get())
     return;
 
   loader_ = CreateResourceLoader(read_position_, -1);
   loader_->SetAllowDefer(!media_is_paused_);
   loader_->Start(
       NewCallback(this, &BufferedDataSource::PartialReadStartCallback),
       NewCallback(this, &BufferedDataSource::NetworkEventCallback),
       frame_);
 }
 
 void BufferedDataSource::WatchDogTask() {
   DCHECK(MessageLoop::current() == render_loop_);
-  DCHECK(!stopped_on_render_loop_);
+  if (stopped_on_render_loop_)
+    return;
 
   // We only care if there is an active read request.
   if (!read_callback_.get())
     return;
 
   DCHECK(loader_.get());
   base::TimeDelta delta = base::Time::Now() - read_submitted_time_;
   if (delta < GetTimeoutMilliseconds())
     return;
 
@@ skipping 285 matching lines @@
     return;
 
   if (network_activity != network_activity_) {
     network_activity_ = network_activity;
     host()->SetNetworkActivity(network_activity);
   }
   host()->SetBufferedBytes(buffered_last_byte_position + 1);
 }
 
 }  // namespace webkit_glue