2012-04-03 03:34:16 +02:00
|
|
|
// Copyright (c) 2008 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.
|
|
|
|
|
2017-05-19 11:06:00 +02:00
|
|
|
#include "libcef/browser/stream_impl.h"
|
2012-04-03 03:34:16 +02:00
|
|
|
#include <stdlib.h>
|
2014-11-12 20:25:15 +01:00
|
|
|
#include "base/files/file_util.h"
|
2012-04-03 03:34:16 +02:00
|
|
|
#include "base/logging.h"
|
2014-02-11 23:44:35 +01:00
|
|
|
#include "base/threading/thread_restrictions.h"
|
2012-04-03 03:34:16 +02:00
|
|
|
|
|
|
|
// Static functions
|
|
|
|
|
|
|
|
CefRefPtr<CefStreamReader> CefStreamReader::CreateForFile(
|
|
|
|
const CefString& fileName) {
|
2014-02-11 23:44:35 +01:00
|
|
|
DCHECK(!fileName.empty());
|
|
|
|
|
|
|
|
// TODO(cef): Do not allow file IO on all threads (issue #1187).
|
2022-11-15 18:50:53 +01:00
|
|
|
base::ScopedAllowBlockingForTesting allow_blocking;
|
2014-02-11 23:44:35 +01:00
|
|
|
|
2012-04-03 03:34:16 +02:00
|
|
|
CefRefPtr<CefStreamReader> reader;
|
2014-02-10 20:26:35 +01:00
|
|
|
FILE* file = base::OpenFile(base::FilePath(fileName), "rb");
|
2023-01-02 23:59:03 +01:00
|
|
|
if (file) {
|
2012-04-03 03:34:16 +02:00
|
|
|
reader = new CefFileReader(file, true);
|
2023-01-02 23:59:03 +01:00
|
|
|
}
|
2012-04-03 03:34:16 +02:00
|
|
|
return reader;
|
|
|
|
}
|
|
|
|
|
|
|
|
CefRefPtr<CefStreamReader> CefStreamReader::CreateForData(void* data,
|
|
|
|
size_t size) {
|
2020-01-15 14:36:24 +01:00
|
|
|
DCHECK(data != nullptr);
|
2017-05-17 11:29:28 +02:00
|
|
|
DCHECK(size > 0);
|
2012-04-03 03:34:16 +02:00
|
|
|
CefRefPtr<CefStreamReader> reader;
|
2023-01-02 23:59:03 +01:00
|
|
|
if (data && size > 0) {
|
2012-04-03 03:34:16 +02:00
|
|
|
reader = new CefBytesReader(data, size, true);
|
2023-01-02 23:59:03 +01:00
|
|
|
}
|
2012-04-03 03:34:16 +02:00
|
|
|
return reader;
|
|
|
|
}
|
|
|
|
|
|
|
|
CefRefPtr<CefStreamReader> CefStreamReader::CreateForHandler(
|
|
|
|
CefRefPtr<CefReadHandler> handler) {
|
|
|
|
DCHECK(handler.get());
|
|
|
|
CefRefPtr<CefStreamReader> reader;
|
2023-01-02 23:59:03 +01:00
|
|
|
if (handler.get()) {
|
2012-04-03 03:34:16 +02:00
|
|
|
reader = new CefHandlerReader(handler);
|
2023-01-02 23:59:03 +01:00
|
|
|
}
|
2012-04-03 03:34:16 +02:00
|
|
|
return reader;
|
|
|
|
}
|
|
|
|
|
|
|
|
CefRefPtr<CefStreamWriter> CefStreamWriter::CreateForFile(
|
|
|
|
const CefString& fileName) {
|
|
|
|
DCHECK(!fileName.empty());
|
2014-02-11 23:44:35 +01:00
|
|
|
|
|
|
|
// TODO(cef): Do not allow file IO on all threads (issue #1187).
|
2022-11-15 18:50:53 +01:00
|
|
|
base::ScopedAllowBlockingForTesting allow_blocking;
|
2014-02-11 23:44:35 +01:00
|
|
|
|
2012-04-03 03:34:16 +02:00
|
|
|
CefRefPtr<CefStreamWriter> writer;
|
2014-02-10 20:26:35 +01:00
|
|
|
FILE* file = base::OpenFile(base::FilePath(fileName), "wb");
|
2023-01-02 23:59:03 +01:00
|
|
|
if (file) {
|
2012-04-03 03:34:16 +02:00
|
|
|
writer = new CefFileWriter(file, true);
|
2023-01-02 23:59:03 +01:00
|
|
|
}
|
2012-04-03 03:34:16 +02:00
|
|
|
return writer;
|
|
|
|
}
|
|
|
|
|
|
|
|
CefRefPtr<CefStreamWriter> CefStreamWriter::CreateForHandler(
|
|
|
|
CefRefPtr<CefWriteHandler> handler) {
|
|
|
|
DCHECK(handler.get());
|
|
|
|
CefRefPtr<CefStreamWriter> writer;
|
2023-01-02 23:59:03 +01:00
|
|
|
if (handler.get()) {
|
2012-04-03 03:34:16 +02:00
|
|
|
writer = new CefHandlerWriter(handler);
|
2023-01-02 23:59:03 +01:00
|
|
|
}
|
2012-04-03 03:34:16 +02:00
|
|
|
return writer;
|
|
|
|
}
|
|
|
|
|
|
|
|
// CefFileReader
|
|
|
|
|
|
|
|
CefFileReader::CefFileReader(FILE* file, bool close)
|
2017-05-17 11:29:28 +02:00
|
|
|
: close_(close), file_(file) {}
|
2012-04-03 03:34:16 +02:00
|
|
|
|
|
|
|
CefFileReader::~CefFileReader() {
|
2014-07-15 00:18:51 +02:00
|
|
|
base::AutoLock lock_scope(lock_);
|
2023-01-02 23:59:03 +01:00
|
|
|
if (close_) {
|
2014-02-10 20:26:35 +01:00
|
|
|
base::CloseFile(file_);
|
2023-01-02 23:59:03 +01:00
|
|
|
}
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
size_t CefFileReader::Read(void* ptr, size_t size, size_t n) {
|
2014-07-15 00:18:51 +02:00
|
|
|
base::AutoLock lock_scope(lock_);
|
2012-04-03 03:34:16 +02:00
|
|
|
return fread(ptr, size, n, file_);
|
|
|
|
}
|
|
|
|
|
2023-06-01 16:06:15 +02:00
|
|
|
int CefFileReader::Seek(int64_t offset, int whence) {
|
2014-07-15 00:18:51 +02:00
|
|
|
base::AutoLock lock_scope(lock_);
|
2022-01-24 18:58:02 +01:00
|
|
|
#if BUILDFLAG(IS_WIN)
|
2012-04-03 03:34:16 +02:00
|
|
|
return _fseeki64(file_, offset, whence);
|
|
|
|
#else
|
|
|
|
return fseek(file_, offset, whence);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2023-06-01 16:06:15 +02:00
|
|
|
int64_t CefFileReader::Tell() {
|
2014-07-15 00:18:51 +02:00
|
|
|
base::AutoLock lock_scope(lock_);
|
2022-01-24 18:58:02 +01:00
|
|
|
#if BUILDFLAG(IS_WIN)
|
2012-04-03 03:34:16 +02:00
|
|
|
return _ftelli64(file_);
|
|
|
|
#else
|
|
|
|
return ftell(file_);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
int CefFileReader::Eof() {
|
2014-07-15 00:18:51 +02:00
|
|
|
base::AutoLock lock_scope(lock_);
|
2012-04-03 03:34:16 +02:00
|
|
|
return feof(file_);
|
|
|
|
}
|
|
|
|
|
|
|
|
// CefFileWriter
|
|
|
|
|
|
|
|
CefFileWriter::CefFileWriter(FILE* file, bool close)
|
2017-05-17 11:29:28 +02:00
|
|
|
: file_(file), close_(close) {}
|
2012-04-03 03:34:16 +02:00
|
|
|
|
|
|
|
CefFileWriter::~CefFileWriter() {
|
2014-07-15 00:18:51 +02:00
|
|
|
base::AutoLock lock_scope(lock_);
|
2023-01-02 23:59:03 +01:00
|
|
|
if (close_) {
|
2014-02-10 20:26:35 +01:00
|
|
|
base::CloseFile(file_);
|
2023-01-02 23:59:03 +01:00
|
|
|
}
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
size_t CefFileWriter::Write(const void* ptr, size_t size, size_t n) {
|
2014-07-15 00:18:51 +02:00
|
|
|
base::AutoLock lock_scope(lock_);
|
2012-04-03 03:34:16 +02:00
|
|
|
return (size_t)fwrite(ptr, size, n, file_);
|
|
|
|
}
|
|
|
|
|
2023-06-01 16:06:15 +02:00
|
|
|
int CefFileWriter::Seek(int64_t offset, int whence) {
|
2014-07-15 00:18:51 +02:00
|
|
|
base::AutoLock lock_scope(lock_);
|
2012-04-03 03:34:16 +02:00
|
|
|
return fseek(file_, offset, whence);
|
|
|
|
}
|
|
|
|
|
2023-06-01 16:06:15 +02:00
|
|
|
int64_t CefFileWriter::Tell() {
|
2014-07-15 00:18:51 +02:00
|
|
|
base::AutoLock lock_scope(lock_);
|
2012-04-03 03:34:16 +02:00
|
|
|
return ftell(file_);
|
|
|
|
}
|
|
|
|
|
|
|
|
int CefFileWriter::Flush() {
|
2014-07-15 00:18:51 +02:00
|
|
|
base::AutoLock lock_scope(lock_);
|
2012-04-03 03:34:16 +02:00
|
|
|
return fflush(file_);
|
|
|
|
}
|
|
|
|
|
|
|
|
// CefBytesReader
|
|
|
|
|
2023-06-01 16:06:15 +02:00
|
|
|
CefBytesReader::CefBytesReader(void* data, int64_t datasize, bool copy)
|
2020-01-15 14:36:24 +01:00
|
|
|
: data_(nullptr), datasize_(0), copy_(false), offset_(0) {
|
2012-04-03 03:34:16 +02:00
|
|
|
SetData(data, datasize, copy);
|
|
|
|
}
|
|
|
|
|
|
|
|
CefBytesReader::~CefBytesReader() {
|
2020-01-15 14:36:24 +01:00
|
|
|
SetData(nullptr, 0, false);
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
size_t CefBytesReader::Read(void* ptr, size_t size, size_t n) {
|
2014-07-15 00:18:51 +02:00
|
|
|
base::AutoLock lock_scope(lock_);
|
2012-04-03 03:34:16 +02:00
|
|
|
size_t s = (datasize_ - offset_) / size;
|
|
|
|
size_t ret = (n < s ? n : s);
|
|
|
|
memcpy(ptr, (reinterpret_cast<char*>(data_)) + offset_, ret * size);
|
|
|
|
offset_ += ret * size;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2023-06-01 16:06:15 +02:00
|
|
|
int CefBytesReader::Seek(int64_t offset, int whence) {
|
2012-04-03 03:34:16 +02:00
|
|
|
int rv = -1L;
|
2014-07-15 00:18:51 +02:00
|
|
|
base::AutoLock lock_scope(lock_);
|
2012-04-03 03:34:16 +02:00
|
|
|
switch (whence) {
|
2017-05-17 11:29:28 +02:00
|
|
|
case SEEK_CUR:
|
2023-01-02 23:59:03 +01:00
|
|
|
if (offset_ + offset > datasize_ || offset_ + offset < 0) {
|
2017-05-17 11:29:28 +02:00
|
|
|
break;
|
2023-01-02 23:59:03 +01:00
|
|
|
}
|
2017-05-17 11:29:28 +02:00
|
|
|
offset_ += offset;
|
|
|
|
rv = 0;
|
2012-04-03 03:34:16 +02:00
|
|
|
break;
|
2017-05-17 11:29:28 +02:00
|
|
|
case SEEK_END: {
|
2023-06-01 16:06:15 +02:00
|
|
|
int64_t offset_abs = std::abs(offset);
|
2023-01-02 23:59:03 +01:00
|
|
|
if (offset_abs > datasize_) {
|
2017-05-17 11:29:28 +02:00
|
|
|
break;
|
2023-01-02 23:59:03 +01:00
|
|
|
}
|
2017-05-17 11:29:28 +02:00
|
|
|
offset_ = datasize_ - offset_abs;
|
|
|
|
rv = 0;
|
2012-04-03 03:34:16 +02:00
|
|
|
break;
|
2017-05-17 11:29:28 +02:00
|
|
|
}
|
|
|
|
case SEEK_SET:
|
2023-01-02 23:59:03 +01:00
|
|
|
if (offset > datasize_ || offset < 0) {
|
2017-05-17 11:29:28 +02:00
|
|
|
break;
|
2023-01-02 23:59:03 +01:00
|
|
|
}
|
2017-05-17 11:29:28 +02:00
|
|
|
offset_ = offset;
|
|
|
|
rv = 0;
|
2012-04-03 03:34:16 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2023-06-01 16:06:15 +02:00
|
|
|
int64_t CefBytesReader::Tell() {
|
2014-07-15 00:18:51 +02:00
|
|
|
base::AutoLock lock_scope(lock_);
|
2012-04-03 03:34:16 +02:00
|
|
|
return offset_;
|
|
|
|
}
|
|
|
|
|
|
|
|
int CefBytesReader::Eof() {
|
2014-07-15 00:18:51 +02:00
|
|
|
base::AutoLock lock_scope(lock_);
|
2012-04-03 03:34:16 +02:00
|
|
|
return (offset_ >= datasize_);
|
|
|
|
}
|
|
|
|
|
2023-06-01 16:06:15 +02:00
|
|
|
void CefBytesReader::SetData(void* data, int64_t datasize, bool copy) {
|
2014-07-15 00:18:51 +02:00
|
|
|
base::AutoLock lock_scope(lock_);
|
2023-01-02 23:59:03 +01:00
|
|
|
if (copy_) {
|
2012-04-03 03:34:16 +02:00
|
|
|
free(data_);
|
2023-01-02 23:59:03 +01:00
|
|
|
}
|
2012-04-03 03:34:16 +02:00
|
|
|
|
|
|
|
copy_ = copy;
|
|
|
|
offset_ = 0;
|
|
|
|
datasize_ = datasize;
|
|
|
|
|
|
|
|
if (copy) {
|
|
|
|
data_ = malloc(datasize);
|
2020-01-15 14:36:24 +01:00
|
|
|
DCHECK(data_ != nullptr);
|
2023-01-02 23:59:03 +01:00
|
|
|
if (data_) {
|
2012-04-03 03:34:16 +02:00
|
|
|
memcpy(data_, data, datasize);
|
2023-01-02 23:59:03 +01:00
|
|
|
}
|
2012-04-03 03:34:16 +02:00
|
|
|
} else {
|
|
|
|
data_ = data;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// CefBytesWriter
|
|
|
|
|
|
|
|
CefBytesWriter::CefBytesWriter(size_t grow)
|
2017-05-17 11:29:28 +02:00
|
|
|
: grow_(grow), datasize_(grow), offset_(0) {
|
|
|
|
DCHECK(grow > 0);
|
2012-04-03 03:34:16 +02:00
|
|
|
data_ = malloc(grow);
|
2020-01-15 14:36:24 +01:00
|
|
|
DCHECK(data_ != nullptr);
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
CefBytesWriter::~CefBytesWriter() {
|
2014-07-15 00:18:51 +02:00
|
|
|
base::AutoLock lock_scope(lock_);
|
2023-01-02 23:59:03 +01:00
|
|
|
if (data_) {
|
2012-04-03 03:34:16 +02:00
|
|
|
free(data_);
|
2023-01-02 23:59:03 +01:00
|
|
|
}
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
size_t CefBytesWriter::Write(const void* ptr, size_t size, size_t n) {
|
2014-07-15 00:18:51 +02:00
|
|
|
base::AutoLock lock_scope(lock_);
|
2012-04-03 03:34:16 +02:00
|
|
|
size_t rv;
|
2023-06-01 16:06:15 +02:00
|
|
|
if (offset_ + static_cast<int64_t>(size * n) >= datasize_ &&
|
2012-04-03 03:34:16 +02:00
|
|
|
Grow(size * n) == 0) {
|
|
|
|
rv = 0;
|
|
|
|
} else {
|
|
|
|
memcpy(reinterpret_cast<char*>(data_) + offset_, ptr, size * n);
|
|
|
|
offset_ += size * n;
|
|
|
|
rv = n;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2023-06-01 16:06:15 +02:00
|
|
|
int CefBytesWriter::Seek(int64_t offset, int whence) {
|
2012-04-03 03:34:16 +02:00
|
|
|
int rv = -1L;
|
2014-07-15 00:18:51 +02:00
|
|
|
base::AutoLock lock_scope(lock_);
|
2012-04-03 03:34:16 +02:00
|
|
|
switch (whence) {
|
2017-05-17 11:29:28 +02:00
|
|
|
case SEEK_CUR:
|
2023-01-02 23:59:03 +01:00
|
|
|
if (offset_ + offset > datasize_ || offset_ + offset < 0) {
|
2017-05-17 11:29:28 +02:00
|
|
|
break;
|
2023-01-02 23:59:03 +01:00
|
|
|
}
|
2017-05-17 11:29:28 +02:00
|
|
|
offset_ += offset;
|
|
|
|
rv = 0;
|
2012-04-03 03:34:16 +02:00
|
|
|
break;
|
2017-05-17 11:29:28 +02:00
|
|
|
case SEEK_END: {
|
2023-06-01 16:06:15 +02:00
|
|
|
int64_t offset_abs = std::abs(offset);
|
2023-01-02 23:59:03 +01:00
|
|
|
if (offset_abs > datasize_) {
|
2017-05-17 11:29:28 +02:00
|
|
|
break;
|
2023-01-02 23:59:03 +01:00
|
|
|
}
|
2017-05-17 11:29:28 +02:00
|
|
|
offset_ = datasize_ - offset_abs;
|
|
|
|
rv = 0;
|
2012-04-03 03:34:16 +02:00
|
|
|
break;
|
2017-05-17 11:29:28 +02:00
|
|
|
}
|
|
|
|
case SEEK_SET:
|
2023-01-02 23:59:03 +01:00
|
|
|
if (offset > datasize_ || offset < 0) {
|
2017-05-17 11:29:28 +02:00
|
|
|
break;
|
2023-01-02 23:59:03 +01:00
|
|
|
}
|
2017-05-17 11:29:28 +02:00
|
|
|
offset_ = offset;
|
|
|
|
rv = 0;
|
2012-04-03 03:34:16 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2023-06-01 16:06:15 +02:00
|
|
|
int64_t CefBytesWriter::Tell() {
|
2014-07-15 00:18:51 +02:00
|
|
|
base::AutoLock lock_scope(lock_);
|
2012-04-03 03:34:16 +02:00
|
|
|
return offset_;
|
|
|
|
}
|
|
|
|
|
|
|
|
int CefBytesWriter::Flush() {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string CefBytesWriter::GetDataString() {
|
2014-07-15 00:18:51 +02:00
|
|
|
base::AutoLock lock_scope(lock_);
|
2012-04-03 03:34:16 +02:00
|
|
|
std::string str(reinterpret_cast<char*>(data_), offset_);
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t CefBytesWriter::Grow(size_t size) {
|
2014-07-15 00:18:51 +02:00
|
|
|
base::AutoLock lock_scope(lock_);
|
2012-04-03 03:34:16 +02:00
|
|
|
size_t rv;
|
|
|
|
size_t s = (size > grow_ ? size : grow_);
|
|
|
|
void* tmp = realloc(data_, datasize_ + s);
|
2020-01-15 14:36:24 +01:00
|
|
|
DCHECK(tmp != nullptr);
|
2012-04-03 03:34:16 +02:00
|
|
|
if (tmp) {
|
|
|
|
data_ = tmp;
|
|
|
|
datasize_ += s;
|
|
|
|
rv = datasize_;
|
|
|
|
} else {
|
|
|
|
rv = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|