Fire CanPlayThrough immediately for local and streaming media files

webkit/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/media/buffered_data_source.h"
 
 #include "base/bind.h"
 #include "media/base/filter_host.h"
 #include "media/base/media_log.h"
 #include "net/base/net_errors.h"
@@ skipping 27 matching lines @@
   return new WebDataSourceFactory(render_loop, frame, media_log,
                                   &NewBufferedDataSource, build_observer);
 }
 
 BufferedDataSource::BufferedDataSource(
     MessageLoop* render_loop,
     WebFrame* frame,
     media::MediaLog* media_log)
     : total_bytes_(kPositionNotSpecified),
       buffered_bytes_(0),
-      loaded_(false),
+      local_source_(false),
       streaming_(false),
       frame_(frame),
       loader_(NULL),
       is_downloading_data_(false),
       read_position_(0),
       read_size_(0),
       read_buffer_(NULL),
       intermediate_read_buffer_(new uint8[kInitialReadBufferSize]),
       intermediate_read_buffer_size_(kInitialReadBufferSize),
       render_loop_(render_loop),
@@ skipping 365 matching lines @@
   }
   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;
+    local_source_ = false;
     streaming_ = (instance_size == kPositionNotSpecified) ||
         !loader_->range_supported();
   } else {
     // TODO(hclam): In case of failure, we can retry several times.
     loader_->Stop();
   }
 
   if (error == net::ERR_INVALID_RESPONSE && using_range_request_) {
     // Assuming that the Range header was causing the problem. Retry without
     // the Range header.
@@ skipping 49 matching lines @@
     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_;
-    loaded_ = true;
+    local_source_ = true;
   } else {
     loader_->Stop();
   }
 
   // Reference to prevent destruction while inside the |initialize_cb_|
   // call. This is a temporary fix to prevent crashes caused by holding the
   // lock and running the destructor.
   // TODO: Review locking in this class and figure out a way to run the callback
   //       w/o the lock.
   scoped_refptr<BufferedDataSource> destruction_guard(this);
@@ skipping 94 matching lines @@
   }
   DoneRead_Locked(error);
 }
 
 void BufferedDataSource::NetworkEventCallback() {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
   // In case of non-HTTP request we don't need to report network events,
   // so return immediately.
-  if (loaded_)
+  if (local_source_)
     return;
 
   bool is_downloading_data = loader_->is_downloading_data();
   int64 buffered_position = loader_->GetBufferedPosition();
 
   // If we get an unspecified value, return immediately.
   if (buffered_position == kPositionNotSpecified)
     return;
 
   // We need to prevent calling to filter host and running the callback if
@@ skipping 20 matching lines @@
 }
 
 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_);
+  filter_host->SetLocalSourceFromFilter(local_source_);
 
   if (streaming_)
     filter_host->SetStreaming(true);
 
   if (total_bytes_ != kPositionNotSpecified)
     filter_host->SetTotalBytes(total_bytes_);
   filter_host->SetBufferedBytes(buffered_bytes_);
 }
 
 }  // namespace webkit_media