void
FileReader::Abort(ErrorResult& aRv)
{
if (mReadyState != LOADING) {
// XXX The spec doesn't say this
aRv.Throw(NS_ERROR_DOM_FILE_ABORT_ERR);
return;
}
ClearProgressEventTimer();
mReadyState = DONE;
// XXX The spec doesn't say this
mError = new DOMError(GetOwner(), NS_LITERAL_STRING("AbortError"));
// Revert status and result attributes
SetDOMStringToNull(mResult);
mResultArrayBuffer = nullptr;
mAsyncStream = nullptr;
mBlob = nullptr;
//Clean up memory buffer
FreeFileData();
// Dispatch the events
DispatchProgressEvent(NS_LITERAL_STRING(ABORT_STR));
DispatchProgressEvent(NS_LITERAL_STRING(LOADEND_STR));
}
//
// Parse either a .conf file provided by the user or the default from glslang::DefaultTBuiltInResource
//
void ProcessConfigFile()
{
char** configStrings = 0;
char* config = 0;
if (ConfigFile.size() > 0) {
configStrings = ReadFileData(ConfigFile.c_str());
if (configStrings)
config = *configStrings;
else {
printf("Error opening configuration file; will instead use the default configuration\n");
usage();
}
}
if (config == 0) {
Resources = glslang::DefaultTBuiltInResource;
return;
}
glslang::DecodeResourceLimits(&Resources, config);
if (configStrings)
FreeFileData(configStrings);
else
delete[] config;
}
void
FileReader::Abort()
{
if (mReadyState == EMPTY || mReadyState == DONE) {
return;
}
MOZ_ASSERT(mReadyState == LOADING);
ClearProgressEventTimer();
mReadyState = DONE;
// XXX The spec doesn't say this
mError = DOMException::Create(NS_ERROR_DOM_ABORT_ERR);
// Revert status and result attributes
SetDOMStringToNull(mResult);
mResultArrayBuffer = nullptr;
mAsyncStream = nullptr;
mBlob = nullptr;
//Clean up memory buffer
FreeFileData();
// Dispatch the events
DispatchProgressEvent(NS_LITERAL_STRING(ABORT_STR));
DispatchProgressEvent(NS_LITERAL_STRING(LOADEND_STR));
}
int download(char *service_name)
{
char *location,*location_tmp;
GetConnect();
memset(client_request, 0, REQUESTSIZE);
strcat(client_request, "GET /v5.0/");
strcat(client_request, service_name);
strcat(client_request, "/content?download=true&access_token=");
strcat(client_request, api_access_token);
strcat(client_request, " HTTP/1.1\r\n");
strcat(client_request, "HOST: apis.live.net\r\n\r\n");
// printf("%s\n",client_request);
if((SSL_write(ssl, client_request, strlen(client_request))) == -1)
{
printf("send fail.\n");
return -1;
}
// printf("sned success!\n");
memset(service_respones, 0, REQUESTSIZE);
if((state = SSL_read(ssl, service_respones, REQUESTSIZE)) == -1)
{
printf("recv faile.\n");
return -1;
}
else if(state == 0)
{
printf("No available data.\n");
// return -1;
}
// printf("recv success!\n");
// printf("%s\n\n",service_respones);
for(location = service_respones; *location != '\0'; location++)
{
if(*location == '\n')
{
location++;
if(strncmp(location, "Location", 8) == 0)
break;
}
}
location+=10;
for(location_tmp = location; *location_tmp != '\r'; location_tmp++);
for(; *location_tmp !='?'; location_tmp--);
*location_tmp = '\0';
location-=strlen("wget --no-check-certificate ");
strncpy(location, "wget --no-check-certificate ",strlen("wget --no-check-certificate "));
// printf("%s",location);
system(location);
CloseConnect();
FreeFileData(FileMes);
GetFileData();
return 0;
}
int upload(char *client_name,char *service_name)
{
int file_fd;
char file_data[REQUESTSIZE - NAMESIZE];
int buf_size;
GetConnect();
file_fd = open(client_name, O_RDONLY);
buf_size = read(file_fd, file_data, REQUESTSIZE - NAMESIZE);
sprintf(tem_buf, "%d", buf_size);
memset(client_request, 0, REQUESTSIZE);
strcat(client_request, "PUT /v5.0/me/skydrive/files/");
strcat(client_request, service_name);
strcat(client_request, "?access_token=");
strcat(client_request, api_access_token);
strcat(client_request, " HTTP/1.1\r\n");
strcat(client_request, "HOST: apis.live.net\r\n");
// strcat(client_request, "Content-Type:application/octet-stream\r\n");
strcat(client_request, "Content-Length:");
strcat(client_request, tem_buf);
strcat(client_request, "\r\n\r\n");
strcat(client_request, file_data);
// printf("\n\n%s\n\n\n",client_request);
if((SSL_write(ssl, client_request, strlen(client_request))) == -1)
{
printf("send fail.\n");
return -1;
}
// printf("sned success!\n");
// printf("%s\n", client_request);
memset(service_respones, 0, REQUESTSIZE);
if((state = SSL_read(ssl, service_respones, REQUESTSIZE)) == -1)
{
printf("recv faile.\n");
return -1;
}
else if(state == 0)
{
printf("No available data.\n");
// return -1;
}
// printf("recv success!\n");
// printf("%s\n", service_respones);
close(file_fd);
CloseConnect();
FreeFileData(FileMes);
GetFileData();
return 0;
}
void
FileReader::FreeDataAndDispatchSuccess()
{
FreeFileData();
mResult.SetIsVoid(false);
mAsyncStream = nullptr;
mBlob = nullptr;
// Dispatch event to signify end of a successful operation
DispatchProgressEvent(NS_LITERAL_STRING(LOAD_STR));
DispatchProgressEvent(NS_LITERAL_STRING(LOADEND_STR));
}
int move_copy(char *operation,char *path1, char *path2)
{
GetConnect();
memset(client_request_date, 0, REQUESTSIZE);
strcat(client_request_date, "destination=");
strcat(client_request_date, path2);
sprintf(tem_buf ,"%d" ,strlen(client_request_date));
memset(client_request, 0, REQUESTSIZE);
strcat(client_request, operation);
strcat(client_request, " /v5.0/");
strcat(client_request, path1);
strcat(client_request, " HTTP/1.1\r\n");
strcat(client_request, "HOST: apis.live.net\r\n");
strcat(client_request, "Authorization: Bearer ");
strcat(client_request, api_access_token);
strcat(client_request, "\r\n");
strcat(client_request, "Content-type:application/x-www-form-urlencoded\r\n");
strcat(client_request, "Content-Length:");
strcat(client_request, tem_buf);
strcat(client_request, "\r\n\r\n");
strcat(client_request, client_request_date);
// printf("%s\n",client_request);
if((SSL_write(ssl, client_request, strlen(client_request))) == -1)
{
printf("send fail.\n");
return -1;
}
// printf("sned success!\n");
memset(service_respones, 0, REQUESTSIZE);
if((state = SSL_read(ssl, service_respones, REQUESTSIZE)) == -1)
{
printf("recv faile.\n");
return -1;
}
else if(state == 0)
{
printf("No available data.\n");
// return -1;
}
// printf("recv success!\n");
// printf("%s\n",service_respones);
CloseConnect();
FreeFileData(FileMes);
GetFileData();
return 0;
}
int createfolder(const char *name)
{
GetConnect();
memset(client_request_date, 0, REQUESTSIZE);
// strcat(client_request_date, "type=folder");
strcat(client_request_date, "name=");
strcat(client_request_date, name);
sprintf(tem_buf ,"%d" ,strlen(client_request_date));
memset(client_request, 0, REQUESTSIZE);
strcat(client_request, "POST /v5.0/me/skydrive");
strcat(client_request, " HTTP/1.1\r\n");
strcat(client_request, "HOST: apis.live.net\r\n");
strcat(client_request, "Authorization: Bearer ");
strcat(client_request, api_access_token);
strcat(client_request, "\r\n");
strcat(client_request, "Content-type:application/x-www-form-urlencoded\r\n");
strcat(client_request, "Content-Length:");
strcat(client_request, tem_buf);
strcat(client_request, "\r\n\r\n");
strcat(client_request, client_request_date);
// printf("%s\n",client_request);
if((SSL_write(ssl, client_request, strlen(client_request))) == -1)
{
printf("send fail.\n");
return -1;
}
// printf("sned success!\n");
memset(service_respones, 0, REQUESTSIZE);
if((state = SSL_read(ssl, service_respones, REQUESTSIZE)) == -1)
{
printf("recv faile.\n");
return -1;
}
else if(state == 0)
{
printf("No available data.\n");
// return -1;
}
// printf("recv success!\n");
// printf("%s\n",service_respones);
CloseConnect();
FreeFileData(FileMes);
GetFileData();
return 0;
}
//
// Read a file's data into a string, and parse it using Hlsl2Glsl_Parse
//
bool ParseFile(const char *fileName, ShHandle parser, int debugOptions)
{
int ret;
char *data = ReadFileData(fileName);
if (!data)
return false;
ret = Hlsl2Glsl_Parse(parser, data, ETargetGLSL_120, debugOptions);
FreeFileData(data);
return ret ? true : false;
}
void
FileReader::FreeDataAndDispatchError()
{
MOZ_ASSERT(mError);
FreeFileData();
mResult.SetIsVoid(true);
mAsyncStream = nullptr;
mBlob = nullptr;
// Dispatch error event to signify load failure
DispatchProgressEvent(NS_LITERAL_STRING(ERROR_STR));
DispatchProgressEvent(NS_LITERAL_STRING(LOADEND_STR));
}
void
FileReader::Shutdown()
{
FreeFileData();
mResultArrayBuffer = nullptr;
if (mAsyncStream) {
mAsyncStream->Close();
mAsyncStream = nullptr;
}
if (mWorkerPrivate && mBusyCount != 0) {
mWorkerPrivate->RemoveFeature(mWorkerPrivate->GetJSContext(), this);
mWorkerPrivate = nullptr;
mBusyCount = 0;
}
}
//
// Read a file's data into a string, and compile it using the old interface ShCompile,
// for non-linkable results.
//
void CompileFile(const char* fileName, ShHandle compiler)
{
int ret = 0;
char** shaderStrings = ReadFileData(fileName);
if (! shaderStrings) {
usage();
}
int* lengths = new int[NumShaderStrings];
// move to length-based strings, rather than null-terminated strings
for (int s = 0; s < NumShaderStrings; ++s)
lengths[s] = (int)strlen(shaderStrings[s]);
if (! shaderStrings) {
CompileFailed = true;
return;
}
EShMessages messages = EShMsgDefault;
SetMessageOptions(messages);
for (int i = 0; i < ((Options & EOptionMemoryLeakMode) ? 100 : 1); ++i) {
for (int j = 0; j < ((Options & EOptionMemoryLeakMode) ? 100 : 1); ++j) {
//ret = ShCompile(compiler, shaderStrings, NumShaderStrings, lengths, EShOptNone, &Resources, Options, (Options & EOptionDefaultDesktop) ? 110 : 100, false, messages);
ret = ShCompile(compiler, shaderStrings, NumShaderStrings, nullptr, EShOptNone, &Resources, Options, (Options & EOptionDefaultDesktop) ? 110 : 100, false, messages);
//const char* multi[12] = { "# ve", "rsion", " 300 e", "s", "\n#err",
// "or should be l", "ine 1", "string 5\n", "float glo", "bal",
// ";\n#error should be line 2\n void main() {", "global = 2.3;}" };
//const char* multi[7] = { "/", "/", "\\", "\n", "\n", "#", "version 300 es" };
//ret = ShCompile(compiler, multi, 7, nullptr, EShOptNone, &Resources, Options, (Options & EOptionDefaultDesktop) ? 110 : 100, false, messages);
}
if (Options & EOptionMemoryLeakMode)
glslang::OS_DumpMemoryCounters();
}
delete [] lengths;
FreeFileData(shaderStrings);
if (ret == 0)
CompileFailed = true;
}
void
FileReader::Shutdown()
{
mReadyState = DONE;
if (mAsyncStream) {
mAsyncStream->Close();
mAsyncStream = nullptr;
}
FreeFileData();
mResultArrayBuffer = nullptr;
if (mWeakWorkerRef && mBusyCount != 0) {
mStrongWorkerRef = nullptr;
mWeakWorkerRef = nullptr;
mBusyCount = 0;
}
}
int deletefile(char *path)
{
GetConnect();
memset(client_request, 0, REQUESTSIZE);
strcat(client_request, "DELETE /v5.0/");
strcat(client_request, path);
strcat(client_request, "?access_token=");
strcat(client_request, api_access_token);
strcat(client_request, " HTTP/1.1\r\n");
strcat(client_request, "HOST: apis.live.net\r\n\r\n");
// printf("%s\n",client_request);
if((SSL_write(ssl, client_request, strlen(client_request))) == -1)
{
printf("send fail.\n");
return -1;
}
// printf("sned success!\n");
memset(service_respones, 0, REQUESTSIZE);
if((state = SSL_read(ssl, service_respones, REQUESTSIZE)) == -1)
{
printf("recv faile.\n");
return -1;
}
else if(state == 0)
{
printf("No available data.\n");
// return -1;
}
// printf("recv success!\n");
// printf("%s\n",service_respones);
CloseConnect();
FreeFileData(FileMes);
GetFileData();
return 0;
}
//
// Do file IO part of compile and link, handing off the pure
// API/programmatic mode to CompileAndLinkShaderUnits(), which can
// be put in a loop for testing memory footprint and performance.
//
// This is just for linking mode: meaning all the shaders will be put into the
// the same program linked together.
//
// This means there are a limited number of work items (not multi-threading mode)
// and that the point is testing at the linking level. Hence, to enable
// performance and memory testing, the actual compile/link can be put in
// a loop, independent of processing the work items and file IO.
//
void CompileAndLinkShaderFiles()
{
std::vector<ShaderCompUnit> compUnits;
// Transfer all the work items from to a simple list of
// of compilation units. (We don't care about the thread
// work-item distribution properties in this path, which
// is okay due to the limited number of shaders, know since
// they are all getting linked together.)
glslang::TWorkItem* workItem;
while (Worklist.remove(workItem)) {
ShaderCompUnit compUnit(
FindLanguage(workItem->name),
workItem->name,
ReadFileData(workItem->name.c_str())
);
if (! compUnit.text) {
usage();
return;
}
compUnits.push_back(compUnit);
}
// Actual call to programmatic processing of compile and link,
// in a loop for testing memory and performance. This part contains
// all the perf/memory that a programmatic consumer will care about.
for (int i = 0; i < ((Options & EOptionMemoryLeakMode) ? 100 : 1); ++i) {
for (int j = 0; j < ((Options & EOptionMemoryLeakMode) ? 100 : 1); ++j)
CompileAndLinkShaderUnits(compUnits);
if (Options & EOptionMemoryLeakMode)
glslang::OS_DumpMemoryCounters();
}
for (auto it = compUnits.begin(); it != compUnits.end(); ++it)
FreeFileData(it->text);
}
int C_DECL main(int argc, char* argv[])
{
bool parseFailed = false;
bool translateFailed = false;
int debugOptions = 0;
std::map<EShLanguage, std::string> Entrys;
std::map<EShLanguage, ShHandle> parsers;
std::map<EShLanguage, std::string> parsersIns;
std::map<EShLanguage, std::string> Outs;
char *uOut = 0;
char *shaderHeader = 0;
//ShHandle translator = 0;
//ShHandle uniformMap = 0;
bool bUseUserVaryings = false;
int attribSemanticCount = 0;
EAttribSemantic attribSemanticEnums[EAttrSemCount];
char* attribSemanticNames[EAttrSemCount];
for ( int i = 0; i < EAttrSemCount; i++ )
{
attribSemanticEnums[i] = EAttrSemUnknown;
attribSemanticNames[i] = NULL;
};
Hlsl2Glsl_Initialize();
argc--;
argv++;
for (; argc >= 1; argc--, argv++)
{
if (argv[0][0] == '-' || argv[0][0] == '/')
{
switch (argv[0][1])
{
case 'f': Entrys.insert(std::pair<EShLanguage, std::string>(EShLangFragment, (++argv)[0])); argc--; break;
case 'v': Entrys.insert(std::pair<EShLanguage, std::string>(EShLangVertex, (++argv)[0])); argc--; break;
case 'o':
if (strlen(argv[0]) > 2)
{
switch (argv[0][2])
{
case 'f':
Outs.insert(std::pair<EShLanguage, std::string>(EShLangFragment, (++argv)[0]));
argc--;
break;
case 'v':
Outs.insert(std::pair<EShLanguage, std::string>(EShLangVertex, (++argv)[0]));
argc--;
break;
case 'u':
uOut = (++argv)[0]; argc--;
break;
default:
usage();
return EFailUsage;
break;
}
}
break;
case 'i':
if (strlen(argv[0]) > 2)
{
EShLanguage language = EShLangFragment;
switch (argv[0][2])
{
case 'f':
language = EShLangFragment;
break;
case 'v':
language = EShLangVertex;
break;
default:
usage();
return EFailUsage;
break;
};
ShHandle l_parser = Hlsl2Glsl_ConstructCompiler(language);
if (l_parser == 0)
return EFailParserCreate;
argv++;
argc--;
parsers.insert(std::pair<EShLanguage, ShHandle>(language, l_parser));
parsersIns.insert(std::pair<EShLanguage, std::string>(language, argv[0]));
}
break;
case 'u':
bUseUserVaryings = true;
break;
case 'a':
{
char *configFileName = (++argv)[0];
argc--;
// Load a configuration file specifying user attributes
if ( !LoadUserAttribConfigFile ( configFileName, attribSemanticEnums, attribSemanticNames, &attribSemanticCount ) )
{
printf ( "Error loading attribute configuration file '%s'.\n", configFileName );
return EFailUsage;
}
}
break;
case 'h':
{
char *shaderHeaderName = (++argv)[0];
argc--;
shaderHeader = ReadFileData ( shaderHeaderName );
}
break;
default:
usage();
return EFailUsage;
}
}
else
{
EShLanguage language = FindLanguage(argv[0]);
ShHandle l_parser = Hlsl2Glsl_ConstructCompiler(language);
if (l_parser == 0)
return EFailParserCreate;
parsers.insert(std::pair<EShLanguage, ShHandle>(language, l_parser));
parsersIns.insert(std::pair<EShLanguage, std::string>(language, argv[0]));
}
}
if (parsers.size() == 0)
{
usage();
return EFailUsage;
}
/*
translator = Hlsl2Glsl_ConstructTranslator(debugOptions);
if (translator == 0)
return EFailTranslatorCreate;
*/
if ( bUseUserVaryings )
{
// Set the translator up to use user varyings
for(std::map<EShLanguage, ShHandle>::iterator it = parsers.begin(); it != parsers.end(); ++it)
{
Hlsl2Glsl_UseUserVaryings (it->second, bUseUserVaryings );
};
};
/*
if ( shaderHeader != NULL )
{
// Set a shader header if requested
Hlsl2Glsl_SetShaderHeader ( translator, true, shaderHeader );
}
*/
if ( attribSemanticCount > 0 )
{
for(std::map<EShLanguage, ShHandle>::iterator it = parsers.begin(); it != parsers.end(); ++it)
{
// Use user attributes if the user specified user attribute configuration file
if ( !Hlsl2Glsl_SetUserAttributeNames (it->second, attribSemanticEnums, (const char**)&attribSemanticNames[0], attribSemanticCount ) )
{
printf ("ERROR: Setting user attribute names\n");
};
};
};
if (parsers.size() > 0)
{
int l_i = -1;
for(std::map<EShLanguage, ShHandle>::iterator it = parsers.begin(); it != parsers.end(); ++it)
{
EShLanguage l_language = it->first;
ShHandle l_parser = it->second;
std::string l_parsedfile = parsersIns[l_language];
l_i += 1;
if(ParseFile(l_parsedfile.c_str(), l_parser, debugOptions))
{
if(Entrys.find(l_language) != Entrys.end())
{
std::string l_entrypointname = Entrys[l_language];
//TODO
if (Hlsl2Glsl_Translate(l_parser, l_entrypointname.c_str() , ETargetGLSL_120, 0))
{
if(Outs.find(l_language) != Outs.end())
{
SaveShader(Outs[l_language].c_str(), l_parser, shaderHeader);
};
if (uOut)
SaveUniforms(uOut, l_parser);
}
else
{
translateFailed = true;
};
}
}
else
{
parseFailed = true;
};
InfoLogMsg("BEGIN", "COMPILER", l_i);
puts(Hlsl2Glsl_GetInfoLog(l_parser));
InfoLogMsg("END", "COMPILER", l_i);
};
};
/*
InfoLogMsg("BEGIN", "LINKER", -1);
puts(Hlsl2Glsl_GetInfoLog(translator));
InfoLogMsg("END", "LINKER", -1);
if (!translateFailed )
{
if (fOut)
SaveShader( fOut, translator, EShLangFragment);
if (vOut)
SaveShader( vOut, translator, EShLangVertex);
if (uOut)
SaveUniforms( uOut, translator);
}
*/
for(std::map<EShLanguage, ShHandle>::iterator it = parsers.begin(); it != parsers.end(); ++it)
{
Hlsl2Glsl_DestructCompiler(it->second);
};
// Hlsl2Glsl_Destruct(translator);
// Hlsl2Glsl_Destruct(uniformMap);
for ( int i = 0; i < EAttrSemCount; i++ )
{
if ( attribSemanticNames[i] != NULL )
{
delete[] attribSemanticNames[i];
attribSemanticNames[i] = NULL;
};
};
if ( shaderHeader )
{
FreeFileData ( shaderHeader );
};
if (parseFailed)
return EFailParse;
if (translateFailed)
return EFailTranslate;
return 0;
}
//
// Load an (optional) configuration file specifying which user attribute names to use
//
bool LoadUserAttribConfigFile ( char* configFileName, EAttribSemantic attribSemanticEnums[],
char* attribSemanticNames[], int* attribSemanticCount )
{
static char *attribString[EAttrSemCount] =
{
"",
"EAttrSemPosition",
"EAttrSemNormal",
"EAttrSemColor0",
"EAttrSemColor1",
"EAttrSemColor2",
"EAttrSemColor3",
"EAttrSemTex0",
"EAttrSemTex1",
"EAttrSemTex2",
"EAttrSemTex3",
"EAttrSemTex4",
"EAttrSemTex5",
"EAttrSemTex6",
"EAttrSemTex7",
"EAttrSemTex8",
"EAttrSemTex9",
"EAttrSemTangent",
"EAttrSemBinormal",
"EAttrSemBlendWeight",
"EAttrSemBlendIndices",
"EAttrSemDepth",
"EAttrSemUnknown",
};
char *data = ReadFileData(configFileName);
int semanticCount = 0;
if (!data)
return false;
char *semToken = strtok ( data, " \n" );
while ( semToken != NULL )
{
char *attrToken = strtok ( NULL, " \n" );
if ( attrToken == NULL )
{
printf ("ERROR: Encountered invalid token in file '%s'\n", configFileName );
FreeFileData(data);
return false;
}
bool bAttribSemFound = false;
EAttribSemantic semantic;
for ( int i = 0; i < EAttrSemCount; i++ )
{
if ( !strcmp ( semToken, attribString[i] ) )
{
bAttribSemFound = true;
semantic = (EAttribSemantic) i;
break;
}
}
if ( !bAttribSemFound )
{
printf ("ERROR: Attribute semantic '%s' in file '%s' not found. \n", semToken, configFileName );
}
else
{
if ( semanticCount < EAttrSemCount )
{
attribSemanticEnums[semanticCount] = semantic;
attribSemanticNames[semanticCount] = new char[strlen(attrToken) + 1];
strcpy ( attribSemanticNames[semanticCount], attrToken );
semanticCount++;
}
else
{
printf ( "WARNING: Ignoring attribute semantic '%s' in file '%s' because there are too many semantics\n", semToken, configFileName );
}
}
semToken = strtok ( NULL, " \n" );
}
*attribSemanticCount = semanticCount;
FreeFileData(data);
return true;
}
void
FileReader::ReadFileContent(Blob& aBlob,
const nsAString &aCharset,
eDataFormat aDataFormat,
ErrorResult& aRv)
{
//Implicit abort to clear any other activity going on
ErrorResult error;
Abort(error);
error.SuppressException();
mError = nullptr;
SetDOMStringToNull(mResult);
mTransferred = 0;
mTotal = 0;
mReadyState = EMPTY;
FreeFileData();
mBlob = &aBlob;
mDataFormat = aDataFormat;
CopyUTF16toUTF8(aCharset, mCharset);
nsresult rv;
nsCOMPtr<nsIStreamTransportService> sts =
do_GetService(kStreamTransportServiceCID, &rv);
if (NS_WARN_IF(NS_FAILED(rv))) {
aRv.Throw(rv);
return;
}
nsCOMPtr<nsIInputStream> stream;
mBlob->GetInternalStream(getter_AddRefs(stream), aRv);
if (NS_WARN_IF(aRv.Failed())) {
return;
}
nsCOMPtr<nsITransport> transport;
aRv = sts->CreateInputTransport(stream,
/* aStartOffset */ 0,
/* aReadLimit */ -1,
/* aCloseWhenDone */ true,
getter_AddRefs(transport));
if (NS_WARN_IF(aRv.Failed())) {
return;
}
nsCOMPtr<nsIInputStream> wrapper;
aRv = transport->OpenInputStream(/* aFlags */ 0,
/* aSegmentSize */ 0,
/* aSegmentCount */ 0,
getter_AddRefs(wrapper));
if (NS_WARN_IF(aRv.Failed())) {
return;
}
MOZ_ASSERT(!mAsyncStream);
mAsyncStream = do_QueryInterface(wrapper);
MOZ_ASSERT(mAsyncStream);
mTotal = mBlob->GetSize(aRv);
if (NS_WARN_IF(aRv.Failed())) {
return;
}
aRv = DoAsyncWait();
if (NS_WARN_IF(aRv.Failed())) {
return;
}
//FileReader should be in loading state here
mReadyState = LOADING;
DispatchProgressEvent(NS_LITERAL_STRING(LOADSTART_STR));
if (mDataFormat == FILE_AS_ARRAYBUFFER) {
mFileData = js_pod_malloc<char>(mTotal);
if (!mFileData) {
NS_WARNING("Preallocation failed for ReadFileData");
aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
}
}
}
nsresult
FileReader::DoOnLoadEnd(nsresult aStatus,
nsAString& aSuccessEvent,
nsAString& aTerminationEvent)
{
// Make sure we drop all the objects that could hold files open now.
nsCOMPtr<nsIAsyncInputStream> stream;
mAsyncStream.swap(stream);
RefPtr<Blob> blob;
mBlob.swap(blob);
// Clear out the data if necessary
if (NS_FAILED(aStatus)) {
FreeFileData();
return NS_OK;
}
// In case we read a different number of bytes, we can assume that the
// underlying storage has changed. We should not continue.
if (mDataLen != mTotal) {
DispatchError(NS_ERROR_FAILURE, aTerminationEvent);
FreeFileData();
return NS_ERROR_FAILURE;
}
aSuccessEvent = NS_LITERAL_STRING(LOAD_STR);
aTerminationEvent = NS_LITERAL_STRING(LOADEND_STR);
nsresult rv = NS_OK;
switch (mDataFormat) {
case FILE_AS_ARRAYBUFFER: {
AutoJSAPI jsapi;
nsCOMPtr<nsIGlobalObject> globalObject;
if (NS_IsMainThread()) {
globalObject = do_QueryInterface(GetParentObject());
} else {
MOZ_ASSERT(mWorkerPrivate);
MOZ_ASSERT(mBusyCount);
globalObject = mWorkerPrivate->GlobalScope();
}
if (!globalObject || !jsapi.Init(globalObject)) {
FreeFileData();
return NS_ERROR_FAILURE;
}
RootResultArrayBuffer();
mResultArrayBuffer = JS_NewArrayBufferWithContents(jsapi.cx(), mDataLen, mFileData);
if (!mResultArrayBuffer) {
JS_ClearPendingException(jsapi.cx());
rv = NS_ERROR_OUT_OF_MEMORY;
} else {
mFileData = nullptr; // Transfer ownership
}
break;
}
case FILE_AS_BINARY:
break; //Already accumulated mResult
case FILE_AS_TEXT:
if (!mFileData) {
if (mDataLen) {
rv = NS_ERROR_OUT_OF_MEMORY;
break;
}
rv = GetAsText(blob, mCharset, "", mDataLen, mResult);
break;
}
rv = GetAsText(blob, mCharset, mFileData, mDataLen, mResult);
break;
case FILE_AS_DATAURL:
rv = GetAsDataURL(blob, mFileData, mDataLen, mResult);
break;
}
mResult.SetIsVoid(false);
FreeFileData();
return rv;
}
//
// For linking mode: Will independently parse each item in the worklist, but then put them
// in the same program and link them together.
//
// Uses the new C++ interface instead of the old handle-based interface.
//
void CompileAndLinkShaders()
{
// keep track of what to free
std::list<glslang::TShader*> shaders;
EShMessages messages = EShMsgDefault;
SetMessageOptions(messages);
//
// Per-shader processing...
//
glslang::TProgram& program = *new glslang::TProgram;
glslang::TWorkItem* workItem;
while (Worklist.remove(workItem)) {
EShLanguage stage = FindLanguage(workItem->name);
glslang::TShader* shader = new glslang::TShader(stage);
shaders.push_back(shader);
char** shaderStrings = ReadFileData(workItem->name.c_str());
if (! shaderStrings) {
usage();
delete &program;
return;
}
const int defaultVersion = Options & EOptionDefaultDesktop? 110: 100;
shader->setStrings(shaderStrings, 1);
if (Options & EOptionOutputPreprocessed) {
std::string str;
if (shader->preprocess(&Resources, defaultVersion, ENoProfile, false, false,
messages, &str, glslang::TShader::ForbidInclude())) {
PutsIfNonEmpty(str.c_str());
} else {
CompileFailed = true;
}
StderrIfNonEmpty(shader->getInfoLog());
StderrIfNonEmpty(shader->getInfoDebugLog());
FreeFileData(shaderStrings);
continue;
}
if (! shader->parse(&Resources, defaultVersion, false, messages))
CompileFailed = true;
program.addShader(shader);
if (! (Options & EOptionSuppressInfolog)) {
PutsIfNonEmpty(workItem->name.c_str());
PutsIfNonEmpty(shader->getInfoLog());
PutsIfNonEmpty(shader->getInfoDebugLog());
}
FreeFileData(shaderStrings);
}
//
// Program-level processing...
//
if (! (Options & EOptionOutputPreprocessed) && ! program.link(messages))
LinkFailed = true;
if (! (Options & EOptionSuppressInfolog)) {
PutsIfNonEmpty(program.getInfoLog());
PutsIfNonEmpty(program.getInfoDebugLog());
}
if (Options & EOptionDumpReflection) {
program.buildReflection();
program.dumpReflection();
}
if (Options & EOptionSpv) {
if (CompileFailed || LinkFailed)
printf("SPIR-V is not generated for failed compile or link\n");
else {
for (int stage = 0; stage < EShLangCount; ++stage) {
if (program.getIntermediate((EShLanguage)stage)) {
std::vector<unsigned int> spirv;
glslang::GlslangToSpv(*program.getIntermediate((EShLanguage)stage), spirv);
glslang::OutputSpv(spirv, GetBinaryName((EShLanguage)stage));
if (Options & EOptionHumanReadableSpv) {
spv::Parameterize();
spv::Disassemble(std::cout, spirv);
}
}
}
}
}
// Free everything up, program has to go before the shaders
// because it might have merged stuff from the shaders, and
// the stuff from the shaders has to have its destructors called
// before the pools holding the memory in the shaders is freed.
delete &program;
while (shaders.size() > 0) {
delete shaders.back();
shaders.pop_back();
}
}
//
// Parse either a .conf file provided by the user or the default string above.
//
void ProcessConfigFile()
{
char** configStrings = 0;
char* config = 0;
if (ConfigFile.size() > 0) {
configStrings = ReadFileData(ConfigFile.c_str());
if (configStrings)
config = *configStrings;
else {
printf("Error opening configuration file; will instead use the default configuration\n");
usage();
}
}
if (config == 0) {
config = new char[strlen(DefaultConfig) + 1];
strcpy(config, DefaultConfig);
}
const char* delims = " \t\n\r";
const char* token = strtok(config, delims);
while (token) {
const char* valueStr = strtok(0, delims);
if (valueStr == 0 || ! (valueStr[0] == '-' || (valueStr[0] >= '0' && valueStr[0] <= '9'))) {
printf("Error: '%s' bad .conf file. Each name must be followed by one number.\n", valueStr ? valueStr : "");
return;
}
int value = atoi(valueStr);
if (strcmp(token, "MaxLights") == 0)
Resources.maxLights = value;
else if (strcmp(token, "MaxClipPlanes") == 0)
Resources.maxClipPlanes = value;
else if (strcmp(token, "MaxTextureUnits") == 0)
Resources.maxTextureUnits = value;
else if (strcmp(token, "MaxTextureCoords") == 0)
Resources.maxTextureCoords = value;
else if (strcmp(token, "MaxVertexAttribs") == 0)
Resources.maxVertexAttribs = value;
else if (strcmp(token, "MaxVertexUniformComponents") == 0)
Resources.maxVertexUniformComponents = value;
else if (strcmp(token, "MaxVaryingFloats") == 0)
Resources.maxVaryingFloats = value;
else if (strcmp(token, "MaxVertexTextureImageUnits") == 0)
Resources.maxVertexTextureImageUnits = value;
else if (strcmp(token, "MaxCombinedTextureImageUnits") == 0)
Resources.maxCombinedTextureImageUnits = value;
else if (strcmp(token, "MaxTextureImageUnits") == 0)
Resources.maxTextureImageUnits = value;
else if (strcmp(token, "MaxFragmentUniformComponents") == 0)
Resources.maxFragmentUniformComponents = value;
else if (strcmp(token, "MaxDrawBuffers") == 0)
Resources.maxDrawBuffers = value;
else if (strcmp(token, "MaxVertexUniformVectors") == 0)
Resources.maxVertexUniformVectors = value;
else if (strcmp(token, "MaxVaryingVectors") == 0)
Resources.maxVaryingVectors = value;
else if (strcmp(token, "MaxFragmentUniformVectors") == 0)
Resources.maxFragmentUniformVectors = value;
else if (strcmp(token, "MaxVertexOutputVectors") == 0)
Resources.maxVertexOutputVectors = value;
else if (strcmp(token, "MaxFragmentInputVectors") == 0)
Resources.maxFragmentInputVectors = value;
else if (strcmp(token, "MinProgramTexelOffset") == 0)
Resources.minProgramTexelOffset = value;
else if (strcmp(token, "MaxProgramTexelOffset") == 0)
Resources.maxProgramTexelOffset = value;
else if (strcmp(token, "MaxClipDistances") == 0)
Resources.maxClipDistances = value;
else if (strcmp(token, "MaxComputeWorkGroupCountX") == 0)
Resources.maxComputeWorkGroupCountX = value;
else if (strcmp(token, "MaxComputeWorkGroupCountY") == 0)
Resources.maxComputeWorkGroupCountY = value;
else if (strcmp(token, "MaxComputeWorkGroupCountZ") == 0)
Resources.maxComputeWorkGroupCountZ = value;
else if (strcmp(token, "MaxComputeWorkGroupSizeX") == 0)
Resources.maxComputeWorkGroupSizeX = value;
else if (strcmp(token, "MaxComputeWorkGroupSizeY") == 0)
Resources.maxComputeWorkGroupSizeY = value;
else if (strcmp(token, "MaxComputeWorkGroupSizeZ") == 0)
Resources.maxComputeWorkGroupSizeZ = value;
else if (strcmp(token, "MaxComputeUniformComponents") == 0)
Resources.maxComputeUniformComponents = value;
else if (strcmp(token, "MaxComputeTextureImageUnits") == 0)
Resources.maxComputeTextureImageUnits = value;
else if (strcmp(token, "MaxComputeImageUniforms") == 0)
Resources.maxComputeImageUniforms = value;
else if (strcmp(token, "MaxComputeAtomicCounters") == 0)
Resources.maxComputeAtomicCounters = value;
else if (strcmp(token, "MaxComputeAtomicCounterBuffers") == 0)
Resources.maxComputeAtomicCounterBuffers = value;
else if (strcmp(token, "MaxVaryingComponents") == 0)
Resources.maxVaryingComponents = value;
else if (strcmp(token, "MaxVertexOutputComponents") == 0)
Resources.maxVertexOutputComponents = value;
else if (strcmp(token, "MaxGeometryInputComponents") == 0)
Resources.maxGeometryInputComponents = value;
else if (strcmp(token, "MaxGeometryOutputComponents") == 0)
Resources.maxGeometryOutputComponents = value;
else if (strcmp(token, "MaxFragmentInputComponents") == 0)
Resources.maxFragmentInputComponents = value;
else if (strcmp(token, "MaxImageUnits") == 0)
Resources.maxImageUnits = value;
else if (strcmp(token, "MaxCombinedImageUnitsAndFragmentOutputs") == 0)
Resources.maxCombinedImageUnitsAndFragmentOutputs = value;
else if (strcmp(token, "MaxCombinedShaderOutputResources") == 0)
Resources.maxCombinedShaderOutputResources = value;
else if (strcmp(token, "MaxImageSamples") == 0)
Resources.maxImageSamples = value;
else if (strcmp(token, "MaxVertexImageUniforms") == 0)
Resources.maxVertexImageUniforms = value;
else if (strcmp(token, "MaxTessControlImageUniforms") == 0)
Resources.maxTessControlImageUniforms = value;
else if (strcmp(token, "MaxTessEvaluationImageUniforms") == 0)
Resources.maxTessEvaluationImageUniforms = value;
else if (strcmp(token, "MaxGeometryImageUniforms") == 0)
Resources.maxGeometryImageUniforms = value;
else if (strcmp(token, "MaxFragmentImageUniforms") == 0)
Resources.maxFragmentImageUniforms = value;
else if (strcmp(token, "MaxCombinedImageUniforms") == 0)
Resources.maxCombinedImageUniforms = value;
else if (strcmp(token, "MaxGeometryTextureImageUnits") == 0)
Resources.maxGeometryTextureImageUnits = value;
else if (strcmp(token, "MaxGeometryOutputVertices") == 0)
Resources.maxGeometryOutputVertices = value;
else if (strcmp(token, "MaxGeometryTotalOutputComponents") == 0)
Resources.maxGeometryTotalOutputComponents = value;
else if (strcmp(token, "MaxGeometryUniformComponents") == 0)
Resources.maxGeometryUniformComponents = value;
else if (strcmp(token, "MaxGeometryVaryingComponents") == 0)
Resources.maxGeometryVaryingComponents = value;
else if (strcmp(token, "MaxTessControlInputComponents") == 0)
Resources.maxTessControlInputComponents = value;
else if (strcmp(token, "MaxTessControlOutputComponents") == 0)
Resources.maxTessControlOutputComponents = value;
else if (strcmp(token, "MaxTessControlTextureImageUnits") == 0)
Resources.maxTessControlTextureImageUnits = value;
else if (strcmp(token, "MaxTessControlUniformComponents") == 0)
Resources.maxTessControlUniformComponents = value;
else if (strcmp(token, "MaxTessControlTotalOutputComponents") == 0)
Resources.maxTessControlTotalOutputComponents = value;
else if (strcmp(token, "MaxTessEvaluationInputComponents") == 0)
Resources.maxTessEvaluationInputComponents = value;
else if (strcmp(token, "MaxTessEvaluationOutputComponents") == 0)
Resources.maxTessEvaluationOutputComponents = value;
else if (strcmp(token, "MaxTessEvaluationTextureImageUnits") == 0)
Resources.maxTessEvaluationTextureImageUnits = value;
else if (strcmp(token, "MaxTessEvaluationUniformComponents") == 0)
Resources.maxTessEvaluationUniformComponents = value;
else if (strcmp(token, "MaxTessPatchComponents") == 0)
Resources.maxTessPatchComponents = value;
else if (strcmp(token, "MaxPatchVertices") == 0)
Resources.maxPatchVertices = value;
else if (strcmp(token, "MaxTessGenLevel") == 0)
Resources.maxTessGenLevel = value;
else if (strcmp(token, "MaxViewports") == 0)
Resources.maxViewports = value;
else if (strcmp(token, "MaxVertexAtomicCounters") == 0)
Resources.maxVertexAtomicCounters = value;
else if (strcmp(token, "MaxTessControlAtomicCounters") == 0)
Resources.maxTessControlAtomicCounters = value;
else if (strcmp(token, "MaxTessEvaluationAtomicCounters") == 0)
Resources.maxTessEvaluationAtomicCounters = value;
else if (strcmp(token, "MaxGeometryAtomicCounters") == 0)
Resources.maxGeometryAtomicCounters = value;
else if (strcmp(token, "MaxFragmentAtomicCounters") == 0)
Resources.maxFragmentAtomicCounters = value;
else if (strcmp(token, "MaxCombinedAtomicCounters") == 0)
Resources.maxCombinedAtomicCounters = value;
else if (strcmp(token, "MaxAtomicCounterBindings") == 0)
Resources.maxAtomicCounterBindings = value;
else if (strcmp(token, "MaxVertexAtomicCounterBuffers") == 0)
Resources.maxVertexAtomicCounterBuffers = value;
else if (strcmp(token, "MaxTessControlAtomicCounterBuffers") == 0)
Resources.maxTessControlAtomicCounterBuffers = value;
else if (strcmp(token, "MaxTessEvaluationAtomicCounterBuffers") == 0)
Resources.maxTessEvaluationAtomicCounterBuffers = value;
else if (strcmp(token, "MaxGeometryAtomicCounterBuffers") == 0)
Resources.maxGeometryAtomicCounterBuffers = value;
else if (strcmp(token, "MaxFragmentAtomicCounterBuffers") == 0)
Resources.maxFragmentAtomicCounterBuffers = value;
else if (strcmp(token, "MaxCombinedAtomicCounterBuffers") == 0)
Resources.maxCombinedAtomicCounterBuffers = value;
else if (strcmp(token, "MaxAtomicCounterBufferSize") == 0)
Resources.maxAtomicCounterBufferSize = value;
else if (strcmp(token, "MaxTransformFeedbackBuffers") == 0)
Resources.maxTransformFeedbackBuffers = value;
else if (strcmp(token, "MaxTransformFeedbackInterleavedComponents") == 0)
Resources.maxTransformFeedbackInterleavedComponents = value;
else if (strcmp(token, "MaxCullDistances") == 0)
Resources.maxCullDistances = value;
else if (strcmp(token, "MaxCombinedClipAndCullDistances") == 0)
Resources.maxCombinedClipAndCullDistances = value;
else if (strcmp(token, "MaxSamples") == 0)
Resources.maxSamples = value;
else if (strcmp(token, "nonInductiveForLoops") == 0)
Resources.limits.nonInductiveForLoops = (value != 0);
else if (strcmp(token, "whileLoops") == 0)
Resources.limits.whileLoops = (value != 0);
else if (strcmp(token, "doWhileLoops") == 0)
Resources.limits.doWhileLoops = (value != 0);
else if (strcmp(token, "generalUniformIndexing") == 0)
Resources.limits.generalUniformIndexing = (value != 0);
else if (strcmp(token, "generalAttributeMatrixVectorIndexing") == 0)
Resources.limits.generalAttributeMatrixVectorIndexing = (value != 0);
else if (strcmp(token, "generalVaryingIndexing") == 0)
Resources.limits.generalVaryingIndexing = (value != 0);
else if (strcmp(token, "generalSamplerIndexing") == 0)
Resources.limits.generalSamplerIndexing = (value != 0);
else if (strcmp(token, "generalVariableIndexing") == 0)
Resources.limits.generalVariableIndexing = (value != 0);
else if (strcmp(token, "generalConstantMatrixVectorIndexing") == 0)
Resources.limits.generalConstantMatrixVectorIndexing = (value != 0);
else
printf("Warning: unrecognized limit (%s) in configuration file.\n", token);
token = strtok(0, delims);
}
if (configStrings)
FreeFileData(configStrings);
}
//
// For linking mode: Will independently parse each item in the worklist, but then put them
// in the same program and link them together.
//
// Uses the new C++ interface instead of the old handle-based interface.
//
void CompileAndLinkShaders(krafix::Target target, const char* filename, const char* tempdir, const glslang::TShader::Includer& includer)
{
// keep track of what to free
std::list<glslang::TShader*> shaders;
EShMessages messages = EShMsgDefault;
SetMessageOptions(messages);
//
// Per-shader processing...
//
glslang::TProgram& program = *new glslang::TProgram;
glslang::TWorkItem* workItem;
while (Worklist.remove(workItem)) {
EShLanguage stage = FindLanguage(workItem->name);
glslang::TShader* shader = new glslang::TShader(stage);
shaders.push_back(shader);
char** shaderStrings = ReadFileData(workItem->name.c_str());
if (! shaderStrings) {
usage();
delete &program;
return;
}
const int defaultVersion = Options & EOptionDefaultDesktop? 110: 100;
shader->setStrings(shaderStrings, 1);
if (Options & EOptionOutputPreprocessed) {
std::string str;
if (shader->preprocess(&Resources, defaultVersion, ENoProfile, false, false,
messages, &str, includer)) {
PutsIfNonEmpty(str.c_str());
} else {
CompileFailed = true;
}
StderrIfNonEmpty(shader->getInfoLog());
StderrIfNonEmpty(shader->getInfoDebugLog());
FreeFileData(shaderStrings);
continue;
}
if (! shader->parse(&Resources, defaultVersion, ENoProfile, false, false, messages, includer))
CompileFailed = true;
program.addShader(shader);
if (! (Options & EOptionSuppressInfolog)) {
//PutsIfNonEmpty(workItem->name.c_str());
PutsIfNonEmpty(shader->getInfoLog());
PutsIfNonEmpty(shader->getInfoDebugLog());
}
FreeFileData(shaderStrings);
}
//
// Program-level processing...
//
if (! (Options & EOptionOutputPreprocessed) && ! program.link(messages))
LinkFailed = true;
if (! (Options & EOptionSuppressInfolog)) {
PutsIfNonEmpty(program.getInfoLog());
PutsIfNonEmpty(program.getInfoDebugLog());
}
if (Options & EOptionDumpReflection) {
program.buildReflection();
program.dumpReflection();
}
if (Options & EOptionSpv) {
if (CompileFailed || LinkFailed)
printf("SPIRV is not generated for failed compile or link\n");
else {
for (int stage = 0; stage < EShLangCount; ++stage) {
if (program.getIntermediate((EShLanguage)stage)) {
std::vector<unsigned int> spirv;
glslang::GlslangToSpv(*program.getIntermediate((EShLanguage)stage), spirv);
krafix::Translator* translator = NULL;
std::map<std::string, int> attributes;
switch (target.lang) {
case krafix::GLSL:
translator = new krafix::GlslTranslator(spirv, (EShLanguage)stage);
break;
case krafix::HLSL:
translator = new krafix::HlslTranslator(spirv, (EShLanguage)stage);
break;
case krafix::Metal:
translator = new krafix::MetalTranslator(spirv, (EShLanguage)stage);
break;
case krafix::AGAL:
translator = new krafix::AgalTranslator(spirv, (EShLanguage)stage);
break;
case krafix::VarList:
translator = new krafix::VarListTranslator(spirv, (EShLanguage)stage);
break;
}
if (target.lang == krafix::HLSL && target.system != krafix::Unity) {
std::string temp = std::string(tempdir) + "/" + removeExtension(extractFilename(workItem->name)) + ".hlsl";
translator->outputCode(target, temp.c_str(), attributes);
if (target.version == 9) {
compileHLSLToD3D9(temp.c_str(), filename, attributes, (EShLanguage)stage);
}
else {
compileHLSLToD3D11(temp.c_str(), filename, attributes, (EShLanguage)stage);
}
}
else {
translator->outputCode(target, filename, attributes);
}
delete translator;
//glslang::OutputSpv(spirv, GetBinaryName((EShLanguage)stage));
if (Options & EOptionHumanReadableSpv) {
spv::Parameterize();
spv::Disassemble(std::cout, spirv);
}
}
}
}
}
// Free everything up, program has to go before the shaders
// because it might have merged stuff from the shaders, and
// the stuff from the shaders has to have its destructors called
// before the pools holding the memory in the shaders is freed.
delete &program;
while (shaders.size() > 0) {
delete shaders.back();
shaders.pop_back();
}
}
void
FileReader::ReadFileContent(Blob& aBlob,
const nsAString &aCharset,
eDataFormat aDataFormat,
ErrorResult& aRv)
{
if (IsCurrentThreadRunningWorker() && !mWeakWorkerRef) {
// The worker is already shutting down.
return;
}
if (mReadyState == LOADING) {
aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
return;
}
mError = nullptr;
SetDOMStringToNull(mResult);
mResultArrayBuffer = nullptr;
mAsyncStream = nullptr;
mTransferred = 0;
mTotal = 0;
mReadyState = EMPTY;
FreeFileData();
mBlob = &aBlob;
mDataFormat = aDataFormat;
CopyUTF16toUTF8(aCharset, mCharset);
{
nsCOMPtr<nsIInputStream> stream;
mBlob->CreateInputStream(getter_AddRefs(stream), aRv);
if (NS_WARN_IF(aRv.Failed())) {
return;
}
aRv = NS_MakeAsyncNonBlockingInputStream(stream.forget(),
getter_AddRefs(mAsyncStream));
if (NS_WARN_IF(aRv.Failed())) {
return;
}
}
MOZ_ASSERT(mAsyncStream);
mTotal = mBlob->GetSize(aRv);
if (NS_WARN_IF(aRv.Failed())) {
return;
}
// Binary Format doesn't need a post-processing of the data. Everything is
// written directly into mResult.
if (mDataFormat != FILE_AS_BINARY) {
if (mDataFormat == FILE_AS_ARRAYBUFFER) {
mFileData = js_pod_malloc<char>(mTotal);
} else {
mFileData = (char *) malloc(mTotal);
}
if (!mFileData) {
NS_WARNING("Preallocation failed for ReadFileData");
aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
return;
}
}
aRv = DoAsyncWait();
if (NS_WARN_IF(aRv.Failed())) {
FreeFileData();
return;
}
//FileReader should be in loading state here
mReadyState = LOADING;
DispatchProgressEvent(NS_LITERAL_STRING(LOADSTART_STR));
}
