Fire CanPlayThrough immediately for local and streaming media files

media/base/pipeline_impl.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.
 //
 // TODO(scherkus): clean up PipelineImpl... too many crazy function names,
 // potential deadlocks, etc...
 
 #include "media/base/pipeline_impl.h"
 
 #include <algorithm>
@@ skipping 233 matching lines @@
   if (state_ == kEnded || elapsed > duration_) {
     return duration_;
   }
   return elapsed;
 }
 
 base::TimeDelta PipelineImpl::GetBufferedTime() {
   base::AutoLock auto_lock(lock_);
 
   // If media is fully loaded, then return duration.
-  if (loaded_ || total_bytes_ == buffered_bytes_) {
+  if (local_source_ || total_bytes_ == buffered_bytes_) {
     max_buffered_time_ = duration_;
     return duration_;
   }
 
   base::TimeDelta current_time = GetCurrentTime_Locked();
 
   // If buffered time was set, we report that value directly.
   if (buffered_time_.ToInternalValue() > 0)
     return std::max(buffered_time_, current_time);
 
@@ skipping 40 matching lines @@
   CHECK(out_size);
   base::AutoLock auto_lock(lock_);
   *out_size = natural_size_;
 }
 
 bool PipelineImpl::IsStreaming() const {
   base::AutoLock auto_lock(lock_);
   return streaming_;
 }
 
-bool PipelineImpl::IsLoaded() const {
+bool PipelineImpl::IsLocalSource() const {
   base::AutoLock auto_lock(lock_);
-  return loaded_;
+  return local_source_;
 }
 
 PipelineStatistics PipelineImpl::GetStatistics() const {
   base::AutoLock auto_lock(lock_);
   return statistics_;
 }
 
 void PipelineImpl::SetClockForTesting(Clock* clock) {
   clock_.reset(clock);
 }
@@ skipping 23 matching lines @@
   running_          = false;
   stop_pending_     = false;
   seek_pending_     = false;
   tearing_down_     = false;
   error_caused_teardown_ = false;
   playback_rate_change_pending_ = false;
   duration_         = kZero;
   buffered_time_    = kZero;
   buffered_bytes_   = 0;
   streaming_        = false;
-  loaded_           = false;
+  local_source_     = false;
   total_bytes_      = 0;
   natural_size_.SetSize(0, 0);
   volume_           = 1.0f;
   preload_          = AUTO;
   playback_rate_    = 0.0f;
   pending_playback_rate_ = 0.0f;
   status_           = PIPELINE_OK;
   has_audio_        = false;
   has_video_        = false;
   waiting_for_clock_update_ = false;
@@ skipping 168 matching lines @@
 
 void PipelineImpl::SetNaturalVideoSize(const gfx::Size& size) {
   DCHECK(IsRunning());
   media_log_->AddEvent(media_log_->CreateVideoSizeSetEvent(
       size.width(), size.height()));
 
   base::AutoLock auto_lock(lock_);
   natural_size_ = size;
 }
 
-void PipelineImpl::SetStreaming(bool streaming) {
-  DCHECK(IsRunning());
-  media_log_->AddEvent(
-      media_log_->CreateBooleanEvent(
-          MediaLogEvent::STREAMING_SET, "streaming", streaming));
-
-  base::AutoLock auto_lock(lock_);
-  streaming_ = streaming;
-}
-
 void PipelineImpl::NotifyEnded() {
   DCHECK(IsRunning());
   message_loop_->PostTask(FROM_HERE,
       base::Bind(&PipelineImpl::NotifyEndedTask, this));
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::ENDED));
 }
 
-void PipelineImpl::SetLoaded(bool loaded) {
-  DCHECK(IsRunning());
-  media_log_->AddEvent(
-      media_log_->CreateBooleanEvent(
-          MediaLogEvent::LOADED_SET, "loaded", loaded));
-
-  base::AutoLock auto_lock(lock_);
-  loaded_ = loaded;
-  download_rate_monitor_.set_loaded(loaded_);
-}
-
 void PipelineImpl::SetNetworkActivity(bool is_downloading_data) {
   DCHECK(IsRunning());
 
   NetworkEvent type = DOWNLOAD_PAUSED;
   if (is_downloading_data)
     type = DOWNLOAD_CONTINUED;
 
   {
     base::AutoLock auto_lock(lock_);
     download_rate_monitor_.SetNetworkActivity(is_downloading_data);
@@ skipping 449 matching lines @@
 
     base::AutoLock auto_lock(lock_);
     // We use audio stream to update the clock. So if there is such a stream,
     // we pause the clock until we receive a valid timestamp.
     waiting_for_clock_update_ = has_audio_;
     if (!waiting_for_clock_update_)
       clock_->Play();
 
     // Start monitoring rate of downloading.
     int bitrate = 0;
-    if (demuxer_.get())
+    if (demuxer_.get()) {
       bitrate = demuxer_->GetBitrate();
+      local_source_ = demuxer_->IsLocalSource();
+      streaming_ = !demuxer_->IsSeekable();
+    }
     // Needs to be locked because most other calls to |download_rate_monitor_|
     // occur on the renderer thread.
     download_rate_monitor_.Start(
-        base::Bind(&PipelineImpl::OnCanPlayThrough, this), bitrate);
+        base::Bind(&PipelineImpl::OnCanPlayThrough, this),
+        bitrate, streaming_, local_source_);
     download_rate_monitor_.SetBufferedBytes(buffered_bytes_, base::Time::Now());
 
     if (IsPipelineStopPending()) {
       // We had a pending stop request need to be honored right now.
       TearDownPipeline();
     }
   } else {
     NOTREACHED() << "Unexpected state: " << state_;
   }
 }
@@ skipping 368 matching lines @@
   message_loop_->PostTask(FROM_HERE,
       base::Bind(&PipelineImpl::NotifyCanPlayThrough, this));
 }
 
 void PipelineImpl::NotifyCanPlayThrough() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   NotifyNetworkEventTask(CAN_PLAY_THROUGH);
 }
 
 }  // namespace media