Implementing preload=metadata for video

webkit/glue/media/buffered_resource_loader.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/glue/media/buffered_resource_loader.h"
 
 #include "base/format_macros.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebKit.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebKitClient.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLError.h"
+#include "webkit/glue/media/buffered_data_source.h"
+#include "webkit/glue/media/defer_strategy.h"
 #include "webkit/glue/multipart_response_delegate.h"
 #include "webkit/glue/webkit_glue.h"
 
 using WebKit::WebFrame;
 using WebKit::WebString;
 using WebKit::WebURLError;
 using WebKit::WebURLLoader;
 using WebKit::WebURLRequest;
 using WebKit::WebURLResponse;
 using webkit_glue::MultipartResponseDelegate;
@@ skipping 19 matching lines @@
 // number to be 2MB.
 // TODO(hclam): determine a better value for this.
 static const int kForwardWaitThreshold = 2 * kMegabyte;
 
 BufferedResourceLoader::BufferedResourceLoader(
     const GURL& url,
     int64 first_byte_position,
     int64 last_byte_position)
     : buffer_(new media::SeekableBuffer(kBackwardCapcity, kForwardCapacity)),
       deferred_(false),
-      defer_allowed_(true),
+      defer_strategy_(ReadThenDeferStrategy::GetInstance()),
       completed_(false),
       range_requested_(false),
       partial_response_(false),
       url_(url),
       first_byte_position_(first_byte_position),
       last_byte_position_(last_byte_position),
       single_origin_(true),
       start_callback_(NULL),
       offset_(0),
       content_length_(kPositionNotSpecified),
@@ skipping 113 matching lines @@
   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;
   }
 
+  DisableDeferIfNeeded();

[acolwell GONE FROM CHROMIUM, 2011/03/25 04:35:28]

Why is this call needed now?

[vrk (LEFT CHROMIUM), 2011/03/25 21:33:32]

Ah, a little hard to explain :) 

This call is needed for the case when you cannot fulfill the read because you
don't have enough data, and you're deferred.

In the old version, the buffer would defer only if there was >5mb of data in the
buffer. This means that if you don't have enough data to fulfill the read, you
would have to be in process of loading data (not deferred) - unless your read
request was > 5 mb (which is a bug! issue 42956)

But now that I have the "ReadThenDefer" buffering scheme that reads only as
little as possible before deferring, it's much more likely that you're deferred
and won't be able to get more data.

Added a comment to try to explain. Let me know if you still have questions or
have another idea for implementation.

+
   // 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);
 }
 
 int64 BufferedResourceLoader::GetBufferedPosition() {
   if (buffer_.get())
     return offset_ + static_cast<int>(buffer_->forward_bytes()) - 1;
   return kPositionNotSpecified;
 }
 
-void BufferedResourceLoader::SetAllowDefer(bool is_allowed) {
-  defer_allowed_ = is_allowed;
-  DisableDeferIfNeeded();
+void BufferedResourceLoader::UpdateDeferStrategy(
+    BufferedDataSource* data_source) {
+  DeferStrategy* strategy = data_source->ChooseDeferStrategy();

[acolwell GONE FROM CHROMIUM, 2011/03/25 04:35:28]

Why don't you do the ChooseDeferStrategy() in the call to this function? That
way this code doesn't have to know about BufferedDataSource.

[vrk (LEFT CHROMIUM), 2011/03/25 21:33:32]

Done.

+  if (strategy != defer_strategy_) {
+    defer_strategy_ = strategy;
+    EnableDeferIfNeeded();
+    DisableDeferIfNeeded();

[acolwell GONE FROM CHROMIUM, 2011/03/25 04:35:28]

The EnableDeferIfNeeded() followed by DisableDeferIfNeeded() is confusing. Is it
true that one of them will do something and the other is a noop? Will the defer
status get toggled on and then off?

[vrk (LEFT CHROMIUM), 2011/03/25 21:33:32]

Redid this to something more intuitive.

+  }
 }
 
 int64 BufferedResourceLoader::content_length() {
   return content_length_;
 }
 
 int64 BufferedResourceLoader::instance_size() {
   return instance_size_;
 }
 
@@ skipping 114 matching lines @@
   // In this case we shouldn't do anything.
   if (!buffer_.get())
     return;
 
   // Writes more data to |buffer_|.
   buffer_->Append(reinterpret_cast<const uint8*>(data), data_length);
 
   // If there is an active read request, try to fulfill the request.
   if (HasPendingRead() && CanFulfillRead()) {
     ReadInternal();
-  } else if (!defer_allowed_) {
+  } else if (!defer_strategy_->AllowsDeferring()) {
     // If we're not allowed to defer, slide the buffer window forward instead
     // of deferring.
     if (buffer_->forward_bytes() > buffer_->forward_capacity()) {
       size_t excess = buffer_->forward_bytes() - buffer_->forward_capacity();
       bool success = buffer_->Seek(excess);
       DCHECK(success);
       offset_ += first_offset_ + excess;
     }
   }
 
@@ skipping 75 matching lines @@
   Release();
 }
 
 bool BufferedResourceLoader::HasSingleOrigin() const {
   return single_origin_;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // Helper methods.
 void BufferedResourceLoader::EnableDeferIfNeeded() {
-  if (!defer_allowed_)
-    return;
-
-  if (!deferred_ &&
-      buffer_->forward_bytes() >= buffer_->forward_capacity()) {
-    deferred_ = true;
-
-  if (url_loader_.get())
-    url_loader_->setDefersLoading(true);
-
+  bool event_occurred = defer_strategy_->EnableDeferIfNeeded(this);
+  if (event_occurred)
     NotifyNetworkEvent();
-  }
 }
 
 void BufferedResourceLoader::DisableDeferIfNeeded() {
-  if (deferred_ &&
-      (!defer_allowed_ ||
-       buffer_->forward_bytes() < buffer_->forward_capacity() / 2)) {
-    deferred_ = false;
-
-    if (url_loader_.get())
-      url_loader_->setDefersLoading(false);
-
+  bool event_occurred = defer_strategy_->DisableDeferIfNeeded(this);
+  if (event_occurred)
     NotifyNetworkEvent();
-  }
 }
 
 bool BufferedResourceLoader::CanFulfillRead() {
   // If we are reading too far in the backward direction.
   if (first_offset_ < 0 &&
       first_offset_ + static_cast<int>(buffer_->backward_bytes()) < 0)
     return false;
 
   // If the start offset is too far ahead.
   if (first_offset_ >= static_cast<int>(buffer_->forward_bytes()))
@@ skipping 103 matching lines @@
   start_callback_->RunWithParams(Tuple1<int>(error));
   start_callback_.reset();
 }
 
 void BufferedResourceLoader::NotifyNetworkEvent() {
   if (event_callback_.get())
     event_callback_->Run();
 }
 
 }  // namespace webkit_glue