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 35 matching lines @@
   base::AutoLock auto_lock(lock_);
   return total_bytes_;
 }
 
 void PipelineImpl::GetNaturalVideoSize(gfx::Size* out_size) const {
   CHECK(out_size);
   base::AutoLock auto_lock(lock_);
   *out_size = natural_size_;
 }
 
+void PipelineImpl::SetLocalSource(bool local_source) {
+  media_log_->AddEvent(
+      media_log_->CreateBooleanEvent(
+          MediaLogEvent::LOCAL_SOURCE_SET, "local_source", local_source));
+
+  base::AutoLock auto_lock(lock_);
+  local_source_ = local_source;
+  download_rate_monitor_.set_local_source(local_source_);
+}
+
 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 176 matching lines @@
 }
 
 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;
+  download_rate_monitor_.set_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) {
+void PipelineImpl::SetLocalSourceFromFilter(bool local_source) {
   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_);
+  SetLocalSource(local_source);
 }
 
 void PipelineImpl::SetNetworkActivity(bool is_downloading_data) {
   DCHECK(IsRunning());
 
   NetworkEvent type = DOWNLOAD_PAUSED;
   if (is_downloading_data)
     type = DOWNLOAD_CONTINUED;
 
   {
@@ skipping 845 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