Report stalled event correctly for <video>

media/base/pipeline_impl.cc

 // Copyright (c) 2008-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.
 //
 // TODO(scherkus): clean up PipelineImpl... too many crazy function names,
 // potential deadlocks, etc...
 
 #include "base/compiler_specific.h"
 #include "base/condition_variable.h"
 #include "base/stl_util-inl.h"
@@ skipping 139 matching lines @@
     case kSeeking:
     case kStarting:
     case kStarted:
     case kEnded:
       return true;
     default:
       return false;
   }
 }
 
+bool PipelineImpl::IsNetworkActive() const {
+  AutoLock auto_lock(lock_);
+  return network_activity_;
+}
+
 bool PipelineImpl::IsRendered(const std::string& major_mime_type) const {
   AutoLock auto_lock(lock_);
   bool is_rendered = (rendered_mime_types_.find(major_mime_type) !=
                       rendered_mime_types_.end());
   return is_rendered;
 }
 
 float PipelineImpl::GetPlaybackRate() const {
   AutoLock auto_lock(lock_);
   return playback_rate_;
@@ skipping 107 matching lines @@
       << "Permanent callbacks should be set before the pipeline has started";
   ended_callback_.reset(ended_callback);
 }
 
 void PipelineImpl::SetPipelineErrorCallback(PipelineCallback* error_callback) {
   DCHECK(!IsRunning())
       << "Permanent callbacks should be set before the pipeline has started";
   error_callback_.reset(error_callback);
 }
 
+void PipelineImpl::SetNetworkEventCallback(PipelineCallback* network_callback) {
+  DCHECK(!IsRunning())
+      << "Permanent callbacks should be set before the pipeline has started";
+  network_callback_.reset(network_callback);
+}
+
 void PipelineImpl::ResetState() {
   AutoLock auto_lock(lock_);
   const base::TimeDelta kZero;
   running_          = false;
   duration_         = kZero;
   buffered_time_    = kZero;
   buffered_bytes_   = 0;
   streaming_        = false;
   loaded_           = false;
   total_bytes_      = 0;
@@ skipping 113 matching lines @@
   message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &PipelineImpl::NotifyEndedTask));
 }
 
 void PipelineImpl::SetLoaded(bool loaded) {
   DCHECK(IsRunning());
   AutoLock auto_lock(lock_);
   loaded_ = loaded;
 }
 
+void PipelineImpl::SetNetworkActivity(bool network_activity) {
+  DCHECK(IsRunning());
+  {
+    AutoLock auto_lock(lock_);
+    network_activity_ = network_activity;
+  }
+  message_loop_->PostTask(FROM_HERE,
+      NewRunnableMethod(this, &PipelineImpl::NotifyNetworkEventTask));
+}
+
 void PipelineImpl::BroadcastMessage(FilterMessage message) {
   DCHECK(IsRunning());
 
   // Broadcast the message on the message loop.
   message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &PipelineImpl::BroadcastMessageTask,
                         message));
 }
 
 void PipelineImpl::InsertRenderedMimeType(const std::string& major_mime_type) {
@@ skipping 281 matching lines @@
     return;
   }
 
   // Transition to ended, executing the callback if present.
   state_ = kEnded;
   if (ended_callback_.get()) {
     ended_callback_->Run();
   }
 }
 
+void PipelineImpl::NotifyNetworkEventTask() {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  if (network_callback_.get()) {
+    network_callback_->Run();
+  }
+}
+
 void PipelineImpl::BroadcastMessageTask(FilterMessage message) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   // TODO(kylep): This is a horribly ugly hack, but we have no better way to
   // log that audio is not and will not be working.
   if (message == media::kMsgDisableAudio) {
     // |rendered_mime_types_| is read through public methods so we need to lock
     // this variable.
     AutoLock auto_lock(lock_);
     rendered_mime_types_.erase(mime_type::kMajorTypeAudio);
@@ skipping 230 matching lines @@
 
   // Reset the pipeline, which will decrement a reference to this object.
   // We will get destroyed as soon as the remaining tasks finish executing.
   // To be safe, we'll set our pipeline reference to NULL.
   filters_.clear();
   filter_types_.clear();
   STLDeleteElements(&filter_threads_);
 }
 
 }  // namespace media