bcarrella/cef
1
0
Fork 0
mirror of https://bitbucket.org/chromiumembedded/cef synced 2025-02-23 07:27:42 +01:00
Code Issues Packages Projects Releases Wiki Activity

Expose zip archive reading support (issue #30).

Browse Source 
Move ClientReadHandler to CefByteReadHandler in cef_wrapper.h.
Add support for the time_t data type to cef_parser.py.

git-svn-id: https://chromiumembedded.googlecode.com/svn/trunk@125 5089003a-bbd8-11dd-ad1f-f1f9622dbc98
This commit is contained in:
Marshall Greenblatt 2010-10-24 16:41:21 +00:00
parent 1911b23bf5
commit 5a4c8f5a13
20 changed files with 1492 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
cef.gyp
View File

@ -99,6 +99,7 @@
'tests/unittests/test_suite.h',
'tests/unittests/v8_unittest.cc',
'tests/unittests/xml_reader_unittest.cc',
'tests/unittests/zip_reader_unittest.cc',
],
'include_dirs': [
'.',
@ -219,6 +220,8 @@
'libcef_dll/cpptoc/v8value_cpptoc.h',
'libcef_dll/cpptoc/xml_reader_cpptoc.cc',
'libcef_dll/cpptoc/xml_reader_cpptoc.h',
'libcef_dll/cpptoc/zip_reader_cpptoc.cc',
'libcef_dll/cpptoc/zip_reader_cpptoc.h',
'libcef_dll/ctocpp/ctocpp.h',
'libcef_dll/ctocpp/download_handler_ctocpp.cc',
'libcef_dll/ctocpp/download_handler_ctocpp.h',
@ -315,9 +318,13 @@
'libcef_dll/ctocpp/v8value_ctocpp.h',
'libcef_dll/ctocpp/xml_reader_ctocpp.cc',
'libcef_dll/ctocpp/xml_reader_ctocpp.h',
'libcef_dll/ctocpp/zip_reader_ctocpp.cc',
'libcef_dll/ctocpp/zip_reader_ctocpp.h',
'libcef_dll/transfer_util.cpp',
'libcef_dll/transfer_util.h',
'libcef_dll/wrapper/cef_byte_read_handler.cc',
'libcef_dll/wrapper/cef_xml_object.cc',
'libcef_dll/wrapper/cef_zip_archive.cc',
'libcef_dll/wrapper/libcef_dll_wrapper.cc',
],
},
@ -431,6 +438,8 @@
'libcef/webwidget_host.h',
'libcef/xml_reader_impl.cc',
'libcef/xml_reader_impl.h',
'libcef/zip_reader_impl.cc',
'libcef/zip_reader_impl.h',
],
'conditions': [
['OS=="win"', {

72
include/cef.h
View File

@ -1272,7 +1272,7 @@ public:
/*--cef()--*/
virtual bool MoveToNextNode() =0;
// Close the document. This must be called directly to ensure that cleanup
// Close the document. This should be called directly to ensure that cleanup
// occurs on the correct thread.
/*--cef()--*/
virtual bool Close() =0;
@ -1412,4 +1412,74 @@ public:
virtual bool MoveToCarryingElement() =0;
};
// Class that supports the reading of zip archives via the zlib unzip API.
/*--cef(source=library)--*/
class CefZipReader : public CefBase
{
public:
// Create a new CefZipReader object. The returned object's methods can only
// be called from the thread that created the object.
/*--cef()--*/
static CefRefPtr<CefZipReader> Create(CefRefPtr<CefStreamReader> stream);
// Moves the cursor to the first file in the archive. Returns true if the
// cursor position was set successfully.
/*--cef()--*/
virtual bool MoveToFirstFile() =0;
// Moves the cursor to the next file in the archive. Returns true if the
// cursor position was set successfully.
/*--cef()--*/
virtual bool MoveToNextFile() =0;
// Moves the cursor to the specified file in the archive. If |caseSensitive|
// is true then the search will be case sensitive. Returns true if the cursor
// position was set successfully.
/*--cef()--*/
virtual bool MoveToFile(const std::wstring& fileName, bool caseSensitive) =0;
// Closes the archive. This should be called directly to ensure that cleanup
// occurs on the correct thread.
/*--cef()--*/
virtual bool Close() =0;
// The below methods act on the file at the current cursor position.
// Returns the name of the file.
/*--cef()--*/
virtual std::wstring GetFileName() =0;
// Returns the uncompressed size of the file.
/*--cef()--*/
virtual long GetFileSize() =0;
// Returns the last modified timestamp for the file.
/*--cef()--*/
virtual time_t GetFileLastModified() =0;
// Opens the file for reading of uncompressed data. A read password may
// optionally be specified.
/*--cef()--*/
virtual bool OpenFile(const std::wstring& password) =0;
// Closes the file.
/*--cef()--*/
virtual bool CloseFile() =0;
// Read uncompressed file contents into the specified buffer. Returns < 0 if
// an error occurred, 0 if at the end of file, or the number of bytes read.
/*--cef()--*/
virtual int ReadFile(void* buffer, size_t bufferSize) =0;
// Returns the current offset in the uncompressed file contents.
/*--cef()--*/
virtual long Tell() =0;
// Returns true if at end of the file contents.
/*--cef()--*/
virtual bool Eof() =0;
};
#endif // _CEF_H

66
include/cef_capi.h
View File

@ -1015,7 +1015,7 @@ typedef struct _cef_xml_reader_t
// if the cursor position was set successfully.
int (CEF_CALLBACK *move_to_next_node)(struct _cef_xml_reader_t* self);
// Close the document. This must be called directly to ensure that cleanup
// Close the document. This should be called directly to ensure that cleanup
// occurs on the correct thread.
int (CEF_CALLBACK *close)(struct _cef_xml_reader_t* self);
@ -1157,6 +1157,70 @@ CEF_EXPORT cef_xml_reader_t* cef_xml_reader_create(cef_stream_reader_t* stream,
enum cef_xml_encoding_type_t encodingType, const wchar_t* URI);
// Structure that supports the reading of zip archives via the zlib unzip API.
typedef struct _cef_zip_reader_t
{
// Base structure.
cef_base_t base;
// Moves the cursor to the first file in the archive. Returns true (1) if the
// cursor position was set successfully.
int (CEF_CALLBACK *move_to_first_file)(struct _cef_zip_reader_t* self);
// Moves the cursor to the next file in the archive. Returns true (1) if the
// cursor position was set successfully.
int (CEF_CALLBACK *move_to_next_file)(struct _cef_zip_reader_t* self);
// Moves the cursor to the specified file in the archive. If |caseSensitive|
// is true (1) then the search will be case sensitive. Returns true (1) if the
// cursor position was set successfully.
int (CEF_CALLBACK *move_to_file)(struct _cef_zip_reader_t* self,
const wchar_t* fileName, int caseSensitive);
// Closes the archive. This should be called directly to ensure that cleanup
// occurs on the correct thread.
int (CEF_CALLBACK *close)(struct _cef_zip_reader_t* self);
// The below functions act on the file at the current cursor position.
// Returns the name of the file.
// The resulting string must be freed by calling cef_string_free().
cef_string_t (CEF_CALLBACK *get_file_name)(struct _cef_zip_reader_t* self);
// Returns the uncompressed size of the file.
long (CEF_CALLBACK *get_file_size)(struct _cef_zip_reader_t* self);
// Returns the last modified timestamp for the file.
time_t (CEF_CALLBACK *get_file_last_modified)(struct _cef_zip_reader_t* self);
// Opens the file for reading of uncompressed data. A read password may
// optionally be specified.
int (CEF_CALLBACK *open_file)(struct _cef_zip_reader_t* self,
const wchar_t* password);
// Closes the file.
int (CEF_CALLBACK *close_file)(struct _cef_zip_reader_t* self);
// Read uncompressed file contents into the specified buffer. Returns < 0 if
// an error occurred, 0 if at the end of file, or the number of bytes read.
int (CEF_CALLBACK *read_file)(struct _cef_zip_reader_t* self, void* buffer,
size_t bufferSize);
// Returns the current offset in the uncompressed file contents.
long (CEF_CALLBACK *tell)(struct _cef_zip_reader_t* self);
// Returns true (1) if at end of the file contents.
int (CEF_CALLBACK *eof)(struct _cef_zip_reader_t* self);
} cef_zip_reader_t;
// Create a new cef_zip_reader_t object. The returned object's functions can
// only be called from the thread that created the object.
CEF_EXPORT cef_zip_reader_t* cef_zip_reader_create(cef_stream_reader_t* stream);
#ifdef __cplusplus
}
#endif

98
include/cef_wrapper.h
View File

@ -40,6 +40,11 @@
#include <map>
#include <vector>
#ifndef min
#define min(a,b) ((a)<(b)?(a):(b))
#endif
// Thread safe class for representing XML data as a structured object. This
// class should not be used with large XML documents because all data will be
// resident in memory at the same time. This implementation supports a
@ -149,4 +154,97 @@ private:
ObjectVector children_;
};
// Thread safe implementation of the CefReadHandler class for reading an
// in-memory array of bytes.
class CefByteReadHandler : public CefThreadSafeBase<CefReadHandler>
{
public:
// Create a new object for reading an array of bytes. An optional |source|
// reference can be kept to keep the underlying data source from being
// released while the reader exists.
CefByteReadHandler(const unsigned char* bytes, size_t size,
CefRefPtr<CefBase> source);
// Read raw binary data.
virtual size_t Read(void* ptr, size_t size, size_t n);
// Seek to the specified offset position. |whence| may be any one of
// SEEK_CUR, SEEK_END or SEEK_SET.
virtual int Seek(long offset, int whence);
// Return the current offset position.
virtual long Tell();
// Return non-zero if at end of file.
virtual int Eof();
private:
const unsigned char* bytes_;
size_t size_;
size_t offset_;
CefRefPtr<CefBase> source_;
};
// Thread-safe class for accessing zip archive file contents. This class should
// not be used with large archive files because all data will be resident in
// memory at the same time. This implementation supports a restricted set of zip
// archive features:
// (1) Password-protected files are not supported.
// (2) All file names are stored and compared in lower case.
// (3) File ordering from the original zip archive is not maintained. This
// means that files from the same folder may not be located together in the
// file content map.
class CefZipArchive : public CefThreadSafeBase<CefBase>
{
public:
// Class representing a file in the archive. Accessing the file data from
// multiple threads is safe provided a reference to the File object is kept.
class File : public CefBase
{
public:
// Returns the read-only data contained in the file.
virtual const unsigned char* GetData() =0;
// Returns the size of the data in the file.
virtual size_t GetDataSize() =0;
// Returns a CefStreamReader object for streaming the contents of the file.
virtual CefRefPtr<CefStreamReader> GetStreamReader() =0;
};
typedef std::map<std::wstring, CefRefPtr<File> > FileMap;
// Create a new object.
CefZipArchive();
virtual ~CefZipArchive();
// Load the contents of the specified zip archive stream into this object.
// If |overwriteExisting| is true then any files in this object that also
// exist in the specified archive will be replaced with the new files.
// Returns the number of files successfully loaded.
size_t Load(CefRefPtr<CefStreamReader> stream, bool overwriteExisting);
// Clears the contents of this object.
void Clear();
// Returns the number of files in the archive.
size_t GetFileCount();
// Returns true if the specified file exists and has contents.
bool HasFile(const std::wstring& fileName);
// Returns the specified file.
CefRefPtr<File> GetFile(const std::wstring& fileName);
// Removes the specified file.
bool RemoveFile(const std::wstring& fileName);
// Returns the map of all files.
size_t GetFiles(FileMap& map);
private:
FileMap contents_;
};
#endif // _CEF_WRAPPER_H

