# HG changeset patch
# Parent bcb8506b23d3df7acafd7c46df9cc391df19466d
# User Andrea Marchesini <baku@mozilla.com>
try: -b do -p all -u all -t none

diff --git a/dom/file/ArchiveEvent.cpp b/dom/file/ArchiveEvent.cpp
--- a/dom/file/ArchiveEvent.cpp
+++ b/dom/file/ArchiveEvent.cpp
@@ -92,20 +92,25 @@ ArchiveReaderEvent::ShareMainThread()
     for (PRUint32 index = 0; index < mFileList.Length(); ++index) {
       nsRefPtr<ArchiveItem> item = mFileList[index];
 
-      PRInt32 offset = item->GetFilename().RFindChar('.');
+      nsCString filename;
+      nsresult rv = item->GetFilename(filename);
+      if (NS_FAILED(rv))
+        continue;
+
+      PRInt32 offset = filename.RFindChar('.');
       if (offset != kNotFound) {
-        nsCString ext(item->GetFilename());
-        ext.Cut(0, offset + 1);
+        filename.Cut(0, offset + 1);
 
         // Just to be sure, if something goes wrong, the mimetype is an empty string:
         nsCString type;
-        if (NS_SUCCEEDED(GetType(ext, type)))
+        if (NS_SUCCEEDED(GetType(filename, type)))
           item->SetType(type);
       }
 
       // This is a nsDOMFile:
       nsRefPtr<nsIDOMFile> file = item->File(mArchiveReader);
-      fileList.AppendElement(file);
+      if (file)
+        fileList.AppendElement(file);
     }
   }
 
diff --git a/dom/file/ArchiveEvent.h b/dom/file/ArchiveEvent.h
--- a/dom/file/ArchiveEvent.h
+++ b/dom/file/ArchiveEvent.h
@@ -32,7 +32,7 @@ public:
   virtual void SetType(const nsCString& aType);
 
   // Getter for the filename
-  virtual nsCString GetFilename() = 0;
+  virtual nsresult GetFilename(nsCString& aFilename) = 0;
 
   // Generate a DOMFile
   virtual nsIDOMFile* File(ArchiveReader* aArchiveReader) = 0;
diff --git a/dom/file/ArchiveZipEvent.cpp b/dom/file/ArchiveZipEvent.cpp
--- a/dom/file/ArchiveZipEvent.cpp
+++ b/dom/file/ArchiveZipEvent.cpp
@@ -8,6 +8,8 @@
 #include "ArchiveZipFile.h"
 
 #include "nsContentUtils.h"
+#include "nsIPlatformCharset.h"
+#include "nsNativeCharsetUtils.h"
 #include "nsCExternalHandlerService.h"
 
 USING_FILE_NAMESPACE
@@ -30,25 +32,115 @@ ArchiveZipItem::~ArchiveZipItem()
   MOZ_COUNT_DTOR(ArchiveZipItem);
 }
 
