This is the ZIP Unpacker extension used in Chrome OS to support reading and unpacking of zip archives.
Since the code is built with NaCl, you'll need its toolchain.
$ cd third-party $ make nacl_sdk
We'll use libraries from webports.
$ cd third-party $ make depot_tools $ make webports
First install npm using your normal packaging system. On Debian, you'll want something like:
$ sudo apt-get install npm
Then install the npm modules that we require. Do this in the root of the unpacker repo.
$ npm install bower 'vulcanize@<0.8'
Once done, install the libarchive-fork/ from third-party/ of the unpacker project. Note that you cannot use libarchive nor libarchive-dev packages from webports at this moment, as not all patches in the fork are upstreamed.
$ cd third-party $ make libarchive-fork
Polymer is used for UI. In order to fetch it, in the same directory type:
$ make polymer
Build the PNaCl module.
$ cd unpacker $ make [debug]
The package can be found in the release or debug directory. You can run it directly from there using Chrome's “Load unpacked extension” feature, or you can zip it up for posting to the Chrome Web Store.
$ zip -r release.zip release/
Once it's loaded, you should be able to open ZIP archives in the Files app.
Paths that aren't linked below are dynamically created at build time.
Some high level points to remember: the JS side reacts to user events and is the only part that has access to actual data on disk. It uses the NaCl module to do all the data parsing (e.g. gzip & tar), but it has to both send a request to the module (“parse this archive”), and respond to requests from the module when the module needs to read actual bytes on disk.
When the extension loads, background.js registers everything and goes idle.
When the Files app wants to mount an archive, callbacks in app.js unpacker.app
are called to initialize the NaCl runtime. Creates an unpacker.Volume
object for each mounted archive.
Requests on the archive (directory listing, metadata lookups, reading files) are routed through app.js unpacker.app
and to volume.js unpacker.Volume
. Then they are sent to the low level decompressor.js unpacker.Decompressor
which talks to the NaCl module using the request.js unpacker.request
protocol. Responses are passed back up.
When the NaCl module is loaded, module.cc NaclArchiveModule
is instantiated. That instantiates NaclArchiveInstance
for initial JS message entry points. It instantiates JavaScriptMessageSender
for sending requests back to JS.
When JS requests come in, module.cc NaclArchiveInstance
will create volume.h Volume
objects on the fly, and pass requests down to them (using the protocol defined in request.h request::*
).
volume.h Volume
objects in turn use the volume_archive.h VolumeArchive
abstract interface to handle requests from the JS side (using the protocol defined in request.h request:**
). This way the lower levels don't have to deal with JS directly.
volume_archive_libarchive.cc VolumeArchiveLibarchive
implements the VolumeArchive
interface and uses libarchive as its backend to do all the decompression & archive format processing.
But NaCl code doesn't have access to any files or data itself. So the volume_reader.h VolumeReader
abstract interface is passed to it to provide the low level data read functions. The volume_reader_javascript_stream.cc VolumeReaderJavaScriptStream
implements that by passing requests back up to the JS side via the javascript_requestor_interface.h JavaScriptRequestorInterface
interface (which was passed down to it).
So requests (mount an archive, read a file, etc...) generally follow the path:
request::*
NaclArchiveModule
-> NaclArchiveModule
-> request::*
Volume
VolumeArchive
VolumeArchiveLibarchive
VolumeReader
VolumeReaderJavaScriptStream
JavaScriptRequestorInterface
JavaScriptRequestor
JavaScriptMessageSenderInterface
JavaScriptMessageSender
-> request::*
Then once VolumeArchive
has processed the raw data stream, it can return results to the Volume
object which takes care of posting JS status messages back to the Chrome side.
Here‘s the JavaScript code that matters. A few files have very specific purposes and can be ignored at a high level, so they’re in a separate section.
unpacker.app
unpacker.Volume
objects.unpacker.Volume
unpacker.Volume
instance.unpacker.Decompressor
unpacker.Volume
requests.unpacker.request
protocol.unpacker.request
unpacker.PassphraseManager
These are the boilerplate/simple JavaScript files you can generally ignore.
unpacker.types
unpacker
unpacker.*
namespace.Here's the NaCl layout.
JavaScriptMessageSenderInterface
interface so the rest of NaCl code can easily send messages back up.JavaScriptRequestorInterface
interface for talking to JS side.Volume
class that encompasses a high level volume.VolumeArchive
.JavaScriptRequestorInterface
interface.VolumeArchive
interface for handling specific archive formats.VolumeArchive
using the libarchive project.VolumeReader
interface for low level reading of data.VolumeReader
.JavaScriptRequestorInterface
to get data from the JS side.To see debug messages open chrome from a terminal and check the output. For output redirection see https://developer.chrome.com/native-client/devguide/devcycle/debugging.
Install Karma for tests runner, Mocha for asynchronous testings, Chai for assertions, and Sinon for spies and stubs.
$ npm install --save-dev \ karma karma-chrome-launcher karma-cli \ mocha karma-mocha karma-chai chai karma-sinon sinon # Run tests: $ cd unpacker-test $ ./run_js_tests.sh # JavaScript tests. $ ./run_cpp_tests.sh # C++ tests. # Check JavaScript code using the Closure JS Compiler. # See https://www.npmjs.com/package/closurecompiler $ cd unpacker $ npm install google-closure-compiler $ bash check_js_for_errors.sh