The Tor Browser: dom/workers/File.cpp@925c144e1f1f (annotated)

dom/workers/File.cpp@925c144e1f1f (annotated)

dom/workers/File.cpp

Fri, 16 Jan 2015 18:13:44 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Fri, 16 Jan 2015 18:13:44 +0100
branch: TOR_BUG_9701
changeset 14: 925c144e1f1f
permissions: -rw-r--r--

Integrate suggestion from review to improve consistency with existing code.

 /* -*- 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 "nsIDOMFile.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<nsDOMMultipartFile> file = new nsDOMMultipartFile();
     nsresult rv = file->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;
     }
     nsDependentJSString 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

The Tor Browser / annotate

dom/workers/File.cpp@925c144e1f1f (annotated)

dom/workers/File.cpp