mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-06 09:05:45 +00:00
504 lines
12 KiB
C++
504 lines
12 KiB
C++
/* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
|
|
/* vim: set ts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "File.h"
|
|
|
|
#include "nsDOMFile.h"
|
|
#include "nsDOMBlobBuilder.h"
|
|
#include "nsError.h"
|
|
|
|
#include "jsapi.h"
|
|
#include "jsfriendapi.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsJSUtils.h"
|
|
#include "nsString.h"
|
|
|
|
#include "mozilla/dom/Exceptions.h"
|
|
#include "WorkerInlines.h"
|
|
#include "WorkerPrivate.h"
|
|
|
|
USING_WORKERS_NAMESPACE
|
|
using mozilla::dom::Throw;
|
|
|
|
namespace {
|
|
|
|
class Blob
|
|
{
|
|
// Blob should never be instantiated.
|
|
Blob();
|
|
~Blob();
|
|
|
|
static const JSClass sClass;
|
|
static const JSPropertySpec sProperties[];
|
|
static const JSFunctionSpec sFunctions[];
|
|
|
|
public:
|
|
static JSObject*
|
|
InitClass(JSContext* aCx, JS::Handle<JSObject*> aObj)
|
|
{
|
|
return JS_InitClass(aCx, aObj, JS::NullPtr(), &sClass, Construct, 0,
|
|
sProperties, sFunctions, nullptr, nullptr);
|
|
}
|
|
|
|
static JSObject*
|
|
Create(JSContext* aCx, nsIDOMBlob* aBlob)
|
|
{
|
|
MOZ_ASSERT(SameCOMIdentity(static_cast<nsISupports*>(aBlob), aBlob));
|
|
|
|
JSObject* obj = JS_NewObject(aCx, &sClass, JS::NullPtr(), JS::NullPtr());
|
|
if (obj) {
|
|
JS_SetPrivate(obj, aBlob);
|
|
NS_ADDREF(aBlob);
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
static nsIDOMBlob*
|
|
GetPrivate(JSObject* aObj);
|
|
|
|
private:
|
|
static nsIDOMBlob*
|
|
GetInstancePrivate(JSContext* aCx, JS::Handle<JSObject*> aObj, const char* aFunctionName)
|
|
{
|
|
nsIDOMBlob* blob = GetPrivate(aObj);
|
|
if (blob) {
|
|
return blob;
|
|
}
|
|
|
|
JS_ReportErrorNumber(aCx, js_GetErrorMessage, nullptr,
|
|
JSMSG_INCOMPATIBLE_PROTO, sClass.name, aFunctionName,
|
|
JS_GetClass(aObj)->name);
|
|
return nullptr;
|
|
}
|
|
|
|
static nsIDOMBlob*
|
|
Unwrap(JSContext* aCx, JSObject* aObj)
|
|
{
|
|
return GetPrivate(aObj);
|
|
}
|
|
|
|
static bool
|
|
Construct(JSContext* aCx, unsigned aArgc, jsval* aVp)
|
|
{
|
|
JS::CallArgs args = CallArgsFromVp(aArgc, aVp);
|
|
|
|
nsRefPtr<DOMMultipartFileImpl> fileImpl = new DOMMultipartFileImpl();
|
|
nsRefPtr<mozilla::dom::DOMFile> file = new mozilla::dom::DOMFile(fileImpl);
|
|
|
|
nsresult rv = fileImpl->InitBlob(aCx, args.length(), args.array(), Unwrap);
|
|
if (NS_FAILED(rv)) {
|
|
return Throw(aCx, rv);
|
|
}
|
|
|
|
JSObject* obj = file::CreateBlob(aCx, file);
|
|
if (!obj) {
|
|
return false;
|
|
}
|
|
|
|
args.rval().setObject(*obj);
|
|
return true;
|
|
}
|
|
|
|
static void
|
|
Finalize(JSFreeOp* aFop, JSObject* aObj)
|
|
{
|
|
MOZ_ASSERT(JS_GetClass(aObj) == &sClass);
|
|
|
|
nsIDOMBlob* blob = GetPrivate(aObj);
|
|
NS_IF_RELEASE(blob);
|
|
}
|
|
|
|
static bool
|
|
IsBlob(JS::Handle<JS::Value> v)
|
|
{
|
|
return v.isObject() && GetPrivate(&v.toObject()) != nullptr;
|
|
}
|
|
|
|
static bool
|
|
GetSizeImpl(JSContext* aCx, JS::CallArgs aArgs)
|
|
{
|
|
JS::Rooted<JSObject*> obj(aCx, &aArgs.thisv().toObject());
|
|
nsIDOMBlob* blob = GetInstancePrivate(aCx, obj, "size");
|
|
MOZ_ASSERT(blob);
|
|
|
|
uint64_t size;
|
|
if (NS_FAILED(blob->GetSize(&size))) {
|
|
return Throw(aCx, NS_ERROR_DOM_FILE_NOT_READABLE_ERR);
|
|
}
|
|
|
|
aArgs.rval().setNumber(double(size));
|
|
return true;
|
|
}
|
|
|
|
static bool
|
|
GetSize(JSContext* aCx, unsigned aArgc, JS::Value* aVp)
|
|
{
|
|
JS::CallArgs args = JS::CallArgsFromVp(aArgc, aVp);
|
|
return JS::CallNonGenericMethod<IsBlob, GetSizeImpl>(aCx, args);
|
|
}
|
|
|
|
static bool
|
|
GetTypeImpl(JSContext* aCx, JS::CallArgs aArgs)
|
|
{
|
|
JS::Rooted<JSObject*> obj(aCx, &aArgs.thisv().toObject());
|
|
nsIDOMBlob* blob = GetInstancePrivate(aCx, obj, "type");
|
|
MOZ_ASSERT(blob);
|
|
|
|
nsString type;
|
|
if (NS_FAILED(blob->GetType(type))) {
|
|
return Throw(aCx, NS_ERROR_DOM_FILE_NOT_READABLE_ERR);
|
|
}
|
|
|
|
JSString* jsType = JS_NewUCStringCopyN(aCx, type.get(), type.Length());
|
|
if (!jsType) {
|
|
return false;
|
|
}
|
|
|
|
aArgs.rval().setString(jsType);
|
|
return true;
|
|
}
|
|
|
|
static bool
|
|
GetType(JSContext* aCx, unsigned aArgc, JS::Value* aVp)
|
|
{
|
|
JS::CallArgs args = JS::CallArgsFromVp(aArgc, aVp);
|
|
return JS::CallNonGenericMethod<IsBlob, GetTypeImpl>(aCx, args);
|
|
}
|
|
|
|
static bool
|
|
Slice(JSContext* aCx, unsigned aArgc, jsval* aVp)
|
|
{
|
|
JS::CallArgs args = JS::CallArgsFromVp(aArgc, aVp);
|
|
|
|
JS::Rooted<JSObject*> obj(aCx, args.thisv().toObjectOrNull());
|
|
if (!obj) {
|
|
return false;
|
|
}
|
|
|
|
nsIDOMBlob* blob = GetInstancePrivate(aCx, obj, "slice");
|
|
if (!blob) {
|
|
return false;
|
|
}
|
|
|
|
double start = 0, end = 0;
|
|
JS::Rooted<JSString*> jsContentType(aCx, JS_GetEmptyString(JS_GetRuntime(aCx)));
|
|
if (!JS_ConvertArguments(aCx, args, "/IIS", &start,
|
|
&end, jsContentType.address())) {
|
|
return false;
|
|
}
|
|
|
|
nsAutoJSString contentType;
|
|
if (!contentType.init(aCx, jsContentType)) {
|
|
return false;
|
|
}
|
|
|
|
uint8_t optionalArgc = aArgc;
|
|
nsCOMPtr<nsIDOMBlob> rtnBlob;
|
|
if (NS_FAILED(blob->Slice(static_cast<uint64_t>(start),
|
|
static_cast<uint64_t>(end),
|
|
contentType, optionalArgc,
|
|
getter_AddRefs(rtnBlob)))) {
|
|
return Throw(aCx, NS_ERROR_DOM_FILE_NOT_READABLE_ERR);
|
|
}
|
|
|
|
JSObject* rtnObj = file::CreateBlob(aCx, rtnBlob);
|
|
if (!rtnObj) {
|
|
return false;
|
|
}
|
|
|
|
args.rval().setObject(*rtnObj);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
const JSClass Blob::sClass = {
|
|
"Blob",
|
|
JSCLASS_HAS_PRIVATE,
|
|
JS_PropertyStub, JS_DeletePropertyStub, JS_PropertyStub, JS_StrictPropertyStub,
|
|
JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, Finalize
|
|
};
|
|
|
|
const JSPropertySpec Blob::sProperties[] = {
|
|
JS_PSGS("size", GetSize, GetterOnlyJSNative, JSPROP_ENUMERATE),
|
|
JS_PSGS("type", GetType, GetterOnlyJSNative, JSPROP_ENUMERATE),
|
|
JS_PS_END
|
|
};
|
|
|
|
const JSFunctionSpec Blob::sFunctions[] = {
|
|
JS_FN("slice", Slice, 1, JSPROP_ENUMERATE),
|
|
JS_FS_END
|
|
};
|
|
|
|
class File : public Blob
|
|
{
|
|
// File should never be instantiated.
|
|
File();
|
|
~File();
|
|
|
|
static const JSClass sClass;
|
|
static const JSPropertySpec sProperties[];
|
|
|
|
public:
|
|
static JSObject*
|
|
InitClass(JSContext* aCx, JS::Handle<JSObject*> aObj, JS::Handle<JSObject*> aParentProto)
|
|
{
|
|
return JS_InitClass(aCx, aObj, aParentProto, &sClass, Construct, 0,
|
|
sProperties, nullptr, nullptr, nullptr);
|
|
}
|
|
|
|
static JSObject*
|
|
Create(JSContext* aCx, nsIDOMFile* aFile)
|
|
{
|
|
MOZ_ASSERT(SameCOMIdentity(static_cast<nsISupports*>(aFile), aFile));
|
|
|
|
JSObject* obj = JS_NewObject(aCx, &sClass, JS::NullPtr(), JS::NullPtr());
|
|
if (obj) {
|
|
JS_SetPrivate(obj, aFile);
|
|
NS_ADDREF(aFile);
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
static nsIDOMFile*
|
|
GetPrivate(JSObject* aObj)
|
|
{
|
|
if (aObj) {
|
|
const JSClass* classPtr = JS_GetClass(aObj);
|
|
if (classPtr == &sClass) {
|
|
nsISupports* priv = static_cast<nsISupports*>(JS_GetPrivate(aObj));
|
|
nsCOMPtr<nsIDOMFile> file = do_QueryInterface(priv);
|
|
MOZ_ASSERT_IF(priv, file);
|
|
return file;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
static const JSClass*
|
|
Class()
|
|
{
|
|
return &sClass;
|
|
}
|
|
|
|
private:
|
|
static nsIDOMFile*
|
|
GetInstancePrivate(JSContext* aCx, JS::Handle<JSObject*> aObj, const char* aFunctionName)
|
|
{
|
|
nsIDOMFile* file = GetPrivate(aObj);
|
|
if (file) {
|
|
return file;
|
|
}
|
|
|
|
JS_ReportErrorNumber(aCx, js_GetErrorMessage, nullptr,
|
|
JSMSG_INCOMPATIBLE_PROTO, sClass.name, aFunctionName,
|
|
JS_GetClass(aObj)->name);
|
|
return nullptr;
|
|
}
|
|
|
|
static bool
|
|
Construct(JSContext* aCx, unsigned aArgc, jsval* aVp)
|
|
{
|
|
JS_ReportErrorNumber(aCx, js_GetErrorMessage, nullptr,
|
|
JSMSG_WRONG_CONSTRUCTOR,
|
|
sClass.name);
|
|
return false;
|
|
}
|
|
|
|
static void
|
|
Finalize(JSFreeOp* aFop, JSObject* aObj)
|
|
{
|
|
MOZ_ASSERT(JS_GetClass(aObj) == &sClass);
|
|
|
|
nsIDOMFile* file = GetPrivate(aObj);
|
|
NS_IF_RELEASE(file);
|
|
}
|
|
|
|
static bool
|
|
IsFile(JS::Handle<JS::Value> v)
|
|
{
|
|
return v.isObject() && GetPrivate(&v.toObject()) != nullptr;
|
|
}
|
|
|
|
static bool
|
|
GetMozFullPathImpl(JSContext* aCx, JS::CallArgs aArgs)
|
|
{
|
|
JS::Rooted<JSObject*> obj(aCx, &aArgs.thisv().toObject());
|
|
nsIDOMFile* file = GetInstancePrivate(aCx, obj, "mozFullPath");
|
|
MOZ_ASSERT(file);
|
|
|
|
nsString fullPath;
|
|
|
|
if (GetWorkerPrivateFromContext(aCx)->UsesSystemPrincipal() &&
|
|
NS_FAILED(file->GetMozFullPathInternal(fullPath))) {
|
|
return Throw(aCx, NS_ERROR_DOM_FILE_NOT_READABLE_ERR);
|
|
}
|
|
|
|
JSString* jsFullPath = JS_NewUCStringCopyN(aCx, fullPath.get(),
|
|
fullPath.Length());
|
|
if (!jsFullPath) {
|
|
return false;
|
|
}
|
|
|
|
aArgs.rval().setString(jsFullPath);
|
|
return true;
|
|
}
|
|
|
|
static bool
|
|
GetMozFullPath(JSContext* aCx, unsigned aArgc, JS::Value* aVp)
|
|
{
|
|
JS::CallArgs args = JS::CallArgsFromVp(aArgc, aVp);
|
|
return JS::CallNonGenericMethod<IsFile, GetMozFullPathImpl>(aCx, args);
|
|
}
|
|
|
|
static bool
|
|
GetNameImpl(JSContext* aCx, JS::CallArgs aArgs)
|
|
{
|
|
JS::Rooted<JSObject*> obj(aCx, &aArgs.thisv().toObject());
|
|
nsIDOMFile* file = GetInstancePrivate(aCx, obj, "name");
|
|
MOZ_ASSERT(file);
|
|
|
|
nsString name;
|
|
if (NS_FAILED(file->GetName(name))) {
|
|
name.Truncate();
|
|
}
|
|
|
|
JSString* jsName = JS_NewUCStringCopyN(aCx, name.get(), name.Length());
|
|
if (!jsName) {
|
|
return false;
|
|
}
|
|
|
|
aArgs.rval().setString(jsName);
|
|
return true;
|
|
}
|
|
|
|
static bool
|
|
GetName(JSContext* aCx, unsigned aArgc, JS::Value* aVp)
|
|
{
|
|
JS::CallArgs args = JS::CallArgsFromVp(aArgc, aVp);
|
|
return JS::CallNonGenericMethod<IsFile, GetNameImpl>(aCx, args);
|
|
}
|
|
|
|
static bool
|
|
GetPathImpl(JSContext* aCx, JS::CallArgs aArgs)
|
|
{
|
|
JS::Rooted<JSObject*> obj(aCx, &aArgs.thisv().toObject());
|
|
nsIDOMFile* file = GetInstancePrivate(aCx, obj, "path");
|
|
MOZ_ASSERT(file);
|
|
|
|
nsString path;
|
|
if (NS_FAILED(file->GetPath(path))) {
|
|
path.Truncate();
|
|
}
|
|
|
|
JSString* jsPath = JS_NewUCStringCopyN(aCx, path.get(), path.Length());
|
|
if (!jsPath) {
|
|
return false;
|
|
}
|
|
|
|
aArgs.rval().setString(jsPath);
|
|
return true;
|
|
}
|
|
|
|
static bool
|
|
GetPath(JSContext* aCx, unsigned aArgc, JS::Value* aVp)
|
|
{
|
|
JS::CallArgs args = JS::CallArgsFromVp(aArgc, aVp);
|
|
return JS::CallNonGenericMethod<IsFile, GetPathImpl>(aCx, args);
|
|
}
|
|
|
|
static bool
|
|
GetLastModifiedDateImpl(JSContext* aCx, JS::CallArgs aArgs)
|
|
{
|
|
JS::Rooted<JSObject*> obj(aCx, &aArgs.thisv().toObject());
|
|
nsIDOMFile* file = GetInstancePrivate(aCx, obj, "lastModifiedDate");
|
|
MOZ_ASSERT(file);
|
|
|
|
if (NS_FAILED(file->GetLastModifiedDate(aCx, aArgs.rval()))) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool
|
|
GetLastModifiedDate(JSContext* aCx, unsigned aArgc, JS::Value* aVp)
|
|
{
|
|
JS::CallArgs args = JS::CallArgsFromVp(aArgc, aVp);
|
|
return JS::CallNonGenericMethod<IsFile, GetLastModifiedDateImpl>(aCx, args);
|
|
}
|
|
};
|
|
|
|
const JSClass File::sClass = {
|
|
"File",
|
|
JSCLASS_HAS_PRIVATE,
|
|
JS_PropertyStub, JS_DeletePropertyStub, JS_PropertyStub, JS_StrictPropertyStub,
|
|
JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, Finalize
|
|
};
|
|
|
|
const JSPropertySpec File::sProperties[] = {
|
|
JS_PSGS("name", GetName, GetterOnlyJSNative, JSPROP_ENUMERATE),
|
|
JS_PSGS("path", GetPath, GetterOnlyJSNative, JSPROP_ENUMERATE),
|
|
JS_PSGS("lastModifiedDate", GetLastModifiedDate, GetterOnlyJSNative,
|
|
JSPROP_ENUMERATE),
|
|
JS_PSGS("mozFullPath", GetMozFullPath, GetterOnlyJSNative, JSPROP_ENUMERATE),
|
|
JS_PS_END
|
|
};
|
|
|
|
nsIDOMBlob*
|
|
Blob::GetPrivate(JSObject* aObj)
|
|
{
|
|
if (aObj) {
|
|
const JSClass* classPtr = JS_GetClass(aObj);
|
|
if (classPtr == &sClass || classPtr == File::Class()) {
|
|
nsISupports* priv = static_cast<nsISupports*>(JS_GetPrivate(aObj));
|
|
nsCOMPtr<nsIDOMBlob> blob = do_QueryInterface(priv);
|
|
MOZ_ASSERT_IF(priv, blob);
|
|
return blob;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
} // anonymous namespace
|
|
|
|
BEGIN_WORKERS_NAMESPACE
|
|
|
|
namespace file {
|
|
|
|
JSObject*
|
|
CreateBlob(JSContext* aCx, nsIDOMBlob* aBlob)
|
|
{
|
|
return Blob::Create(aCx, aBlob);
|
|
}
|
|
|
|
bool
|
|
InitClasses(JSContext* aCx, JS::Handle<JSObject*> aGlobal)
|
|
{
|
|
JS::Rooted<JSObject*> blobProto(aCx, Blob::InitClass(aCx, aGlobal));
|
|
return blobProto && File::InitClass(aCx, aGlobal, blobProto);
|
|
}
|
|
|
|
nsIDOMBlob*
|
|
GetDOMBlobFromJSObject(JSObject* aObj)
|
|
{
|
|
return Blob::GetPrivate(aObj);
|
|
}
|
|
|
|
JSObject*
|
|
CreateFile(JSContext* aCx, nsIDOMFile* aFile)
|
|
{
|
|
return File::Create(aCx, aFile);
|
|
}
|
|
|
|
nsIDOMFile*
|
|
GetDOMFileFromJSObject(JSObject* aObj)
|
|
{
|
|
return File::GetPrivate(aObj);
|
|
}
|
|
|
|
} // namespace file
|
|
|
|
END_WORKERS_NAMESPACE
|