-// Getter/Setter for the filename
-nsCString
-ArchiveZipItem::GetFilename()
+nsresult
+ArchiveZipItem::NativeFilename()
 {
-  return mFilename;
+  if (NS_IsNativeUTF8())
+    return NS_ERROR_FAILURE;
+
+  nsString filenameU;
+  nsCString charset;
+
+  nsresult rv;
+  nsCOMPtr<nsIPlatformCharset> platformCharset = do_GetService(NS_PLATFORMCHARSET_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = platformCharset->GetCharset(kPlatformCharsetSel_FileName, charset);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = nsContentUtils::ConvertStringFromCharset(charset, mFilename, filenameU);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (filenameU.IsEmpty())
+    return NS_ERROR_FAILURE;
+
+  mFilenameU = NS_ConvertUTF16toUTF8(filenameU);
+  return NS_OK;
 }
 
-void
-ArchiveZipItem::SetFilename(const nsCString& aFilename)
+nsresult
+ArchiveZipItem::GuessFilename()
 {
-  mFilename = aFilename;
+  nsCString charset;
+  nsresult rv = nsContentUtils::GuessCharset(mFilename.get(), mFilename.Length(), charset);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // The charset cannot be UTF-8:
+  if (charset.IsEmpty() || charset.EqualsLiteral("UTF-8"))
+    return NS_ERROR_FAILURE;
+
+  nsString filenameU;
+  rv = nsContentUtils::ConvertStringFromCharset(charset, mFilename, filenameU);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (filenameU.IsEmpty())
+    return NS_ERROR_FAILURE;
+
+  mFilenameU = NS_ConvertUTF16toUTF8(filenameU);
+  return NS_OK;
 }
 
+nsresult
+ArchiveZipItem::ISO8859Filename()
+{
+  nsString filenameU;
+  nsresult rv = nsContentUtils::ConvertStringFromCharset(NS_LITERAL_CSTRING("ISO-8859-1"), mFilename, filenameU);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (filenameU.IsEmpty())
+    return NS_ERROR_FAILURE;
+
+  mFilenameU = NS_ConvertUTF16toUTF8(filenameU);
+  return NS_OK;
+}
+
+nsresult
+ArchiveZipItem::GetFilename(nsCString& aFilename)
+{
+  NS_ASSERTION(NS_IsMainThread(), "main thread only");
+
+  if (mFilenameU.IsEmpty()) {
+    nsresult rv = NS_ERROR_FAILURE;
+
+    // Maybe this string is UTF-8:
+    if (IsUTF8(mFilename, false)) {
+      mFilenameU = mFilename;
+      rv = NS_OK;
+    }
+
+    // native UTF8?
+    if (NS_FAILED(rv) && !NS_IsNativeUTF8()) {
+      rv = NativeFilename();
+    }
+
+    // Let's try to guess the charset:
+    if (NS_FAILED(rv)) {
+      rv = GuessFilename();
+    }
+
+    // Last option:
+    if (NS_FAILED(rv)) {
+      rv = ISO8859Filename();
+    }
+
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  aFilename = mFilenameU;
+  return NS_OK;
+}
 
 // From zipItem to DOMFile:
 nsIDOMFile*
 ArchiveZipItem::File(ArchiveReader* aArchiveReader)
 {
-  return new ArchiveZipFile(NS_ConvertUTF8toUTF16(mFilename),
+  nsCString filename;
+  nsresult rv = GetFilename(filename);
+
+  if (NS_FAILED(rv))
+    return 0;
+
+  return new ArchiveZipFile(NS_ConvertUTF8toUTF16(filename),
                             NS_ConvertUTF8toUTF16(GetType()),
                             StrToInt32(mCentralStruct.orglen),
                             mCentralStruct,
diff --git a/dom/file/ArchiveZipEvent.h b/dom/file/ArchiveZipEvent.h
--- a/dom/file/ArchiveZipEvent.h
+++ b/dom/file/ArchiveZipEvent.h
@@ -21,8 +21,7 @@ public:
                  ZipCentral& aCentralStruct);
   virtual ~ArchiveZipItem();
 
-  void SetFilename(const nsCString& aFilename);
-  nsCString GetFilename();
+  nsresult GetFilename(nsCString& aFilename);
 
   // From zipItem to DOMFile:
   virtual nsIDOMFile* File(ArchiveReader* aArchiveReader);
@@ -31,8 +30,15 @@ public: // for the event
   static PRUint32 StrToInt32(const PRUint8* aStr);
   static PRUint16 StrToInt16(const PRUint8* aStr);
 
+private:
+  nsresult NativeFilename();
+  nsresult GuessFilename();
+  nsresult ISO8859Filename();
+
 private: // data
   nsCString mFilename;
+
+  nsCString mFilenameU;
   ZipCentral mCentralStruct;
 };
 
diff --git a/dom/file/test/Makefile.in b/dom/file/test/Makefile.in
--- a/dom/file/test/Makefile.in
+++ b/dom/file/test/Makefile.in
@@ -31,6 +31,7 @@ MOCHITEST_FILES = \
   test_workers.html \
   test_archivereader.html \
   test_archivereader_zip_in_zip.html \
+  test_archivereader_nonUnicode.html \
   $(NULL)
 
 include $(topsrcdir)/config/rules.mk
diff --git a/dom/file/test/test_archivereader_nonUnicode.html b/dom/file/test/test_archivereader_nonUnicode.html
new file mode 100644
--- /dev/null
+++ b/dom/file/test/test_archivereader_nonUnicode.html
@@ -0,0 +1,80 @@
+<!--
+  Any copyright is dedicated to the Public Domain.
+  http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<html>
+<head>
+  <title>Archive Reader Non-Unicode Test</title>
+
+  <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+
+  <script type="text/javascript;version=1.7">
+  function createNonUnicodeData() {
+    var Cc = SpecialPowers.wrap(Components).classes;
+    var Ci = SpecialPowers.wrap(Components).interfaces;
+
+    var dirSvc = Cc["@mozilla.org/file/directory_service;1"].getService(Ci.nsIProperties);
+    var testFile = dirSvc.get("ProfD", Ci.nsIFile);
+    testFile.append("fileArchiveReader_nonUnicode.zip");
+    var outStream = Cc["@mozilla.org/network/file-output-stream;1"].createInstance(Ci.nsIFileOutputStream);
+    outStream.init(testFile, 0x02 | 0x08 | 0x20, // write, create, truncate
+                   0666, 0);
+
+    var binaryData = "";
+    for (var i = 0, len = binaryString.length / 2; i < len; ++i) {
+      var hex = binaryString[i * 2] + binaryString[i * 2 + 1];
+      binaryData += String.fromCharCode(parseInt(hex,16));
+    }
+    outStream.write(binaryData, binaryData.length);
+    outStream.close();
+
+    var fileList = document.getElementById('fileList');
+    SpecialPowers.wrap(fileList).value = testFile.path;
+
+    return fileList.files[0];
+  }
+
+  function testSteps()
+  {
+    var binaryFile = createNonUnicodeData();
+
+    var r = new ArchiveReader(binaryFile);
+    isnot(r, null, "ArchiveReader cannot be null");
+
+    // GetFilename
+    var handle = r.getFilenames();
+    isnot(handle, null, "ArchiveReader.getFilenames() cannot be null");
+    handle.onsuccess = function() {
+      ok(true, "ArchiveReader.getFilenames() should return a 'success'");
+      is(this.result instanceof Array, true, "ArchiveReader.getFilenames() should return an array");
+      is(this.result.length, 1, "ArchiveReader.getFilenames(): the array contains 1 item");
+      ok(this.reader, r, "ArchiveRequest.reader should be == ArchiveReader");
+      dump('Content: ' + this.result[0] + '\n');
+      finishTest();
+    }
+
+    yield;
+  }
+
+  </script>
+  <script type="text/javascript;version=1.7" src="helpers.js"></script>
+
+</head>
+
+<body onload="runTest();">
+<p id="display">
+  <input id="fileList" type="file"></input>
+</p>
+<script type="text/javascript;version=1.7">
+var binaryString = '' +
+'504B0304140000000000255D094100000000000000000000000002000000912F504B03040A0000000000285D09416BB50A5A' +
+'010000000100000007000000912F9B2E747874D8504B01023F00140000000000255D09410000000000000000000000000200' +
+'24000000000000001000000000000000912F0A002000000000000100180062505F1A1376CD0162505F1A1376CD01FE3F8D59' +
+'1176CD01504B01023F000A0000000000285D09416BB50A5A0100000001000000070024000000000000002000000020000000' +
+'912F9B2E7478740A0020000000000001001800565EF41D1376CD0107BD73631176CD0107BD73631176CD01504B0506000000' +
+'0002000200AD000000460000000000';
+</script>
+</body>
+
+</html>