298
libcef/zip_reader_impl.cc Normal file
View File

@ -0,0 +1,298 @@
// Copyright (c) 20010 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 "zip_reader_impl.h"
#include "base/logging.h"
#include "base/utf_string_conversions.h"
#include <time.h>
// Static functions
//static
CefRefPtr<CefZipReader> CefZipReader::Create(CefRefPtr<CefStreamReader> stream)
{
CefRefPtr<CefZipReaderImpl> impl(new CefZipReaderImpl());
if (!impl->Initialize(stream))
return NULL;
return impl.get();
}
// CefZipReaderImpl
namespace {
voidpf ZCALLBACK zlib_open_callback OF((voidpf opaque, const char* filename,
int mode))
{
// The stream is already implicitly open so just return the pointer.
return opaque;
}
uLong ZCALLBACK zlib_read_callback OF((voidpf opaque, voidpf stream, void* buf,
uLong size))
{
CefRefPtr<CefStreamReader> reader(static_cast<CefStreamReader*>(opaque));
return reader->Read(buf, 1, size);
}
long ZCALLBACK zlib_tell_callback OF((voidpf opaque, voidpf stream))
{
CefRefPtr<CefStreamReader> reader(static_cast<CefStreamReader*>(opaque));
return reader->Tell();
}
long ZCALLBACK zlib_seek_callback OF((voidpf opaque, voidpf stream,
uLong offset, int origin))
{
CefRefPtr<CefStreamReader> reader(static_cast<CefStreamReader*>(opaque));
int whence;
switch (origin) {
case ZLIB_FILEFUNC_SEEK_CUR:
whence = SEEK_CUR;
break;
case ZLIB_FILEFUNC_SEEK_END:
whence = SEEK_END;
break;
case ZLIB_FILEFUNC_SEEK_SET:
whence = SEEK_SET;
break;
default:
NOTREACHED();
return -1;
}
return reader->Seek(offset, whence);
}
int ZCALLBACK zlib_close_callback OF((voidpf opaque, voidpf stream))
{
CefRefPtr<CefStreamReader> reader(static_cast<CefStreamReader*>(opaque));
// Release the reference added by CefZipReaderImpl::Initialize().
reader->Release();
return 0;
}
int ZCALLBACK zlib_error_callback OF((voidpf opaque, voidpf stream))
{
return 0;
}
} // namespace
CefZipReaderImpl::CefZipReaderImpl()
: supported_thread_id_(PlatformThread::CurrentId()), reader_(NULL),
has_fileopen_(false), has_fileinfo_(false), filesize_(0), filemodified_(0)
{
}
CefZipReaderImpl::~CefZipReaderImpl()
{
if (reader_ != NULL) {
if (!VerifyContext()) {
// Close() is supposed to be called directly. We'll try to free the reader
// now on the wrong thread but there's no guarantee this call won't crash.
if (has_fileopen_)
unzCloseCurrentFile(reader_);
unzClose(reader_);
} else {
Close();
}
}
}
bool CefZipReaderImpl::Initialize(CefRefPtr<CefStreamReader> stream)
{
zlib_filefunc_def filefunc_def;
filefunc_def.zopen_file = zlib_open_callback;
filefunc_def.zread_file = zlib_read_callback;
filefunc_def.zwrite_file = NULL;
filefunc_def.ztell_file = zlib_tell_callback;
filefunc_def.zseek_file = zlib_seek_callback;
filefunc_def.zclose_file = zlib_close_callback;
filefunc_def.zerror_file = zlib_error_callback;
filefunc_def.opaque = stream.get();
// Add a reference that will be released by zlib_close_callback().
stream->AddRef();
reader_ = unzOpen2("", &filefunc_def);
return (reader_ != NULL);
}
bool CefZipReaderImpl::MoveToFirstFile()
{
if (!VerifyContext())
return false;
if (has_fileopen_)
CloseFile();
has_fileinfo_ = false;
return (unzGoToFirstFile(reader_) == UNZ_OK);
}
bool CefZipReaderImpl::MoveToNextFile()
{
if (!VerifyContext())
return false;
if (has_fileopen_)
CloseFile();
has_fileinfo_ = false;
return (unzGoToNextFile(reader_) == UNZ_OK);
}
bool CefZipReaderImpl::MoveToFile(const std::wstring& fileName, bool caseSensitive)
{
if (!VerifyContext())
return false;
if (has_fileopen_)
CloseFile();
has_fileinfo_ = false;
std::string fileNameStr = WideToUTF8(fileName);
return (unzLocateFile(reader_, fileNameStr.c_str(),
(caseSensitive ? 1 : 2)) == UNZ_OK);
}
bool CefZipReaderImpl::Close()
{
if (!VerifyContext())
return false;
if (has_fileopen_)
CloseFile();
int result = unzClose(reader_);
reader_ = NULL;
return (result == UNZ_OK);
}
std::wstring CefZipReaderImpl::GetFileName()
{
if (!VerifyContext() || !GetFileInfo())
return std::wstring();
return filename_;
}
long CefZipReaderImpl::GetFileSize()
{
if (!VerifyContext() || !GetFileInfo())
return -1;
return filesize_;
}
time_t CefZipReaderImpl::GetFileLastModified()
{
if (!VerifyContext() || !GetFileInfo())
return 0;
return filemodified_;
}
bool CefZipReaderImpl::OpenFile(const std::wstring& password)
{
if (!VerifyContext())
return false;
if (has_fileopen_)
CloseFile();
bool ret;
if (password.empty()) {
ret = (unzOpenCurrentFile(reader_) == UNZ_OK);
} else {
std::string passwordStr = WideToUTF8(password);
ret = (unzOpenCurrentFilePassword(reader_, passwordStr.c_str()) == UNZ_OK);
}
if (ret)
has_fileopen_ = true;
return ret;
}
bool CefZipReaderImpl::CloseFile()
{
if (!VerifyContext() || !has_fileopen_)
return false;
has_fileopen_ = false;
has_fileinfo_ = false;
return (unzCloseCurrentFile(reader_) == UNZ_OK);
}
int CefZipReaderImpl::ReadFile(void* buffer, size_t bufferSize)
{
if (!VerifyContext() || !has_fileopen_)
return -1;
return unzReadCurrentFile(reader_, buffer, bufferSize);
}
long CefZipReaderImpl::Tell()
{
if (!VerifyContext() || !has_fileopen_)
return -1;
return unztell(reader_);
}
bool CefZipReaderImpl::Eof()
{
if (!VerifyContext() || !has_fileopen_)
return true;
return (unzeof(reader_) == 1 ? true : false);
}
bool CefZipReaderImpl::GetFileInfo()
{
if (has_fileinfo_)
return true;
char file_name[512] = {0};
unz_file_info file_info;
memset(&file_info, 0, sizeof(file_info));
if (unzGetCurrentFileInfo(reader_, &file_info, file_name, sizeof(file_name),
NULL, 0, NULL, 0) != UNZ_OK) {
return false;
}
has_fileinfo_ = true;
UTF8ToWide(file_name, strlen(file_name), &filename_);
filesize_ = file_info.uncompressed_size;
struct tm time;
memset(&time, 0, sizeof(time));
time.tm_sec = file_info.tmu_date.tm_sec;
time.tm_min = file_info.tmu_date.tm_min;
time.tm_hour = file_info.tmu_date.tm_hour;
time.tm_mday = file_info.tmu_date.tm_mday;
time.tm_mon = file_info.tmu_date.tm_mon;
time.tm_year = file_info.tmu_date.tm_year;
filemodified_ = mktime(&time);
return true;
}
bool CefZipReaderImpl::VerifyContext()
{
if (PlatformThread::CurrentId() != supported_thread_id_) {
// This object should only be accessed from the thread that created it.
NOTREACHED();
return false;
}
return (reader_ != NULL);
}

