Implementing preload=metadata for video

webkit/glue/media/defer_strategy.cc

Index: webkit/glue/media/defer_strategy.cc
diff --git a/webkit/glue/media/defer_strategy.cc b/webkit/glue/media/defer_strategy.cc
new file mode 100644
index 0000000000000000000000000000000000000000..473763c8648dd9100532707f93cbbf03b42d910c
--- /dev/null
+++ b/webkit/glue/media/defer_strategy.cc
@@ -0,0 +1,91 @@
+// 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/defer_strategy.h"
+
+#include "webkit/glue/media/buffered_resource_loader.h"
+
+namespace webkit_glue {
+
+bool DeferStrategy::ToggleDefer(BufferedResourceLoader* loader)
+{
+    DCHECK(loader);
+    bool deferSetting = !loader->deferred_;
+    loader->deferred_ = deferSetting;
+    if (loader->url_loader_.get()) {
+      loader->url_loader_->setDefersLoading(deferSetting);
+      return true;
+    }
+    return false;

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

Shouldn't this a method in BufferedResourceLoader? This code shouldn't have to
know the details of BufferedResourceLoader.

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

lol yeah, oops. Fixed/NA anymore! :)

+}
+
+NeverDeferStrategy* NeverDeferStrategy::GetInstance() {
+  return Singleton<NeverDeferStrategy>::get();
+}
+
+bool NeverDeferStrategy::EnableDeferIfNeeded(
+    BufferedResourceLoader* loader) const {
+  return false;
+}
+
+bool NeverDeferStrategy::DisableDeferIfNeeded(
+    BufferedResourceLoader* loader) const {
+  DCHECK(loader);
+  if (loader->deferred_)
+      return ToggleDefer(loader);
+  return false;
+}
+
+ThresholdDeferStrategy* ThresholdDeferStrategy::GetInstance() {
+  return Singleton<ThresholdDeferStrategy>::get();
+}
+
+bool ThresholdDeferStrategy::EnableDeferIfNeeded(
+    BufferedResourceLoader* loader) const {
+  DCHECK(loader);
+  if (!loader->deferred_ &&
+      loader->buffer_->forward_bytes() >= loader->buffer_->forward_capacity()) {
+    return ToggleDefer(loader);
+  }
+  return false;
+}
+
+bool ThresholdDeferStrategy::DisableDeferIfNeeded(
+    BufferedResourceLoader* loader) const {
+  DCHECK(loader);
+  DCHECK(loader->buffer_.get());
+  size_t amount_buffered = loader->buffer_->forward_bytes();
+  size_t half_capacity = loader->buffer_->forward_capacity() / 2;
+  if (loader->deferred_ && amount_buffered < half_capacity)
+    return ToggleDefer(loader);
+  return false;
+}
+
+ReadThenDeferStrategy* ReadThenDeferStrategy::GetInstance() {
+  return Singleton<ReadThenDeferStrategy>::get();
+}
+
+bool ReadThenDeferStrategy::EnableDeferIfNeeded(
+    BufferedResourceLoader* loader) const {
+  DCHECK(loader);
+  if (!loader->deferred_ && !loader->read_callback_.get())
+    return ToggleDefer(loader);
+  return false;
+}
+
+bool ReadThenDeferStrategy::DisableDeferIfNeeded(
+    BufferedResourceLoader* loader) const {
+  DCHECK(loader);
+  DCHECK(loader->buffer_.get());
+  size_t amount_buffered = loader->buffer_->forward_bytes();
+  size_t amount_to_read = static_cast<size_t>(loader->read_size_);
+
+  if (loader->deferred_ && loader->read_callback_.get() &&
+      amount_buffered < amount_to_read) {
+    return ToggleDefer(loader);
+  }
+  return false;
+}
+
+};