Cleaned up threadiness of BufferedDataSource.

webkit/glue/media/buffered_data_source.cc

 // Copyright (c) 2011 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 "media/base/media_log.h"
 #include "net/base/net_errors.h"
 #include "webkit/glue/media/web_data_source_factory.h"
@@ skipping 67 matching lines @@
 
   return new BufferedResourceLoader(url_,
                                     first_byte_position,
                                     last_byte_position,
                                     media_log_);
 }
 
 void BufferedDataSource::set_host(media::FilterHost* host) {
   DataSource::set_host(host);
 
-  if (loader_.get())
-    UpdateHostState();
+  if (loader_.get()) {
+    base::AutoLock auto_lock(lock_);
+    UpdateHostState_Locked();
+  }
 }
 
 void BufferedDataSource::Initialize(const std::string& url,
                                     const media::PipelineStatusCB& callback) {
   // Saves the url.
   url_ = GURL(url);
 
   // This data source doesn't support data:// protocol so reject it.
   if (url_.SchemeIs(kDataScheme)) {
     callback.Run(media::DATASOURCE_ERROR_URL_NOT_SUPPORTED);
     return;
   } else if (!IsProtocolSupportedForMedia(url_)) {
     callback.Run(media::PIPELINE_ERROR_NETWORK);
     return;
   }
 
   DCHECK(!callback.is_null());
-  initialize_cb_ = callback;
+  {
+    base::AutoLock auto_lock(lock_);
+    initialize_cb_ = callback;
+  }
 
   // Post a task to complete the initialization task.
   render_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &BufferedDataSource::InitializeTask));
 }
 
 void BufferedDataSource::CancelInitialize() {
   base::AutoLock auto_lock(lock_);
   DCHECK(!initialize_cb_.is_null());
 
@@ skipping 85 matching lines @@
 
   CleanupTask();
   frame_ = NULL;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // Render thread tasks.
 void BufferedDataSource::InitializeTask() {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(!loader_.get());
-  if (stopped_on_render_loop_ || initialize_cb_.is_null())
-    return;
+
+  {
+    base::AutoLock auto_lock(lock_);
+    if (stopped_on_render_loop_ || initialize_cb_.is_null() ||
+        stop_signal_received_) {
+      return;
+    }
+  }
 
   if (url_.SchemeIs(kHttpScheme) || url_.SchemeIs(kHttpsScheme)) {
     // Do an unbounded range request starting at the beginning.  If the server
     // responds with 200 instead of 206 we'll fall back into a streaming mode.
     loader_ = CreateResourceLoader(0, kPositionNotSpecified);
     loader_->Start(
         NewCallback(this, &BufferedDataSource::HttpInitialStartCallback),
         NewCallback(this, &BufferedDataSource::NetworkEventCallback),
         frame_);
   } else {
@@ skipping 30 matching lines @@
 
   // Call to read internal to perform the actual read.
   ReadInternal();
 }
 
 void BufferedDataSource::CleanupTask() {
   DCHECK(MessageLoop::current() == render_loop_);
 
   {
     base::AutoLock auto_lock(lock_);
+    initialize_cb_.Reset();
     if (stopped_on_render_loop_)
       return;
 
     // Signal that stop task has finished execution.
     // NOTE: it's vital that this be set under lock, as that's how Read() tests
     // before registering a new |read_callback_| (which is cleared below).
     stopped_on_render_loop_ = true;
 
     if (read_callback_.get())
       DoneRead_Locked(net::ERR_FAILED);
@@ skipping 52 matching lines @@
 }
 
 void BufferedDataSource::SetBitrateTask(int bitrate) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
   loader_->SetBitrate(bitrate);
 }
 
 BufferedResourceLoader::DeferStrategy
 BufferedDataSource::ChooseDeferStrategy() {
+  DCHECK(MessageLoop::current() == render_loop_);
   // If the user indicates preload=metadata, then just load exactly
   // what is needed for starting the pipeline and prerolling frames.
   if (preload_ == media::METADATA && !media_has_played_)
     return BufferedResourceLoader::kReadThenDefer;
 
   // In general, we want to try to buffer the entire video when the video
   // is paused. But we don't want to do this if the video hasn't played yet
   // and preload!=auto.
   if (media_is_paused_ &&
       (preload_ == media::AUTO || media_has_played_)) {
@@ skipping 57 matching lines @@
 
 /////////////////////////////////////////////////////////////////////////////
 // BufferedResourceLoader callback methods.
 void BufferedDataSource::HttpInitialStartCallback(int error) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
   int64 instance_size = loader_->instance_size();
   bool success = error == net::OK;
 
-  if (initialize_cb_.is_null()) {
+
+  bool initialize_cb_is_null = false;
+  {
+    base::AutoLock auto_lock(lock_);
+    initialize_cb_is_null = initialize_cb_.is_null();
+  }
+  if (initialize_cb_is_null) {
     loader_->Stop();
     return;
   }
 
   if (success) {
     // TODO(hclam): Needs more thinking about supporting servers without range
     // request or their partial response is not complete.
     total_bytes_ = instance_size;
     loaded_ = false;
     streaming_ = (instance_size == kPositionNotSpecified) ||
@@ skipping 33 matching lines @@
     // safe because |lock_| is only acquired in tasks on render thread.
     base::AutoLock auto_lock(lock_);
     if (stop_signal_received_)
       return;
 
     if (!success) {
       DoneInitialization_Locked(media::PIPELINE_ERROR_NETWORK);
       return;
     }
 
-    UpdateHostState();
+    UpdateHostState_Locked();
     DoneInitialization_Locked(media::PIPELINE_OK);
   }
 }
 
 void BufferedDataSource::NonHttpInitialStartCallback(int error) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
-  if (initialize_cb_.is_null()) {
+  bool initialize_cb_is_null = false;
+  {
+    base::AutoLock auto_lock(lock_);
+    initialize_cb_is_null = initialize_cb_.is_null();
+  }
+  if (initialize_cb_is_null) {
     loader_->Stop();
     return;
   }
 
   int64 instance_size = loader_->instance_size();
   bool success = error == net::OK && instance_size != kPositionNotSpecified;
 
   if (success) {
     total_bytes_ = instance_size;
     buffered_bytes_ = total_bytes_;
@@ skipping 19 matching lines @@
     // safe because |lock_| is only acquired in tasks on render thread.
     base::AutoLock auto_lock(lock_);
     if (stop_signal_received_ || initialize_cb_.is_null())
       return;
 
     if (!success) {
       DoneInitialization_Locked(media::PIPELINE_ERROR_NETWORK);
       return;
     }
 
-    UpdateHostState();
+    UpdateHostState_Locked();
     DoneInitialization_Locked(media::PIPELINE_OK);
   }
 }
 
 void BufferedDataSource::PartialReadStartCallback(int error) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
   if (error == net::OK) {
     // Once the request has started successfully, we can proceed with
@@ skipping 96 matching lines @@
     network_activity_ = network_activity;
     if (host())
       host()->SetNetworkActivity(network_activity);
   }
 
   buffered_bytes_ = buffered_position + 1;
   if (host())
     host()->SetBufferedBytes(buffered_bytes_);
 }
 
-void BufferedDataSource::UpdateHostState() {
+void BufferedDataSource::UpdateHostState_Locked() {
+  // Called from various threads, under lock.
+  lock_.AssertAcquired();
+
   media::FilterHost* filter_host = host();
   if (!filter_host)
     return;
 
   filter_host->SetLoaded(loaded_);
 
   if (streaming_) {
     filter_host->SetStreaming(true);
   } else {
     filter_host->SetTotalBytes(total_bytes_);
     filter_host->SetBufferedBytes(buffered_bytes_);
   }
 }
 
 }  // namespace webkit_glue