52
libcef/zip_reader_impl.h Normal file
View File

@ -0,0 +1,52 @@
// Copyright (c) 20010 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.
#ifndef _ZIP_READER_IMPL_H
#define _ZIP_READER_IMPL_H
#include "../include/cef.h"
#include "base/platform_thread.h"
#include "third_party/zlib/contrib/minizip/unzip.h"
#include <sstream>
// Implementation of CefZipReader
class CefZipReaderImpl : public CefThreadSafeBase<CefZipReader>
{
public:
CefZipReaderImpl();
~CefZipReaderImpl();
// Initialize the reader context.
bool Initialize(CefRefPtr<CefStreamReader> stream);
virtual bool MoveToFirstFile();
virtual bool MoveToNextFile();
virtual bool MoveToFile(const std::wstring& fileName, bool caseSensitive);
virtual bool Close();
virtual std::wstring GetFileName();
virtual long GetFileSize();
virtual time_t GetFileLastModified();
virtual bool OpenFile(const std::wstring& password);
virtual bool CloseFile();
virtual int ReadFile(void* buffer, size_t bufferSize);
virtual long Tell();
virtual bool Eof();
bool GetFileInfo();
// Verify that the reader exists and is being accessed from the correct
// thread.
bool VerifyContext();
protected:
unzFile reader_;
bool has_fileopen_;
bool has_fileinfo_;
std::wstring filename_;
long filesize_;
time_t filemodified_;
PlatformThreadId supported_thread_id_;
};
#endif // _ZIP_READER_IMPL_H

180
libcef_dll/cpptoc/zip_reader_cpptoc.cc Normal file
View File

