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 39 matching lines @@
 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;
   }
+  local_source_ = !url_.SchemeIs(kHttpScheme) && !url_.SchemeIs(kHttpsScheme);
 
   DCHECK(!callback.is_null());
   {
     base::AutoLock auto_lock(lock_);
     initialize_cb_ = callback;
   }
 
   // Post a task to complete the initialization task.
   render_loop_->PostTask(FROM_HERE,
       base::Bind(&BufferedDataSource::InitializeTask, this));
@@ skipping 31 matching lines @@
 void BufferedDataSource::SetPreload(media::Preload preload) {
   render_loop_->PostTask(FROM_HERE, base::Bind(
       &BufferedDataSource::SetPreloadTask, this, preload));
 }
 
 void BufferedDataSource::SetBitrate(int bitrate) {
   render_loop_->PostTask(FROM_HERE, base::Bind(
       &BufferedDataSource::SetBitrateTask, this, bitrate));
 }
 
+bool BufferedDataSource::IsLocalSource() {
+  return local_source_;
+}
+
 /////////////////////////////////////////////////////////////////////////////
 // media::DataSource implementation.
 void BufferedDataSource::Read(
     int64 position, size_t size, uint8* data,
     const media::DataSource::ReadCallback& read_callback) {
   VLOG(1) << "Read: " << position << " offset, " << size << " bytes";
   DCHECK(!read_callback.is_null());
 
   {
     base::AutoLock auto_lock(lock_);
@@ skipping 255 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;
     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;
   } 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_);
-
   if (streaming_)
     filter_host->SetStreaming(true);
 
   if (total_bytes_ != kPositionNotSpecified)
     filter_host->SetTotalBytes(total_bytes_);
   filter_host->SetBufferedBytes(buffered_bytes_);
 }
 
 }  // namespace webkit_media