Add support for redirecting ResourceHandlers to a blob: URL

content/browser/streams/chrome_stream.cc

Index: content/browser/streams/chrome_stream.cc
diff --git a/content/browser/streams/chrome_stream.cc b/content/browser/streams/chrome_stream.cc
new file mode 100644
index 0000000000000000000000000000000000000000..9bc468ac825a29e95280e65bdf11f8408c1cb24f
--- /dev/null
+++ b/content/browser/streams/chrome_stream.cc
@@ -0,0 +1,95 @@
+// Copyright (c) 2013 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 "content/browser/streams/chrome_stream.h"
+
+#include "net/base/io_buffer.h"
+
+namespace {
+// Start throttling the connection at about 1MB
+const size_t kDeferSizeThreshold = 40 * 32768;
+}
+
+namespace content {
+
+ChromeStream::ChromeStream(const GURL& security_origin)
+    : current_size_(0),
+      bytes_read_(0),
+      complete_(false),
+      should_defer_(false),
+      security_origin_(security_origin) {
+}
+
+ChromeStream::~ChromeStream() {
+}
+
+void ChromeStream::AddObserver(ChromeStreamObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void ChromeStream::RemoveObserver(ChromeStreamObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+void ChromeStream::AddData(scoped_refptr<net::IOBuffer> buffer, size_t size) {
+  buffer_.push_back(std::make_pair(buffer, size));
+  current_size_ += size;
+  if (current_size_ > kDeferSizeThreshold) {
+    should_defer_ = true;
+  }
+
+  FOR_EACH_OBSERVER(ChromeStreamObserver, observers_, OnDataAvailable(this));
+}
+
+void ChromeStream::MarkComplete() {
+  complete_ = true;
+
+  MaybeNotifyComplete();
+}
+
+bool ChromeStream::ReadRawData(net::IOBuffer* buf,
+                               int buf_size,

[darin (slow to review), 2013/02/13 09:18:12]

it feels like there is some redundancy here with ByteStream{Reader,Writer}:

https://code.google.com/searchframe#OAMlx_jo-ck/src/content/browser/download/...

[Zachary Kuznia, 2013/02/13 16:37:14]

Modified this class to use ByteStream.

+                               int* bytes_read) {
+  if (buffer_.empty()) {
+    return complete_;
+  }
+
+  size_t current_buffer_size = buffer_.front().second;
+  size_t remaining_bytes = current_buffer_size - bytes_read_;
+  size_t to_read =
+      (size_t)buf_size < remaining_bytes ? buf_size : remaining_bytes;
+  scoped_refptr<net::IOBuffer> source = buffer_.front().first;
+
+  memcpy(buf->data(), source->data() + bytes_read_, to_read);
+
+  bytes_read_ += to_read;
+
+  if (bytes_read_ >= current_buffer_size) {
+    current_size_ -= current_buffer_size;
+    bytes_read_ = 0;
+    buffer_.pop_front();
+
+    if (should_defer_ && current_size_ < kDeferSizeThreshold) {
+      should_defer_ = false;
+      FOR_EACH_OBSERVER(ChromeStreamObserver,
+                        observers_,
+                        OnBufferAvailable(this));
+    }
+  }
+
+  *bytes_read = to_read;
+
+  MaybeNotifyComplete();
+
+  return true;
+}
+
+void ChromeStream::MaybeNotifyComplete() {
+  if (complete_ && buffer_.empty()) {
+    FOR_EACH_OBSERVER(ChromeStreamObserver, observers_, OnStreamComplete(this));
+  }
+}
+
+}  // namespace content
+