@ -0,0 +1,180 @@
// Copyright (c) 2010 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.
//
// ---------------------------------------------------------------------------
//
// A portion of this file was generated by the CEF translator tool. When
// making changes by hand only do so within the body of existing function
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
#include "libcef_dll/cpptoc/stream_reader_cpptoc.h"
#include "libcef_dll/cpptoc/zip_reader_cpptoc.h"
// GLOBAL FUNCTIONS - Body may be edited by hand.
CEF_EXPORT cef_zip_reader_t* cef_zip_reader_create(cef_stream_reader_t* stream)
{
CefRefPtr<CefZipReader> impl = CefZipReader::Create(
CefStreamReaderCppToC::Unwrap(stream));
if(impl.get())
return CefZipReaderCppToC::Wrap(impl);
return NULL;
}
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK zip_reader_move_to_first_file(struct _cef_zip_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefZipReaderCppToC::Get(self)->MoveToFirstFile();
}
int CEF_CALLBACK zip_reader_move_to_next_file(struct _cef_zip_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefZipReaderCppToC::Get(self)->MoveToNextFile();
}
int CEF_CALLBACK zip_reader_move_to_file(struct _cef_zip_reader_t* self,
const wchar_t* fileName, int caseSensitive)
{
DCHECK(self);
if(!self)
return 0;
std::wstring fileNameStr;
if (fileName)
fileNameStr = fileName;
return CefZipReaderCppToC::Get(self)->MoveToFile(fileNameStr,
caseSensitive ? true : false);
}
int CEF_CALLBACK zip_reader_close(struct _cef_zip_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefZipReaderCppToC::Get(self)->Close();
}
cef_string_t CEF_CALLBACK zip_reader_get_file_name(
struct _cef_zip_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
std::wstring retStr = CefZipReaderCppToC::Get(self)->GetFileName();
if(!retStr.empty())
return cef_string_alloc(retStr.c_str());
return NULL;
}
long CEF_CALLBACK zip_reader_get_file_size(struct _cef_zip_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefZipReaderCppToC::Get(self)->GetFileSize();
}
time_t CEF_CALLBACK zip_reader_get_file_last_modified(
struct _cef_zip_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefZipReaderCppToC::Get(self)->GetFileLastModified();
}
int CEF_CALLBACK zip_reader_open_file(struct _cef_zip_reader_t* self,
const wchar_t* password)
{
DCHECK(self);
if(!self)
return 0;
std::wstring passwordStr;
if (password)
passwordStr = password;
return CefZipReaderCppToC::Get(self)->OpenFile(passwordStr);
}
int CEF_CALLBACK zip_reader_close_file(struct _cef_zip_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefZipReaderCppToC::Get(self)->CloseFile();
}
int CEF_CALLBACK zip_reader_read_file(struct _cef_zip_reader_t* self,
void* buffer, size_t bufferSize)
{
DCHECK(self);
if(!self)
return -1;
return CefZipReaderCppToC::Get(self)->ReadFile(buffer, bufferSize);
}
long CEF_CALLBACK zip_reader_tell(struct _cef_zip_reader_t* self)
{
DCHECK(self);
if(!self)
return -1;
return CefZipReaderCppToC::Get(self)->Tell();
}
int CEF_CALLBACK zip_reader_eof(struct _cef_zip_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefZipReaderCppToC::Get(self)->Eof();
}
// CONSTRUCTOR - Do not edit by hand.
CefZipReaderCppToC::CefZipReaderCppToC(CefZipReader* cls)
: CefCppToC<CefZipReaderCppToC, CefZipReader, cef_zip_reader_t>(cls)
{
struct_.struct_.move_to_first_file = zip_reader_move_to_first_file;
struct_.struct_.move_to_next_file = zip_reader_move_to_next_file;
struct_.struct_.move_to_file = zip_reader_move_to_file;
struct_.struct_.close = zip_reader_close;
struct_.struct_.get_file_name = zip_reader_get_file_name;
struct_.struct_.get_file_size = zip_reader_get_file_size;
struct_.struct_.get_file_last_modified = zip_reader_get_file_last_modified;
struct_.struct_.open_file = zip_reader_open_file;
struct_.struct_.close_file = zip_reader_close_file;
struct_.struct_.read_file = zip_reader_read_file;
struct_.struct_.tell = zip_reader_tell;
struct_.struct_.eof = zip_reader_eof;
}
#ifdef _DEBUG
long CefCppToC<CefZipReaderCppToC, CefZipReader, cef_zip_reader_t>::DebugObjCt =
0;
#endif

34
libcef_dll/cpptoc/zip_reader_cpptoc.h Normal file
View File

@ -0,0 +1,34 @@
// Copyright (c) 2010 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.
//
// ---------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool and should not edited
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
#ifndef _ZIPREADER_CPPTOC_H
#define _ZIPREADER_CPPTOC_H
#ifndef BUILDING_CEF_SHARED
#pragma message("Warning: "__FILE__" may be accessed DLL-side only")
#else // BUILDING_CEF_SHARED
#include "include/cef.h"
#include "include/cef_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefZipReaderCppToC
: public CefCppToC<CefZipReaderCppToC, CefZipReader, cef_zip_reader_t>
{
public:
CefZipReaderCppToC(CefZipReader* cls);
virtual ~CefZipReaderCppToC() {}
};
#endif // BUILDING_CEF_SHARED
#endif // _ZIPREADER_CPPTOC_H

141
libcef_dll/ctocpp/zip_reader_ctocpp.cc Normal file
View File

@ -0,0 +1,141 @@
// Copyright (c) 2010 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.
//
// ---------------------------------------------------------------------------
//
// A portion of this file was generated by the CEF translator tool. When
// making changes by hand only do so within the body of existing static and
// virtual method implementations. See the translator.README.txt file in the
// tools directory for more information.
//
#include "libcef_dll/ctocpp/stream_reader_ctocpp.h"
#include "libcef_dll/ctocpp/zip_reader_ctocpp.h"
// STATIC METHODS - Body may be edited by hand.
CefRefPtr<CefZipReader> CefZipReader::Create(CefRefPtr<CefStreamReader> stream)
{
cef_zip_reader_t* impl = cef_zip_reader_create(
CefStreamReaderCToCpp::Unwrap(stream));
if(impl)
return CefZipReaderCToCpp::Wrap(impl);
return NULL;
}
// VIRTUAL METHODS - Body may be edited by hand.
bool CefZipReaderCToCpp::MoveToFirstFile()
{
if(CEF_MEMBER_MISSING(struct_, move_to_first_file))
return false;
return struct_->move_to_first_file(struct_) ? true : false;
}
bool CefZipReaderCToCpp::MoveToNextFile()
{
if(CEF_MEMBER_MISSING(struct_, move_to_next_file))
return false;
return struct_->move_to_next_file(struct_) ? true : false;
}
bool CefZipReaderCToCpp::MoveToFile(const std::wstring& fileName,
bool caseSensitive)
{
if(CEF_MEMBER_MISSING(struct_, move_to_file))
return false;
return struct_->move_to_file(struct_, fileName.c_str(), caseSensitive) ?
true : false;
}
bool CefZipReaderCToCpp::Close()
{
if(CEF_MEMBER_MISSING(struct_, close))
return false;
return struct_->close(struct_) ? true : false;
}
std::wstring CefZipReaderCToCpp::GetFileName()
{
std::wstring str;
if(CEF_MEMBER_MISSING(struct_, get_file_name))
return str;
cef_string_t cef_str = struct_->get_file_name(struct_);
if(cef_str) {
str = cef_str;
cef_string_free(cef_str);
}
return str;
}
long CefZipReaderCToCpp::GetFileSize()
{
if(CEF_MEMBER_MISSING(struct_, get_file_size))
return -1;
return struct_->get_file_size(struct_);
}
time_t CefZipReaderCToCpp::GetFileLastModified()
{
if(CEF_MEMBER_MISSING(struct_, get_file_last_modified))
return 0;
return struct_->get_file_last_modified(struct_);
}
bool CefZipReaderCToCpp::OpenFile(const std::wstring& password)
{
if(CEF_MEMBER_MISSING(struct_, open_file))
return 0;
return struct_->open_file(struct_, password.c_str()) ? true : false;
}
bool CefZipReaderCToCpp::CloseFile()
{
if(CEF_MEMBER_MISSING(struct_, close_file))
return 0;
return struct_->close_file(struct_) ? true : false;
}
int CefZipReaderCToCpp::ReadFile(void* buffer, size_t bufferSize)
{
if(CEF_MEMBER_MISSING(struct_, read_file))
return -1;
return struct_->read_file(struct_, buffer, bufferSize);
}
long CefZipReaderCToCpp::Tell()
{
if(CEF_MEMBER_MISSING(struct_, tell))
return -1;
return struct_->tell(struct_);
}
bool CefZipReaderCToCpp::Eof()
{
if(CEF_MEMBER_MISSING(struct_, eof))
return false;
return struct_->eof(struct_) ? true : false;
}
#ifdef _DEBUG
long CefCToCpp<CefZipReaderCToCpp, CefZipReader, cef_zip_reader_t>::DebugObjCt =
0;
#endif

