BufferedDataSource to support server without range request support...

webkit/glue/media/buffered_data_source.cc

 // Copyright (c) 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.
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "chrome/common/extensions/url_pattern.h"
@@ skipping 14 matching lines @@
 
 // Define the number of bytes in a megabyte.
 const size_t kMegabyte = 1024 * 1024;
 
 // Backward capacity of the buffer, by default 2MB.
 const size_t kBackwardCapcity = 2 * kMegabyte;
 
 // Forward capacity of the buffer, by default 10MB.
 const size_t kForwardCapacity = 10 * kMegabyte;
 
-// The maximum offset to seek to, this value limits the range of seek to
-// prevent corruption of calculations. The buffer has a maximum size of 12MB
-// so this is enough to contain every valid operations.
-const int kMaxSeek = 100 * kMegabyte;
-
 // The threshold of bytes that we should wait until the data arrives in the
 // future instead of restarting a new connection. This number is defined in the
 // number of bytes, we should determine this value from typical connection speed
 // and amount of time for a suitable wait. Now I just make a guess for this
 // number to be 2MB.
 // TODO(hclam): determine a better value for this.
 const int kForwardWaitThreshold = 2 * kMegabyte;
 
 // Defines how long we should wait for more data before we declare a connection
 // timeout and start a new request.
 // TODO(hclam): Use this value when retry is implemented.
 // TODO(hclam): Set it to 5s, calibrate this value later.
 const int kDataTransferTimeoutSeconds = 5;
 
 // Defines how many times we should try to read from a buffered resource loader
 // before we declare a read error. After each failure of read from a buffered
 // resource loader, a new one is created to be read.
 // TODO(hclam): Use this value when retry is implemented.
 const int kReadTrials = 3;
 
 // BufferedDataSource has an intermediate buffer, this value governs the initial
 // size of that buffer. It is set to 32KB because this is a typical read size
 // of FFmpeg.
 const int kInitialReadBufferSize = 32768;
 
 // A helper method that accepts only HTTP, HTTPS and FILE protocol.
