--- /dev/null
+// Copyright (c) 2014 The Chromium Embedded Framework 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 <algorithm>
+#include <cstdlib>
+#include <string>
+
+#include "include/base/cef_bind.h"
+#include "include/cef_stream.h"
+#include "include/wrapper/cef_closure_task.h"
+#include "include/wrapper/cef_stream_resource_handler.h"
+#include "tests/ceftests/routing_test_handler.h"
+#include "tests/gtest/include/gtest/gtest.h"
+
+namespace {
+
+const char kTestUrl[] = "http://tests-srh/test.html";
+const size_t kReadBlockSize = 1024U; // 1k.
+
+// The usual network buffer size is about 32k. Choose a value that's larger.
+const size_t kReadDesiredSize = 100U * 1024U; // 100k
+
+class ReadHandler : public CefReadHandler {
+ public:
+ explicit ReadHandler(bool may_block)
+ : may_block_(may_block),
+ offset_(0),
+ expected_result_(0) {
+ }
+
+ void CreateContent() {
+ // To verify that the data transers successfully we're going to make a big
+ // math problem.
+ content_.reserve(kReadDesiredSize + 50U);
+ content_ = "<html><body><script>var myratherlongvariablename=0;";
+
+ while (content_.size() < kReadDesiredSize) {
+ content_ += "myratherlongvariablename=myratherlongvariablename+1;";
+ expected_result_++;
+ }
+
+ content_ += "window.testQuery({request:myratherlongvariablename+''});"
+ "</script></body></html>";
+ }
+
+ int GetExpectedResult() const {
+ return expected_result_;
+ }
+
+ size_t Read(void* ptr, size_t size, size_t n) override {
+ EXPECT_EQ(1U, size);
+
+ // Read the minimum of requested size, remaining size or kReadBlockSize.
+ const size_t read_bytes =
+ std::min(std::min(size * n, content_.size() - offset_), kReadBlockSize);
+ if (read_bytes > 0) {
+ memcpy(ptr, content_.c_str() + offset_, read_bytes);
+ offset_ += read_bytes;
+ }
+
+ return read_bytes;
+ }
+
+ int Seek(int64 offset, int whence) override {
+ EXPECT_TRUE(false); // Not reached.
+ return 0;
+ }
+
+ int64 Tell() override {
+ EXPECT_TRUE(false); // Not reached.
+ return 0;
+ }
+
+ int Eof() override {
+ EXPECT_TRUE(false); // Not reached.
+ return 0;
+ }
+
+ bool MayBlock() override {
+ return may_block_;
+ }
+
+ private:
+ const bool may_block_;
+ std::string content_;
+ size_t offset_;
+ int expected_result_;
+
+ IMPLEMENT_REFCOUNTING(ReadHandler);
+};
+
+class ReadTestHandler : public RoutingTestHandler {
+ public:
+ explicit ReadTestHandler(bool may_block)
+ : may_block_(may_block),
+ expected_result_(0) {}
+
+ void RunTest() override {
+ // Create the browser.
+ CreateBrowser(kTestUrl);
+
+ // Time out the test after a reasonable period of time.
+ SetTestTimeout();
+ }
+
+ CefRefPtr<CefResourceHandler> GetResourceHandler(
+ CefRefPtr<CefBrowser> browser,
+ CefRefPtr<CefFrame> frame,
+ CefRefPtr<CefRequest> request) override {
+ got_resource_handler_.yes();
+
+ const std::string& url = request->GetURL();
+ EXPECT_STREQ(kTestUrl, url.c_str());
+
+ CefRefPtr<ReadHandler> handler = new ReadHandler(may_block_);
+ handler->CreateContent();
+ expected_result_ = handler->GetExpectedResult();
+
+ CefRefPtr<CefStreamReader> stream =
+ CefStreamReader::CreateForHandler(handler.get());
+ return new CefStreamResourceHandler("text/html", stream);
+ }
+
+ bool OnQuery(CefRefPtr<CefBrowser> browser,
+ CefRefPtr<CefFrame> frame,
+ int64 query_id,
+ const CefString& request,
+ bool persistent,
+ CefRefPtr<Callback> callback) override {
+ got_on_query_.yes();
+
+ const int actual_result = atoi(request.ToString().c_str());
+ EXPECT_EQ(expected_result_, actual_result);
+
+ DestroyTestIfDone();
+
+ return true;
+ }
+
+ void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
+ bool isLoading,
+ bool canGoBack,
+ bool canGoForward) override {
+ if (!isLoading) {
+ got_on_loading_state_change_done_.yes();
+ DestroyTestIfDone();
+ }
+ }
+
+ private:
+ void DestroyTestIfDone() {
+ if (got_on_query_ && got_on_loading_state_change_done_)
+ DestroyTest();
+ }
+
+ void DestroyTest() override {
+ EXPECT_TRUE(got_resource_handler_);
+ EXPECT_TRUE(got_on_query_);
+ EXPECT_TRUE(got_on_loading_state_change_done_);
+ RoutingTestHandler::DestroyTest();
+ }
+
+ const bool may_block_;
+
+ int expected_result_;
+ TrackCallback got_resource_handler_;
+ TrackCallback got_on_query_;
+ TrackCallback got_on_loading_state_change_done_;
+
+ IMPLEMENT_REFCOUNTING(ReadTestHandler);
+};
+
+} // namespace
+
+TEST(StreamResourceHandlerTest, ReadWillBlock) {
+ CefRefPtr<ReadTestHandler> handler = new ReadTestHandler(true);
+ handler->ExecuteTest();
+ ReleaseAndWaitForDestructor(handler);
+}
+
+TEST(StreamResourceHandlerTest, ReadWontBlock) {
+ CefRefPtr<ReadTestHandler> handler = new ReadTestHandler(false);
+ handler->ExecuteTest();
+ ReleaseAndWaitForDestructor(handler);
+}
projects / casparcg / blobdiff