Fold RestartLoadingTask() into ReadCallback() as the method is called on the render thread.

webkit/media/buffered_data_source.cc

 // Copyright (c) 2012 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/media/buffered_data_source.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "media/base/media_log.h"
 #include "net/base/net_errors.h"
@@ skipping 222 matching lines @@
 
   // 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_size_ = 0;
   read_buffer_ = 0;
 }
 
-void BufferedDataSource::RestartLoadingTask() {
-  DCHECK(MessageLoop::current() == render_loop_);
-  if (stopped_on_render_loop_)
-    return;
-
-  {
-    // If there's no outstanding read then return early.
-    base::AutoLock auto_lock(lock_);
-    if (read_cb_.is_null())
-      return;
-  }
-
-  // Start reading from where we last left off until the end of the resource.
-  loader_.reset(CreateResourceLoader(last_read_start_, kPositionNotSpecified));
-  loader_->Start(
-      base::Bind(&BufferedDataSource::PartialReadStartCallback, this),
-      base::Bind(&BufferedDataSource::LoadingCallback, this),
-      base::Bind(&BufferedDataSource::ProgressCallback, this),
-      frame_);
-}
-
 void BufferedDataSource::SetPlaybackRateTask(float playback_rate) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
   if (playback_rate != 0)
     media_has_played_ = true;
 
   playback_rate_ = playback_rate;
   loader_->SetPlaybackRate(playback_rate);
 
@@ skipping 152 matching lines @@
     int bytes_read) {
   DCHECK(MessageLoop::current() == render_loop_);
 
   if (status != BufferedResourceLoader::kOk) {
     // Stop the resource load if it failed.
     loader_->Stop();
 
     if (status == BufferedResourceLoader::kCacheMiss &&
         cache_miss_retries_left_ > 0) {
       cache_miss_retries_left_--;
-      render_loop_->PostTask(FROM_HERE,
-          base::Bind(&BufferedDataSource::RestartLoadingTask, this));
+
+      // Recreate a loader starting from where we last left off until the

[Ami GONE FROM CHROMIUM, 2012/07/10 02:48:25]

Why is it no longer necessary to test stopped_on_render_loop_?

[scherkus (not reviewing), 2012/07/10 03:15:16]

Previously the only way that could happen is if CleanupTask() was called before
RestartLoadingTask() was executed.

The only way that could have happened was if WebMediaPlayerImpl::Destroy() was
triggered due to ~WMPI() or the render thread going away.

Since we're on the render thread when we notice a cache miss it's impossible for
us to be stopped so we kick off the read anyway. If CleanupTask() were to
execute immediately after we yield back to the render thread we'd simply stop
the load again via loader_->Stop();

+      // end of the resource.
+      loader_.reset(CreateResourceLoader(
+          last_read_start_, kPositionNotSpecified));
+      loader_->Start(
+          base::Bind(&BufferedDataSource::PartialReadStartCallback, this),
+          base::Bind(&BufferedDataSource::LoadingCallback, this),
+          base::Bind(&BufferedDataSource::ProgressCallback, this),
+          frame_);
       return;
     }
 
     // Fall through to signal a read error.
     bytes_read = kReadError;
   }
 
   // TODO(scherkus): we shouldn't have to lock to signal host(), see
   // http://crbug.com/113712 for details.
   base::AutoLock auto_lock(lock_);
@@ skipping 80 matching lines @@
   if (!host())
     return;
 
   if (total_bytes_ != kPositionNotSpecified)
     host()->SetTotalBytes(total_bytes_);
   if (buffered_bytes_ > last_read_start_)
     host()->AddBufferedByteRange(last_read_start_, buffered_bytes_);
 }
 
 }  // namespace webkit_media