cef/tests/ceftests/stream_resource_handler_uni...

180 lines
4.9 KiB
C++

// 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);
}