- Add MayBlock() method to stream classes which is used as a hint when determining the thread to access the stream from (issue #1187).

- In cases where MayBlock() returns true have CefStreamResourceReader perform the reads on the FILE thread (issue #1187).

git-svn-id: https://chromiumembedded.googlecode.com/svn/trunk@1582 5089003a-bbd8-11dd-ad1f-f1f9622dbc98

libcef_dll/wrapper/cef_stream_resource_handler.cc

@@ -3,32 +3,119 @@
 // can be found in the LICENSE file.
 
 #include "include/wrapper/cef_stream_resource_handler.h"
+#include <algorithm>
 #include "include/cef_callback.h"
 #include "include/cef_request.h"
+#include "include/cef_runnable.h"
 #include "include/cef_stream.h"
 #include "libcef_dll/cef_logging.h"
 
+// Class that represents a readable/writable character buffer.
+class CefStreamResourceHandler::Buffer {
+ public:
+  Buffer()
+      : buffer_(NULL),
+        size_(0),
+        bytes_requested_(0),
+        bytes_written_(0),
+        bytes_read_(0) {
+  }
+
+  ~Buffer() {
+    if (buffer_)
+      delete [] buffer_;
+  }
+
+  void Reset(int new_size) {
+    if (size_ < new_size) {
+      if (buffer_)
+        delete [] buffer_;
+      size_ = new_size;
+      buffer_ = new char[size_];
+      DCHECK(buffer_);
+    }
+    bytes_requested_ = new_size;
+    bytes_written_ = 0;
+    bytes_read_ = 0;
+  }
+
+  bool IsEmpty() const {
+    return (bytes_written_ == 0);
+  }
+
+  bool CanRead() const {
+    return (bytes_read_ < bytes_written_);
+  }
+
+  int WriteTo(void* data_out, int bytes_to_read) {
+    const int write_size =
+        std::min(bytes_to_read, bytes_written_ - bytes_read_);
+    if (write_size > 0) {
+      memcpy(data_out, buffer_  + bytes_read_, write_size);
+      bytes_read_ += write_size;
+    }
+    return write_size;
+  }
+
+  int ReadFrom(CefRefPtr<CefStreamReader> reader) {
+    // Read until the buffer is full or until Read() returns 0 to indicate no
+    // more data.
+    int bytes_read;
+    do {
+      bytes_read = static_cast<int>(
+          reader->Read(buffer_ + bytes_written_, 1,
+                       bytes_requested_ - bytes_written_));
+      bytes_written_ += bytes_read;
+    } while (bytes_read != 0 && bytes_written_ < bytes_requested_);
+
+    return bytes_written_;
+  }
+
+ private:
+  char* buffer_;
+  int size_;
+  int bytes_requested_;
+  int bytes_written_;
+  int bytes_read_;
+};
+
 CefStreamResourceHandler::CefStreamResourceHandler(
     const CefString& mime_type,
     CefRefPtr<CefStreamReader> stream)
     : status_code_(200),
+      status_text_("OK"),
       mime_type_(mime_type),
-      stream_(stream) {
+      stream_(stream),
+      buffer_(NULL)
+#ifndef NDEBUG
+      , buffer_owned_by_file_thread_(false)
+#endif
+{
   DCHECK(!mime_type_.empty());
   DCHECK(stream_.get());
+  read_on_file_thread_ = stream_->MayBlock();
 }
 
 CefStreamResourceHandler::CefStreamResourceHandler(
     int status_code,
+    const CefString& status_text,
     const CefString& mime_type,
     CefResponse::HeaderMap header_map,
     CefRefPtr<CefStreamReader> stream)
     : status_code_(status_code),
+      status_text_(status_text),
       mime_type_(mime_type),
       header_map_(header_map),
-      stream_(stream) {
+      stream_(stream),
+      buffer_(NULL) {
   DCHECK(!mime_type_.empty());
   DCHECK(stream_.get());
+  read_on_file_thread_ = stream_->MayBlock();
+}
+
+CefStreamResourceHandler::~CefStreamResourceHandler() {
+  if (buffer_)
+    delete buffer_;
 }
 
 bool CefStreamResourceHandler::ProcessRequest(CefRefPtr<CefRequest> request,
@@ -42,6 +129,7 @@ void CefStreamResourceHandler::GetResponseHeaders(
     int64& response_length,
     CefString& redirectUrl) {
   response->SetStatus(status_code_);
+  response->SetStatusText(status_text_);
   response->SetMimeType(mime_type_);
 
   if (!header_map_.empty())
@@ -54,9 +142,63 @@ bool CefStreamResourceHandler::ReadResponse(void* data_out,
                                             int bytes_to_read,
                                             int& bytes_read,
                                             CefRefPtr<CefCallback> callback) {
-  bytes_read = static_cast<int>(stream_->Read(data_out, 1, bytes_to_read));
-  return (bytes_read > 0);
+  DCHECK_GT(bytes_to_read, 0);
+
+  if (read_on_file_thread_) {
+    DCHECK(!buffer_owned_by_file_thread_);
+    if (buffer_ && (buffer_->CanRead() || buffer_->IsEmpty())) {
+      if (buffer_->CanRead()) {
+        // Provide data from the buffer.
+        bytes_read = buffer_->WriteTo(data_out, bytes_to_read);
+        return (bytes_read > 0);
+      } else {
+        // End of the steam.
+        bytes_read = 0;
+        return false;
+      }
+    } else {
+      // Perform another read on the file thread.
+      bytes_read = 0;
+#ifndef NDEBUG
+      buffer_owned_by_file_thread_ = true;
+#endif
+      CefPostTask(TID_FILE,
+          NewCefRunnableMethod(this, &CefStreamResourceHandler::ReadOnFileThread,
+                               bytes_to_read, callback));
+      return true;
+    }
+  } else {
+    // Read until the buffer is full or until Read() returns 0 to indicate no
+    // more data.
+    bytes_read = 0;
+    int read = 0;
+    do {
+      read = static_cast<int>(
+          stream_->Read(static_cast<char*>(data_out) + bytes_read, 1,
+                        bytes_to_read - bytes_read));
+      bytes_read += read;
+    } while (read != 0 && bytes_read < bytes_to_read);
+
+    return (bytes_read > 0);
+  }
 }
 
 void CefStreamResourceHandler::Cancel() {
 }
+
+void CefStreamResourceHandler::ReadOnFileThread(
+    int bytes_to_read,
+    CefRefPtr<CefCallback> callback) {
+  CEF_REQUIRE_FILE_THREAD();
+  DCHECK(buffer_owned_by_file_thread_);
+
+  if (!buffer_)
+    buffer_ = new Buffer();
+  buffer_->Reset(bytes_to_read);
+  buffer_->ReadFrom(stream_);
+
+#ifndef NDEBUG
+  buffer_owned_by_file_thread_ = false;
+#endif
+  callback->Continue();
+}