50
libcef_dll/ctocpp/zip_reader_ctocpp.h Normal file
View File

@ -0,0 +1,50 @@
// Copyright (c) 2010 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.
//
// -------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool and should not edited
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
#ifndef _ZIPREADER_CTOCPP_H
#define _ZIPREADER_CTOCPP_H
#ifndef USING_CEF_SHARED
#pragma message("Warning: "__FILE__" may be accessed wrapper-side only")
#else // USING_CEF_SHARED
#include "include/cef.h"
#include "include/cef_capi.h"
#include "libcef_dll/ctocpp/ctocpp.h"
// Wrap a C structure with a C++ class.
// This class may be instantiated and accessed wrapper-side only.
class CefZipReaderCToCpp
: public CefCToCpp<CefZipReaderCToCpp, CefZipReader, cef_zip_reader_t>
{
public:
CefZipReaderCToCpp(cef_zip_reader_t* str)
: CefCToCpp<CefZipReaderCToCpp, CefZipReader, cef_zip_reader_t>(str) {}
virtual ~CefZipReaderCToCpp() {}
// CefZipReader methods
virtual bool MoveToFirstFile();
virtual bool MoveToNextFile();
virtual bool MoveToFile(const std::wstring& fileName, bool caseSensitive);
virtual bool Close();
virtual std::wstring GetFileName();
virtual long GetFileSize();
virtual time_t GetFileLastModified();
virtual bool OpenFile(const std::wstring& password);
virtual bool CloseFile();
virtual int ReadFile(void* buffer, size_t bufferSize);
virtual long Tell();
virtual bool Eof();
};
#endif // USING_CEF_SHARED
#endif // _ZIPREADER_CTOCPP_H

2
libcef_dll/libcef_dll.cc
View File

@ -15,6 +15,7 @@
#include "cpptoc/stream_writer_cpptoc.h"
#include "cpptoc/v8value_cpptoc.h"
#include "cpptoc/xml_reader_cpptoc.h"
#include "cpptoc/zip_reader_cpptoc.h"
#include "ctocpp/download_handler_ctocpp.h"
#include "ctocpp/handler_ctocpp.h"
#include "ctocpp/read_handler_ctocpp.h"
@ -49,6 +50,7 @@ CEF_EXPORT void cef_shutdown()
DCHECK(CefStreamWriterCppToC::DebugObjCt == 0);
DCHECK(CefV8ValueCppToC::DebugObjCt == 0);
DCHECK(CefXmlReaderCppToC::DebugObjCt == 0);
DCHECK(CefZipReaderCppToC::DebugObjCt == 0);
DCHECK(CefDownloadHandlerCToCpp::DebugObjCt == 0);
DCHECK(CefHandlerCToCpp::DebugObjCt == 0);
DCHECK(CefReadHandlerCToCpp::DebugObjCt == 0);

67
libcef_dll/wrapper/cef_byte_read_handler.cc Normal file
View File

@ -0,0 +1,67 @@
// Copyright (c) 2010 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 "include/cef_wrapper.h"
#include "base/logging.h"
CefByteReadHandler::CefByteReadHandler(const unsigned char* bytes, size_t size,
CefRefPtr<CefBase> source)
: bytes_(bytes), size_(size), offset_(0), source_(source)
{
}
size_t CefByteReadHandler::Read(void* ptr, size_t size, size_t n)
{
Lock();
size_t s = (size_ - offset_) / size;
size_t ret = min(n, s);
memcpy(ptr, bytes_ + offset_, ret * size);
offset_ += ret * size;
Unlock();
return ret;
}
int CefByteReadHandler::Seek(long offset, int whence)
{
int rv = -1L;
Lock();
switch(whence) {
case SEEK_CUR:
if(offset_ + offset > size_)
break;
offset_ += offset;
rv = offset_;
break;
case SEEK_END:
if(offset > static_cast<long>(size_))
break;
offset_ = size_ - offset;
rv = offset_;
case SEEK_SET:
if(offset > static_cast<long>(size_))
break;
offset_ = offset;
rv = offset_;
break;
}
Unlock();
return rv;
}
long CefByteReadHandler::Tell()
{
Lock();
long rv = offset_;
Unlock();
return rv;
}
int CefByteReadHandler::Eof()
{
Lock();
int rv = (offset_ >= size_);
Unlock();
return rv;
}

163
libcef_dll/wrapper/cef_zip_archive.cc Normal file
View File

@ -0,0 +1,163 @@
// Copyright (c) 2010 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 "include/cef_wrapper.h"
#include "base/logging.h"
#include <algorithm>
namespace {
class CefZipFile : public CefThreadSafeBase<CefZipArchive::File>
{
public:
CefZipFile(size_t size) : data_(size) {}
~CefZipFile() {}
// Returns the read-only data contained in the file.
virtual const unsigned char* GetData() { return &data_[0]; }
// Returns the size of the data in the file.
virtual size_t GetDataSize() { return data_.size(); }
// Returns a CefStreamReader object for streaming the contents of the file.
virtual CefRefPtr<CefStreamReader> GetStreamReader() {
CefRefPtr<CefReadHandler> handler(
new CefByteReadHandler(GetData(), GetDataSize(), this));
return CefStreamReader::CreateForHandler(handler);
}
std::vector<unsigned char>* GetDataVector() { return &data_; }
private:
std::vector<unsigned char> data_;
};
} // namespace
// CefZipArchive implementation
CefZipArchive::CefZipArchive()
{
}
CefZipArchive::~CefZipArchive()
{
}
size_t CefZipArchive::Load(CefRefPtr<CefStreamReader> stream,
bool overwriteExisting)
{
AutoLock lock_scope(this);
CefRefPtr<CefZipReader> reader(CefZipReader::Create(stream));
if (!reader.get())
return 0;
if (!reader->MoveToFirstFile())
return 0;
std::wstring name;
CefRefPtr<CefZipFile> contents;
FileMap::iterator it;
std::vector<unsigned char>* data;
size_t count = 0, size, offset;
do {
size = static_cast<size_t>(reader->GetFileSize());
if (size == 0) {
// Skip directories and empty files.
continue;
}
if (!reader->OpenFile(L""))
break;
name = reader->GetFileName();
std::transform(name.begin(), name.end(), name.begin(), towlower);
it = contents_.find(name);
if (it != contents_.end()) {
if (overwriteExisting)
contents_.erase(it);
else // Skip files that already exist.
continue;
}
contents = new CefZipFile(size);
data = contents->GetDataVector();
offset = 0;
// Read the file contents.
do {
offset += reader->ReadFile(&(*data)[offset], size - offset);
} while (offset < size && !reader->Eof());
DCHECK(offset == size);
reader->CloseFile();
count++;
// Add the file to the map.
contents_.insert(
std::make_pair<std::wstring, CefRefPtr<File> >(name, contents.get()));
} while (reader->MoveToNextFile());
return count;
}
void CefZipArchive::Clear()
{
AutoLock lock_scope(this);
contents_.empty();
}
size_t CefZipArchive::GetFileCount()
{
AutoLock lock_scope(this);
return contents_.size();
}
bool CefZipArchive::HasFile(const std::wstring& fileName)
{
std::wstring str = fileName;
std::transform(str.begin(), str.end(), str.begin(), towlower);
AutoLock lock_scope(this);
FileMap::const_iterator it = contents_.find(str);
return (it != contents_.end());
}
CefRefPtr<CefZipArchive::File> CefZipArchive::GetFile(
const std::wstring& fileName)
{
std::wstring str = fileName;
std::transform(str.begin(), str.end(), str.begin(), towlower);
AutoLock lock_scope(this);
FileMap::const_iterator it = contents_.find(str);
if (it != contents_.end())
return it->second;
return NULL;
}
bool CefZipArchive::RemoveFile(const std::wstring& fileName)
{
std::wstring str = fileName;
std::transform(str.begin(), str.end(), str.begin(), towlower);
AutoLock lock_scope(this);
FileMap::iterator it = contents_.find(str);
if (it != contents_.end()) {
contents_.erase(it);
return true;
}
return false;
}
size_t CefZipArchive::GetFiles(FileMap& map)
{
AutoLock lock_scope(this);
map = contents_;
return contents_.size();
}