+// TODO(hclam): Support also FTP protocol.
 bool IsSchemeSupported(const GURL& url) {
   return url.SchemeIs(kHttpScheme) ||
          url.SchemeIs(kHttpsScheme) ||
          url.SchemeIsFile();
 }
 
 }  // namespace
 
 namespace webkit_glue {
 
 /////////////////////////////////////////////////////////////////////////////
 // BufferedResourceLoader
 BufferedResourceLoader::BufferedResourceLoader(
     webkit_glue::MediaResourceLoaderBridgeFactory* bridge_factory,
     const GURL& url,
     int64 first_byte_position,
     int64 last_byte_position)
     : buffer_(new media::SeekableBuffer(kBackwardCapcity, kForwardCapacity)),
       deferred_(false),
       completed_(false),
       range_requested_(false),
       bridge_factory_(bridge_factory),
       url_(url),
       first_byte_position_(first_byte_position),
       last_byte_position_(last_byte_position),
       start_callback_(NULL),
       bridge_(NULL),
       offset_(0),
       content_length_(kPositionNotSpecified),
+      instance_size_(kPositionNotSpecified),
       read_callback_(NULL),
       read_position_(0),
       read_size_(0),
       read_buffer_(NULL),
       first_offset_(0),
       last_offset_(0) {
 }
 
 BufferedResourceLoader::~BufferedResourceLoader() {
 }
@@ skipping 47 matching lines @@
   DCHECK(buffer_.get());
   DCHECK(read_callback);
   DCHECK(buffer);
 
   // Saves the parameter of reading.
   read_callback_.reset(read_callback);
   read_position_ = position;
   read_size_ = read_size;
   read_buffer_ = buffer;
 
-  // Check that the read parameters are within the range that we can handle.
-  // If the read request is made too far from the current offset, report that
-  // we cannot serve the request.
-  if (VerifyRead()) {
-    // If we can serve the request now, do the actual read.
-    if (CanFulfillRead()) {
-      ReadInternal();
-      DisableDeferIfNeeded();
-      return;
-    }
+  // If read position is beyond the instance size, we cannot read there.
+  if (instance_size_ != kPositionNotSpecified &&
+      instance_size_ <= read_position_) {
+    DoneRead(0);
+    return;
+  }
 
-    // If we expected the read request to be fulfilled later, returns
-    // immediately and let more data to flow in.
-    if (WillFulfillRead())
-      return;
-
-    // Make a callback to report failure.
+  // Make sure |offset_| and |read_position_| does not differ by a large
+  // amount.
+  if (read_position_ > offset_ + kint32max ||
+      read_position_ < offset_ + kint32min) {
     DoneRead(net::ERR_CACHE_MISS);
     return;
   }
 
-  // TODO(hclam): We should report a better error code than just 0.
-  DoneRead(0);
+  // Prepare the parameters.
+  first_offset_ = static_cast<int>(read_position_ - offset_);
+  last_offset_ = first_offset_ + read_size_;
+
+  // If we can serve the request now, do the actual read.
+  if (CanFulfillRead()) {
+    ReadInternal();
+    DisableDeferIfNeeded();
+    return;
+  }
+
+  // If we expected the read request to be fulfilled later, returns
+  // immediately and let more data to flow in.
+  if (WillFulfillRead())
+    return;
+
+  // Make a callback to report failure.
+  DoneRead(net::ERR_CACHE_MISS);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // BufferedResourceLoader,
 //     webkit_glue::ResourceLoaderBridge::Peer implementations
 void BufferedResourceLoader::OnReceivedRedirect(const GURL& new_url) {
   DCHECK(bridge_.get());
   DCHECK(start_callback_.get());
 
   // Saves the new URL.
@@ skipping 18 matching lines @@
 
   // The file:// protocol should be able to serve any request we want, so we
   // take an exception for file protocol.
   if (!url_.SchemeIsFile()) {
     int error = net::OK;
     if (!info.headers) {
       // We expect to receive headers because this is a HTTP or HTTPS protocol,
       // if not report failure.
       error = net::ERR_INVALID_RESPONSE;
     } else if (range_requested_) {
-      if (info.headers->response_code() != kHttpPartialContent ||
-          !info.headers->GetContentRange(&first_byte_position,
-                                         &last_byte_position,
-                                          &instance_size)) {
-        // We requested a range, but server didn't reply with partial content or
-        // the "Content-Range" header is corrupted.
-        // TODO(hclam): should also make sure this is the range we requested.
-        error = net::ERR_INVALID_RESPONSE;
-      }
+      // If we have verified the partial response and it is correct, we will
+      // return net::OK.
+      if (!VerifyPartialResponse(info))
+        error = net::ERR_REQUEST_RANGE_NOT_SATISFIABLE;
     } else if (info.headers->response_code() != kHttpOK) {
       // We didn't request a range but server didn't reply with "200 OK".
       error = net::ERR_FAILED;
     }
 
     if (error != net::OK) {
       DoneStart(error);
       Stop();
       return;
     }
   }
 
   // |info.content_length| can be -1, in that case |content_length_| is
   // not specified and this is a streaming response.
   content_length_ = info.content_length;
 
+  // If we have not requested a range, then the size of the instance is equal
+  // to the content length.
+  if (!range_requested_)
+    instance_size_ = content_length_;
+
   // We only care about the first byte position if it's given by the server.
   // TODO(hclam): If server replies with a different offset, consider failing
   // here.
   if (first_byte_position != kPositionNotSpecified)
     offset_ = first_byte_position;
 
   // Calls with a successful response.
   DoneStart(net::OK);
 }
 
@@ skipping 105 matching lines @@
     return false;
 
   // The resource request has completed, there's no way we can fulfill the
   // read request.
   if (completed_)
     return false;
 
   return true;
 }
 
-bool BufferedResourceLoader::VerifyRead() {
-  // Make sure |offset_| and |read_position_| does not differ by a large
-  // amount
-  if (read_position_ > offset_ + kMaxSeek)
-    return false;
-  else if (read_position_ < offset_ - kMaxSeek)
-    return false;
-
-  // If we can manage the read request with int32 math, then prepare the
-  // parameters.
-  first_offset_ = static_cast<int>(read_position_ - offset_);
-  last_offset_ = first_offset_ + read_size_;
-  return true;
-}
-
 void BufferedResourceLoader::ReadInternal() {
   // Seek to the first byte requested.
   bool ret = buffer_->Seek(first_offset_);
   DCHECK(ret);
 
   // Then do the read.
   int read = static_cast<int>(buffer_->Read(read_size_, read_buffer_));
   offset_ += first_offset_ + read;
 
   // And report with what we have read.
   DoneRead(read);
 }
 
 void BufferedResourceLoader::DoneRead(int error) {
   read_callback_->RunWithParams(Tuple1<int>(error));
   read_callback_.reset();
   read_position_ = 0;
   read_size_ = 0;
   read_buffer_ = NULL;
   first_offset_ = 0;
   last_offset_ = 0;
 }
 
 void BufferedResourceLoader::DoneStart(int error) {
   start_callback_->RunWithParams(Tuple1<int>(error));
   start_callback_.reset();
 }
 
+bool BufferedResourceLoader::VerifyPartialResponse(
+    const ResourceLoaderBridge::ResponseInfo& info) {
+  if (info.headers->response_code() != kHttpPartialContent)
+    return false;
+
+  int64 first_byte_position, last_byte_position, instance_size;
+  if (!info.headers->GetContentRange(&first_byte_position,
+                                     &last_byte_position,
+                                     &instance_size)) {
+    return false;
+  }
+
+  if (instance_size != kPositionNotSpecified)
+    instance_size_ = instance_size;
+
+  if (first_byte_position_ != -1 &&
+      first_byte_position_ != first_byte_position) {
+    return false;
+  }
+
+  // TODO(hclam): I should also check |last_byte_position|, but since
+  // we will never make such a request that it is ok to leave it unimplemented.
+  return true;
+}
+
 //////////////////////////////////////////////////////////////////////////////
 // BufferedDataSource, protected
 BufferedDataSource::BufferedDataSource(
     MessageLoop* render_loop,
     webkit_glue::MediaResourceLoaderBridgeFactory* bridge_factory)
     : total_bytes_(kPositionNotSpecified),
+      streaming_(false),
       bridge_factory_(bridge_factory),
       loader_(NULL),
+      initialize_callback_(NULL),
       read_callback_(NULL),
       read_position_(0),
       read_size_(0),
       read_buffer_(NULL),
+      initial_response_received_(false),
+      probe_response_received_(false),
       intermediate_read_buffer_(new uint8[kInitialReadBufferSize]),
       intermediate_read_buffer_size_(kInitialReadBufferSize),
       render_loop_(render_loop),
-      initialize_callback_(NULL),
       stopped_(false) {
 }
 
 BufferedDataSource::~BufferedDataSource() {
 }
 
 // A factory method to create BufferedResourceLoader using the read parameters.
 // This method can be overrided to inject mock BufferedResourceLoader object
 // for testing purpose.
 BufferedResourceLoader* BufferedDataSource::CreateLoader(
@@ skipping 51 matching lines @@
 
 bool BufferedDataSource::GetSize(int64* size_out) {
   if (total_bytes_ != kPositionNotSpecified) {
     *size_out = total_bytes_;
     return true;
   }
   *size_out = 0;
   return false;
 }
 
-bool BufferedDataSource::IsSeekable() {
-  return total_bytes_ != kPositionNotSpecified;
+bool BufferedDataSource::IsStreaming() {
+  return streaming_;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // BufferedDataSource, render thread tasks
 void BufferedDataSource::InitializeTask() {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(!loader_.get());
+  DCHECK(!probe_loader_.get());
 
-  // Creates a new resource loader with the full range.
+  // Creates a new resource loader with the full range and a probe resource
+  // loader. Creates a probe resource loader to make sure the server supports
+  // partial range request.
+  // TODO(hclam): Only request 1 byte for this probe request, it may be useful
+  // that we perform a suffix range request and fetch the index. That way we
+  // can minimize the number of requests made.
   loader_.reset(CreateLoader(-1, -1));
+  probe_loader_.reset(CreateLoader(1, 1));
 
-  // And then start the resource request.
-  loader_->Start(NewCallback(this,
-                             &BufferedDataSource::InitializeStartCallback));
+  loader_->Start(NewCallback(this, &BufferedDataSource::InitialStartCallback));
+  probe_loader_->Start(
+      NewCallback(this, &BufferedDataSource::ProbeStartCallback));
 }
 
 void BufferedDataSource::ReadTask(
      int64 position, int read_size, uint8* buffer,
      media::DataSource::ReadCallback* read_callback) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(!read_callback_.get());
   DCHECK(read_callback);
 
   // Saves the read parameters.
   read_position_ = position;
   read_size_ = read_size;
   read_callback_.reset(read_callback);
   read_buffer_ = buffer;
 
   // Call to read internal to perform the actual read.
   ReadInternal();
 }
 
 void BufferedDataSource::StopTask() {
   DCHECK(MessageLoop::current() == render_loop_);
 
   // We just need to stop the loader, so it stops activity.
-  if (loader_.get()) {
+  if (loader_.get())
     loader_->Stop();
-    loader_.reset();
-  }
+
+  // If the probe request is still active, stop it too.
+  if (probe_loader_.get())
+    probe_loader_->Stop();
 }
 
 void BufferedDataSource::SwapLoaderTask(BufferedResourceLoader* loader) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader);
 
   loader_.reset(loader);
   loader_->Start(NewCallback(this,
                              &BufferedDataSource::PartialReadStartCallback));
 }
 
 // This method is the place where actual read happens, |loader_| must be valid
 // prior to make this method call.
 void BufferedDataSource::ReadInternal() {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
   // First we prepare the intermediate read buffer for BufferedResourceLoader
   // to write to.
   if (read_size_ > intermediate_read_buffer_size_) {
     intermediate_read_buffer_.reset(new uint8[read_size_]);
   }
 
   // Perform the actual read with BufferedResourceLoader.
-  loader_->Read(read_position_, read_size_,
-                intermediate_read_buffer_.get(),
+  loader_->Read(read_position_, read_size_, intermediate_read_buffer_.get(),
                 NewCallback(this, &BufferedDataSource::ReadCallback));
 }
 
 // Method to report the results of the current read request. Also reset all
 // the read parameters.
 void BufferedDataSource::DoneRead(int error) {
   DCHECK(MessageLoop::current() == render_loop_);
   lock_.AssertAcquired();
 
   if (error >= 0) {
@@ skipping 14 matching lines @@
   lock_.AssertAcquired();
 
   initialize_callback_->Run();
   initialize_callback_.reset();
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // BufferedDataSource, callback methods.
 // These methods are called on the render thread for the events reported by
 // BufferedResourceLoader.
-void BufferedDataSource::InitializeStartCallback(int error) {
+void BufferedDataSource::InitialStartCallback(int error) {
   DCHECK(MessageLoop::current() == render_loop_);
 
   // We need to prevent calling to filter host and running the callback if
   // we have received the stop signal. We need to lock down the whole callback
   // method to prevent bad things from happening. The reason behind this is
   // that we cannot guarantee tasks on render thread have completely stopped
   // when we receive the Stop() method call. The only way to solve this is to
   // let tasks on render thread to run but make sure they don't call outside
   // this object when Stop() method is ever called. Locking this method is safe
   // because |lock_| is only acquired in tasks on render thread.
   AutoLock auto_lock(lock_);
   if (stopped_)
     return;
 
-  DCHECK(loader_.get());
-
-  if (error == net::OK) {
-    total_bytes_ = loader_->content_length();
-    // TODO(hclam): Figure out what to do when total bytes is not known.
-    if (total_bytes_ >= 0) {
-      host()->SetTotalBytes(total_bytes_);
-
-      // This value governs the range that we can seek to.
-      // TODO(hclam): Report the correct value of buffered bytes.
-      host()->SetBufferedBytes(total_bytes_);
-    }
-  } else {
+  if (error != net::OK) {
     // TODO(hclam): In case of failure, we can retry several times.
-    // Also it might be bad to access host() here.
     host()->SetError(media::PIPELINE_ERROR_NETWORK);
-
-    // Stops the loader, just to be safe.
+    DCHECK(loader_.get());
+    DCHECK(probe_loader_.get());
     loader_->Stop();
+    probe_loader_->Stop();
+    DoneInitialization();
+    return;
   }
 
-  DoneInitialization();
+  total_bytes_ = loader_->instance_size();
+  if (total_bytes_ >= 0) {
+    // This value governs the range that we can seek to.
+    // TODO(hclam): Report the correct value of buffered bytes.
+    host()->SetTotalBytes(total_bytes_);
+    host()->SetBufferedBytes(total_bytes_);
+  } else {
+    // If the server didn't reply with a content length, it is likely this
+    // is a streaming response.
+    streaming_ = true;
+    host()->SetStreaming(true);
+  }
+
+  initial_response_received_ = true;
+  if (probe_response_received_)
+    DoneInitialization();
+}
+
+void BufferedDataSource::ProbeStartCallback(int error) {
+  DCHECK(MessageLoop::current() == render_loop_);
+
+  // We need to prevent calling to filter host and running the callback if
+  // we have received the stop signal. We need to lock down the whole callback
+  // method to prevent bad things from happening. The reason behind this is
+  // that we cannot guarantee tasks on render thread have completely stopped
+  // when we receive the Stop() method call. The only way to solve this is to
+  // let tasks on render thread to run but make sure they don't call outside
+  // this object when Stop() method is ever called. Locking this method is safe
+  // because |lock_| is only acquired in tasks on render thread.
+  AutoLock auto_lock(lock_);
+  if (stopped_)
+    return;
+
+  if (error != net::OK) {
+    streaming_ = true;
+    host()->SetStreaming(true);
+  }
+
+  DCHECK(probe_loader_.get());
+  probe_loader_->Stop();
+  probe_response_received_ = true;
+  if (initial_response_received_)
+    DoneInitialization();
 }
 
 void BufferedDataSource::PartialReadStartCallback(int error) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
   if (error == net::OK) {
     // Once the range request has start successfully, we can proceed with
     // reading from it.
     ReadInternal();
   } else {
+    loader_->Stop();
+
     // We need to prevent calling to filter host and running the callback if
     // we have received the stop signal. We need to lock down the whole callback
     // method to prevent bad things from happening. The reason behind this is
     // that we cannot guarantee tasks on render thread have completely stopped
     // when we receive the Stop() method call. So only way to solve this is to
     // let tasks on render thread to run but make sure they don't call outside
     // this object when Stop() method is ever called. Locking this method is
     // safe because |lock_| is only acquired in tasks on render thread.
     AutoLock auto_lock(lock_);
     if (stopped_)
       return;
-
-    // TODO(hclam): It may be bad to access host() here.
-    host()->SetError(media::PIPELINE_ERROR_NETWORK);
-
-    // Kill the loader just to be safe.
-    loader_->Stop();
+    DoneRead(net::ERR_INVALID_RESPONSE);
   }
 }
 
 void BufferedDataSource::ReadCallback(int error) {
   DCHECK(MessageLoop::current() == render_loop_);
 
   // We need to prevent calling to filter host and running the callback if
   // we have received the stop signal. We need to lock down the whole callback
   // method to prevent bad things from happening. The reason behind this is
   // that we cannot guarantee tasks on render thread have completely stopped
   // when we receive the Stop() method call. So only way to solve this is to
   // let tasks on render thread to run but make sure they don't call outside
   // this object when Stop() method is ever called. Locking this method is safe
   // because |lock_| is only acquired in tasks on render thread.
   AutoLock auto_lock(lock_);
   if (stopped_)
     return;
 
   DCHECK(loader_.get());
   DCHECK(read_callback_.get());
 
   if (error >= 0) {
     // If a position error code is received, read was successful. So copy
     // from intermediate read buffer to the target read buffer.
     memcpy(read_buffer_, intermediate_read_buffer_.get(), error);
-
     DoneRead(error);
   } else if (error == net::ERR_CACHE_MISS) {
     // If the current loader cannot serve this read request, we need to create
     // a new one.
-    // We have the following conditions:
-    // 1. Read is beyond the content length of the file (if known).
-    // 2. We have tried too many times (TODO here).
-    if (read_position_ >= total_bytes_) {
-      DoneRead(0);
-      return;
-    }
-
     // TODO(hclam): we need to count how many times it failed to prevent
     // excessive trials.
 
     // Stops the current resource loader.
     loader_->Stop();
 
     // Since this method is called from the current buffered resource loader,
     // we cannot delete it. So we need to post a task to swap in a new
     // resource loader and starts it.
     render_loop_->PostTask(FROM_HERE,
-        NewRunnableMethod(this,
-                          &BufferedDataSource::SwapLoaderTask,
+        NewRunnableMethod(this, &BufferedDataSource::SwapLoaderTask,
                           CreateLoader(read_position_, -1)));
   } else {
-    // The read has finished with error.
+    loader_->Stop();
     DoneRead(error);
-
-    // TODO(hclam): It may be bad to access host() here.
-    host()->SetError(media::PIPELINE_ERROR_NETWORK);
-
-    // Stops the laoder.
-    loader_->Stop();
   }
 }
 
 }  // namespace webkit_glue