2
libcef_dll/wrapper/libcef_dll_wrapper.cc
View File

@ -22,6 +22,7 @@
#include "libcef_dll/ctocpp/stream_writer_ctocpp.h"
#include "libcef_dll/ctocpp/v8value_ctocpp.h"
#include "libcef_dll/ctocpp/xml_reader_ctocpp.h"
#include "libcef_dll/ctocpp/zip_reader_ctocpp.h"
bool CefInitialize(bool multi_threaded_message_loop,
@ -52,6 +53,7 @@ void CefShutdown()
DCHECK(CefStreamWriterCToCpp::DebugObjCt == 0);
DCHECK(CefV8ValueCToCpp::DebugObjCt == 0);
DCHECK(CefXmlReaderCToCpp::DebugObjCt == 0);
DCHECK(CefZipReaderCToCpp::DebugObjCt == 0);
#endif // _DEBUG
}

7
tests/cefclient/cefclient.cpp
View File

@ -3,6 +3,7 @@
// can be found in the LICENSE file.
#include "include/cef.h"
#include "include/cef_wrapper.h"
#include "cefclient.h"
#include "binding_test.h"
#include "download_handler.h"
@ -408,21 +409,21 @@ public:
// Show the uiapp contents
if(LoadBinaryResource(IDS_UIPLUGIN, dwSize, pBytes)) {
resourceStream = CefStreamReader::CreateForHandler(
new ClientReadHandler(pBytes, dwSize));
new CefByteReadHandler(pBytes, dwSize, NULL));
mimeType = L"text/html";
}
} else if(wcsstr(url.c_str(), L"/ps_logo2.png") != NULL) {
// Any time we find "ps_logo2.png" in the URL substitute in our own image
if(LoadBinaryResource(IDS_LOGO, dwSize, pBytes)) {
resourceStream = CefStreamReader::CreateForHandler(
new ClientReadHandler(pBytes, dwSize));
new CefByteReadHandler(pBytes, dwSize, NULL));
mimeType = L"image/png";
}
} else if(wcsstr(url.c_str(), L"/logoball.png") != NULL) {
// Load the "logoball.png" image resource.
if(LoadBinaryResource(IDS_LOGOBALL, dwSize, pBytes)) {
resourceStream = CefStreamReader::CreateForHandler(
new ClientReadHandler(pBytes, dwSize));
new CefByteReadHandler(pBytes, dwSize, NULL));
mimeType = L"image/png";
}
}

65
tests/cefclient/resource_util.cpp
View File

@ -4,7 +4,6 @@
#include "resource_util.h"
bool LoadBinaryResource(int binaryId, DWORD &dwSize, LPBYTE &pBytes)
{
extern HINSTANCE hInst;
@ -24,67 +23,3 @@ bool LoadBinaryResource(int binaryId, DWORD &dwSize, LPBYTE &pBytes)
return false;
}
// ClientReadHandler implementation
ClientReadHandler::ClientReadHandler(LPBYTE pBytes, DWORD dwSize)
: bytes_(pBytes), size_(dwSize), offset_(0) {}
size_t ClientReadHandler::Read(void* ptr, size_t size, size_t n)
{
Lock();
size_t s = (size_ - offset_) / size;
size_t ret = min(n, s);
memcpy(ptr, bytes_ + offset_, ret * size);
offset_ += ret * size;
Unlock();
return ret;
}
int ClientReadHandler::Seek(long offset, int whence)
{
int rv = -1L;
Lock();
switch(whence) {
case SEEK_CUR:
if(offset_ + offset > size_) {
break;
}
offset_ += offset;
rv = offset_;
break;
case SEEK_END:
if(offset > (int)size_) {
break;
}
offset_ = size_ - offset;
rv = offset_;
case SEEK_SET:
if(offset > (int)size_) {
break;
}
offset_ = offset;
rv = offset_;
break;
}
Unlock();
return rv;
}
long ClientReadHandler::Tell()
{
Lock();
long rv = offset_;
Unlock();
return rv;
}
int ClientReadHandler::Eof()
{
Lock();
int rv = (offset_ >= size_);
Unlock();
return rv;
}

29
tests/cefclient/resource_util.h
View File

@ -6,34 +6,5 @@
#include "include/cef.h"
#ifndef min
#define min(a,b) ((a)<(b)?(a):(b))
#endif
// Load a resource of type BINARY
bool LoadBinaryResource(int binaryId, DWORD &dwSize, LPBYTE &pBytes);
// Implementation of the stream read handler for reading in-memory data.
class ClientReadHandler : public CefThreadSafeBase<CefReadHandler>
{
public:
ClientReadHandler(LPBYTE pBytes, DWORD dwSize);
// Read raw binary data.
virtual size_t Read(void* ptr, size_t size, size_t n);
// Seek to the specified offset position. |whence| may be any one of
// SEEK_CUR, SEEK_END or SEEK_SET.
virtual int Seek(long offset, int whence);
// Return the current offset position.
virtual long Tell();
// Return non-zero if at end of file.
virtual int Eof();
private:
LPBYTE bytes_;
DWORD size_, offset_;
};

1
tests/cefclient/scheme_test.cpp
View File

@ -2,6 +2,7 @@
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
#include "include/cef_wrapper.h"
#include "scheme_test.h"
#include "string_util.h"
#include "resource_util.h"

254
tests/unittests/zip_reader_unittest.cc Normal file
View File

@ -0,0 +1,254 @@
// Copyright (c) 2010 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 "include/cef.h"
#include "include/cef_wrapper.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace {
unsigned char g_test_zip[] = {
0x50, 0x4b, 0x03, 0x04, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x67, 0x7f,
0x57, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61,
0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x2f, 0x50, 0x4b, 0x03, 0x04, 0x0a,
0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x7f, 0x57, 0x3d, 0xf8, 0x47, 0x0c,
0xc6, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00,
0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x72, 0x63, 0x68, 0x69, 0x76,
0x65, 0x2f, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x31, 0x2e, 0x74, 0x78, 0x74,
0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x6f, 0x66, 0x20,
0x66, 0x69, 0x6c, 0x65, 0x20, 0x31, 0x2e, 0x50, 0x4b, 0x03, 0x04, 0x0a,
0x00, 0x00, 0x00, 0x00, 0x00, 0x53, 0x7f, 0x57, 0x3d, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00,
0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x72, 0x63, 0x68, 0x69, 0x76,
0x65, 0x2f, 0x66, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x20, 0x31, 0x2f, 0x50,
0x4b, 0x03, 0x04, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0x7f, 0x57,
0x3d, 0x43, 0xe3, 0x11, 0x5f, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00,
0x00, 0x21, 0x00, 0x00, 0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x72,
0x63, 0x68, 0x69, 0x76, 0x65, 0x2f, 0x66, 0x6f, 0x6c, 0x64, 0x65, 0x72,
0x20, 0x31, 0x2f, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x31, 0x61, 0x2e, 0x74,
0x78, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x6f,
0x66, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x31, 0x41, 0x2e, 0x50, 0x4b,
0x03, 0x04, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x7f, 0x57, 0x3d,
0x80, 0xb0, 0x3c, 0x74, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
0x21, 0x00, 0x00, 0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x72, 0x63,
0x68, 0x69, 0x76, 0x65, 0x2f, 0x66, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x20,
0x31, 0x2f, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x31, 0x62, 0x2e, 0x74, 0x78,
0x74, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x6f, 0x66,
0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x31, 0x42, 0x2e, 0x50, 0x4b, 0x03,
0x04, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x7f, 0x57, 0x3d, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20,
0x00, 0x00, 0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x72, 0x63, 0x68,
0x69, 0x76, 0x65, 0x2f, 0x66, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x20, 0x31,
0x2f, 0x66, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x20, 0x31, 0x61, 0x2f, 0x50,
0x4b, 0x03, 0x04, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0x7f, 0x57,
0x3d, 0x15, 0xed, 0x04, 0x2c, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00,
0x00, 0x2c, 0x00, 0x00, 0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x72,
0x63, 0x68, 0x69, 0x76, 0x65, 0x2f, 0x66, 0x6f, 0x6c, 0x64, 0x65, 0x72,
0x20, 0x31, 0x2f, 0x66, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x20, 0x31, 0x61,
0x2f, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x31, 0x61, 0x31, 0x2e, 0x74, 0x78,
0x74, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x6f, 0x66,
0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x31, 0x41, 0x31, 0x2e, 0x50, 0x4b,
0x03, 0x04, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, 0x7f, 0x57, 0x3d,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x16, 0x00, 0x00, 0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x72, 0x63,
0x68, 0x69, 0x76, 0x65, 0x2f, 0x66, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x20,
0x32, 0x2f, 0x50, 0x4b, 0x03, 0x04, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00,
0x02, 0x80, 0x57, 0x3d, 0x1a, 0x5d, 0x57, 0x5d, 0x14, 0x00, 0x00, 0x00,
0x14, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x74, 0x65, 0x73, 0x74,
0x5f, 0x61, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x2f, 0x66, 0x6f, 0x6c,
0x64, 0x65, 0x72, 0x20, 0x32, 0x2f, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x32,
0x61, 0x2e, 0x74, 0x78, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74,
0x73, 0x20, 0x6f, 0x66, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x32, 0x41,
0x2e, 0x50, 0x4b, 0x01, 0x02, 0x14, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00,
0x00, 0x67, 0x7f, 0x57, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x74,
0x65, 0x73, 0x74, 0x5f, 0x61, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x2f,
0x50, 0x4b, 0x01, 0x02, 0x14, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00,
0x70, 0x7f, 0x57, 0x3d, 0xf8, 0x47, 0x0c, 0xc6, 0x13, 0x00, 0x00, 0x00,
0x13, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x74, 0x65,
0x73, 0x74, 0x5f, 0x61, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x2f, 0x66,
0x69, 0x6c, 0x65, 0x20, 0x31, 0x2e, 0x74, 0x78, 0x74, 0x50, 0x4b, 0x01,
0x02, 0x14, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x53, 0x7f, 0x57,
0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
0x00, 0x00, 0x00, 0x73, 0x00, 0x00, 0x00, 0x74, 0x65, 0x73, 0x74, 0x5f,
0x61, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x2f, 0x66, 0x6f, 0x6c, 0x64,
0x65, 0x72, 0x20, 0x31, 0x2f, 0x50, 0x4b, 0x01, 0x02, 0x14, 0x00, 0x0a,
0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0x7f, 0x57, 0x3d, 0x43, 0xe3, 0x11,
0x5f, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xa7,
0x00, 0x00, 0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x72, 0x63, 0x68,
0x69, 0x76, 0x65, 0x2f, 0x66, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x20, 0x31,
0x2f, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x31, 0x61, 0x2e, 0x74, 0x78, 0x74,
0x50, 0x4b, 0x01, 0x02, 0x14, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00,
0x78, 0x7f, 0x57, 0x3d, 0x80, 0xb0, 0x3c, 0x74, 0x14, 0x00, 0x00, 0x00,
0x14, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x00, 0x00, 0x74, 0x65,
0x73, 0x74, 0x5f, 0x61, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x2f, 0x66,
0x6f, 0x6c, 0x64, 0x65, 0x72, 0x20, 0x31, 0x2f, 0x66, 0x69, 0x6c, 0x65,
0x20, 0x31, 0x62, 0x2e, 0x74, 0x78, 0x74, 0x50, 0x4b, 0x01, 0x02, 0x14,
0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x7f, 0x57, 0x3d, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
0x00, 0x4d, 0x01, 0x00, 0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x72,
0x63, 0x68, 0x69, 0x76, 0x65, 0x2f, 0x66, 0x6f, 0x6c, 0x64, 0x65, 0x72,
0x20, 0x31, 0x2f, 0x66, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x20, 0x31, 0x61,
0x2f, 0x50, 0x4b, 0x01, 0x02, 0x14, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00,
0x00, 0x7c, 0x7f, 0x57, 0x3d, 0x15, 0xed, 0x04, 0x2c, 0x15, 0x00, 0x00,
0x00, 0x15, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x8b, 0x01, 0x00, 0x00, 0x74,
0x65, 0x73, 0x74, 0x5f, 0x61, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x2f,
0x66, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x20, 0x31, 0x2f, 0x66, 0x6f, 0x6c,
0x64, 0x65, 0x72, 0x20, 0x31, 0x61, 0x2f, 0x66, 0x69, 0x6c, 0x65, 0x20,
0x31, 0x61, 0x31, 0x2e, 0x74, 0x78, 0x74, 0x50, 0x4b, 0x01, 0x02, 0x14,
0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, 0x7f, 0x57, 0x3d, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
0x00, 0xea, 0x01, 0x00, 0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x72,
0x63, 0x68, 0x69, 0x76, 0x65, 0x2f, 0x66, 0x6f, 0x6c, 0x64, 0x65, 0x72,
0x20, 0x32, 0x2f, 0x50, 0x4b, 0x01, 0x02, 0x14, 0x00, 0x0a, 0x00, 0x00,
0x00, 0x00, 0x00, 0x02, 0x80, 0x57, 0x3d, 0x1a, 0x5d, 0x57, 0x5d, 0x14,
0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x1e, 0x02, 0x00,
0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x72, 0x63, 0x68, 0x69, 0x76,
0x65, 0x2f, 0x66, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x20, 0x32, 0x2f, 0x66,
0x69, 0x6c, 0x65, 0x20, 0x32, 0x61, 0x2e, 0x74, 0x78, 0x74, 0x50, 0x4b,
0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x09, 0x00, 0x9d, 0x02,
0x00, 0x00, 0x71, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00
};
} // namespace
// Test Zip reading.
TEST(ZipReaderTest, Read)
{
// Create the stream reader.
CefRefPtr<CefStreamReader> stream(
CefStreamReader::CreateForData(g_test_zip, sizeof(g_test_zip) - 1));
ASSERT_TRUE(stream.get() != NULL);
// Create the Zip reader.
CefRefPtr<CefZipReader> reader(CefZipReader::Create(stream));
ASSERT_TRUE(reader.get() != NULL);
char buff[25];
// Walk through the archive contents.
ASSERT_TRUE(reader->MoveToFirstFile());
ASSERT_EQ(reader->GetFileName(), L"test_archive/");
ASSERT_EQ(reader->GetFileSize(), 0);
ASSERT_TRUE(reader->MoveToNextFile());
ASSERT_EQ(reader->GetFileName(), L"test_archive/file 1.txt");
ASSERT_EQ(reader->GetFileSize(), 19);
ASSERT_TRUE(reader->OpenFile(L""));
ASSERT_EQ(reader->ReadFile(buff, sizeof(buff)), 19);
ASSERT_TRUE(!strncmp(buff, "Contents of file 1.", 19));
ASSERT_TRUE(reader->MoveToNextFile());
ASSERT_EQ(reader->GetFileName(), L"test_archive/folder 1/");
ASSERT_EQ(reader->GetFileSize(), 0);
ASSERT_TRUE(reader->MoveToNextFile());
ASSERT_EQ(reader->GetFileName(), L"test_archive/folder 1/file 1a.txt");
ASSERT_EQ(reader->GetFileSize(), 20);
ASSERT_TRUE(reader->OpenFile(L""));
ASSERT_EQ(reader->ReadFile(buff, sizeof(buff)), 20);
ASSERT_TRUE(reader->CloseFile());
ASSERT_TRUE(!strncmp(buff, "Contents of file 1A.", 20));
ASSERT_TRUE(reader->MoveToNextFile());
ASSERT_EQ(reader->GetFileName(), L"test_archive/folder 1/file 1b.txt");
ASSERT_EQ(reader->GetFileSize(), 20);
ASSERT_TRUE(reader->OpenFile(L""));
ASSERT_EQ(reader->ReadFile(buff, sizeof(buff)), 20);
ASSERT_TRUE(reader->CloseFile());
ASSERT_TRUE(!strncmp(buff, "Contents of file 1B.", 20));
ASSERT_TRUE(reader->MoveToNextFile());
ASSERT_EQ(reader->GetFileName(), L"test_archive/folder 1/folder 1a/");
ASSERT_EQ(reader->GetFileSize(), 0);
ASSERT_TRUE(reader->MoveToNextFile());
ASSERT_EQ(reader->GetFileName(),
L"test_archive/folder 1/folder 1a/file 1a1.txt");
ASSERT_EQ(reader->GetFileSize(), 21);
ASSERT_TRUE(reader->OpenFile(L""));
ASSERT_EQ(reader->ReadFile(buff, sizeof(buff)), 21);
ASSERT_TRUE(reader->CloseFile());
ASSERT_TRUE(!strncmp(buff, "Contents of file 1A1.", 21));
ASSERT_TRUE(reader->MoveToNextFile());
ASSERT_EQ(reader->GetFileName(), L"test_archive/folder 2/");
ASSERT_EQ(reader->GetFileSize(), 0);
ASSERT_TRUE(reader->MoveToNextFile());
ASSERT_EQ(reader->GetFileName(), L"test_archive/folder 2/file 2a.txt");
ASSERT_EQ(reader->GetFileSize(), 20);
ASSERT_TRUE(reader->OpenFile(L""));
ASSERT_EQ(reader->ReadFile(buff, sizeof(buff)), 20);
ASSERT_TRUE(reader->CloseFile());
ASSERT_TRUE(!strncmp(buff, "Contents of file 2A.", 20));
ASSERT_FALSE(reader->MoveToNextFile());
// Try seeking a particular file
ASSERT_TRUE(reader->MoveToFile(L"TEST_ARCHIVE/FOLDER 1/FILE 1B.TXT", false));
ASSERT_EQ(reader->GetFileName(), L"test_archive/folder 1/file 1b.txt");
ASSERT_EQ(reader->GetFileSize(), 20);
ASSERT_TRUE(reader->OpenFile(L""));
ASSERT_EQ(reader->ReadFile(buff, sizeof(buff)), 20);
ASSERT_TRUE(reader->CloseFile());
ASSERT_TRUE(!strncmp(buff, "Contents of file 1B.", 20));
ASSERT_TRUE(reader->MoveToFile(L"test_archive/folder 1/file 1b.txt", true));
ASSERT_FALSE(reader->MoveToFile(L"test_archive/folder 1/FILE 1B.txt", true));
ASSERT_TRUE(reader->Close());
}
// Test CefZipArchive object.
TEST(ZipReaderTest, ReadArchive)
{
// Create the stream reader.
CefRefPtr<CefStreamReader> stream(
CefStreamReader::CreateForData(g_test_zip, sizeof(g_test_zip) - 1));
ASSERT_TRUE(stream.get() != NULL);
// Create the Zip archive object.
CefRefPtr<CefZipArchive> archive(new CefZipArchive());
ASSERT_EQ(archive->Load(stream, false), 5);
ASSERT_TRUE(archive->HasFile(L"test_archive/file 1.txt"));
ASSERT_TRUE(archive->HasFile(L"test_archive/folder 1/file 1a.txt"));
ASSERT_TRUE(archive->HasFile(L"test_archive/FOLDER 1/file 1b.txt"));
ASSERT_TRUE(archive->HasFile(L"test_archive/folder 1/folder 1a/file 1a1.txt"));
ASSERT_TRUE(archive->HasFile(L"test_archive/folder 2/file 2a.txt"));
// Test content retrieval.
CefRefPtr<CefZipArchive::File> file;
file = archive->GetFile(L"test_archive/folder 2/file 2a.txt");
ASSERT_TRUE(file.get());
ASSERT_EQ(file->GetDataSize(), 20);
ASSERT_TRUE(!strncmp(reinterpret_cast<const char*>(file->GetData()),
"Contents of file 2A.", 20));
// Test stream reading.
CefRefPtr<CefStreamReader> reader(file->GetStreamReader());
ASSERT_TRUE(reader.get());
char buff[8];
ASSERT_EQ(reader->Read(buff, 1, 8), 8);
ASSERT_TRUE(!strncmp(buff, "Contents", 8));
ASSERT_EQ(reader->Read(buff, 1, 8), 8);
ASSERT_TRUE(!strncmp(buff, " of file", 8));
ASSERT_EQ(reader->Read(buff, 1, 8), 4);
ASSERT_TRUE(!strncmp(buff, " 2A.", 4));
ASSERT_TRUE(reader->Eof());
}

1
tools/cef_parser.py
View File

@ -1073,6 +1073,7 @@ class obj_analysis:
'long' : 'long',
'unsigned long' : 'unsigned long',
'size_t' : 'size_t',
'time_t' : 'time_t',
'bool' : 'int',
'CefWindowHandle' : 'cef_window_handle_t',
'CefRect' : 'cef_rect_t',