Bugzilla

[scriptable, uuid(94490b3f-f094-418e-b1b9-73878d29bff3)]

   * The "canonical" manifest is a plaintext file which sits outside of a

   * JAR file. To provide backwards-compatibility with contents.rdf, we provide

   * this function which reads a contents.rdf manifest and writes it to a file.

   *

   * @param aOldManifestURI  The URI of an old manifest to read, without

   *                         the trailing "contents.rdf", e.g.

   *                         "jar:resource:///chrome/foo.jar!/content/foo/" or

   *                         "file://path/to/contents/rdf/"

   * @param aFile            The URI of a manifest file to write. It's a good

   *                         idea to use a resource: URI if possible.

   * @param aBaseURI         The base URI for relative path creation

   *                         "jar:resource:///chrome/foo.jar!/content/foo/"

   *                         this is a separate param from aOldManifestURI so

   *                         the "contents.rdf" can be read outside of the jar

   *                         to keep the zipreader cache from holding it open.

   * @param aAppend          Whether we should append to an existing manifest

   *                         or truncate and start empty.

   * @param aSkinOnly        Only allow skin packages.

   */

  void processContentsManifest(in nsIURI aOldManifestURI, in nsIURI aFile,

                               in nsIURI aBaseURI, in boolean aAppend,

                               in boolean aSkinOnly);

  /**

#ifdef MOZ_XUL

// keep all the RDF stuff together, in case we can remove it in the far future

#include "rdf.h"

#include "nsRDFCID.h"

#include "nsIRDFService.h"

#include "nsIRDFDataSource.h"

#include "nsIRDFObserver.h"

#include "nsIRDFRemoteDataSource.h"

#include "nsIRDFXMLSink.h"

#include "nsIRDFResource.h"

#include "nsIRDFDataSource.h"

#include "nsIRDFContainer.h"

#include "nsIRDFContainerUtils.h"

#define CHROME_URI "http://www.mozilla.org/rdf/chrome#"

DEFINE_RDF_VOCAB(CHROME_URI, CHROME, packages);

DEFINE_RDF_VOCAB(CHROME_URI, CHROME, package);

DEFINE_RDF_VOCAB(CHROME_URI, CHROME, name);

DEFINE_RDF_VOCAB(CHROME_URI, CHROME, platformPackage);

#endif

  // these atoms appear in almost every chrome registry contents.rdf

  // in some form or another. making static atoms prevents the atoms

  // from constantly being created/destroyed during parsing

  static const nsStaticAtom atoms[] = {

    { "chrome",        nsnull },

    { "NC",            nsnull },

    { "allowScripts",  nsnull },

    { "package",       nsnull },

    { "packages",      nsnull },

    { "hasOverlays",   nsnull },

  };

  NS_RegisterStaticAtoms(atoms, NS_ARRAY_LENGTH(atoms));

  // this is the main manifest; if it doesn't exist we generate it from

  // installed-chrome.txt. When the build system learns about the new system,

  // this code can go away.

#ifdef DEBUG

  // In debug builds, installed-chrome.txt may change during development;

  // we just rebuild it every time because we're not worried about startup

  // time or other bad/goodness.

  if (exists) {

    manifest->Remove(PR_FALSE);

    exists = PR_FALSE;

  }

#endif

  if (!exists) {

    nsCOMPtr<nsIFile> installed;

    manifest->Clone(getter_AddRefs(installed));

    if (!installed)

      return NS_ERROR_OUT_OF_MEMORY;

    nsCOMPtr<nsILocalFile> linstalled (do_QueryInterface(installed));

    NS_ENSURE_TRUE(linstalled, NS_NOINTERFACE);

    linstalled->SetNativeLeafName(NS_LITERAL_CSTRING("installed-chrome.txt"));

    rv = linstalled->Exists(&exists);

    NS_ENSURE_SUCCESS(rv, rv);

    // process installed-chrome.txt into app-chrome.manifest

    if (exists)

      ProcessNewChromeFile(linstalled, manifestURI);

  }

nsresult

nsChromeRegistry::ProcessNewChromeFile(nsILocalFile *aListFile, nsIURI* aManifest)

{

  nsresult rv;

  PRFileDesc *file;

  rv = aListFile->OpenNSPRFileDesc(PR_RDONLY, 0, &file);

  NS_ENSURE_SUCCESS(rv, rv);

  PRInt32 n, size;

  char *buf;

  size = PR_Available(file);

  if (size == -1) {

    rv = NS_ERROR_UNEXPECTED;

    goto end;

  }

  buf = (char *) malloc(size + 1);

  if (!buf) {

    rv = NS_ERROR_OUT_OF_MEMORY;

    goto end;

  }

  n = PR_Read(file, buf, size);

  if (n > 0)

    rv = ProcessNewChromeBuffer(buf, size, aManifest);

  free(buf);

end:

  PR_Close(file);

  return rv;

}

nsresult

nsChromeRegistry::ProcessNewChromeBuffer(char *aBuffer, PRInt32 aLength,

                                         nsIURI* aManifest)

{

  nsresult rv = NS_OK;

  char   *bufferEnd = aBuffer + aLength;

  char   *chromeType,      // "content", "locale" or "skin"

         *chromeProfile,   // "install" or "profile"

         *chromeLocType,   // type of location (local path or URL)

         *chromeLocation;  // base location of chrome (jar file)

  nsCOMPtr<nsIURI> baseURI;

  // process chromeType, chromeProfile, chromeLocType, chromeLocation

  while (aBuffer < bufferEnd) {

    // parse one line of installed-chrome.txt

    chromeType = aBuffer;

    while (aBuffer < bufferEnd && *aBuffer != ',')

      ++aBuffer;

    *aBuffer = '\0';

    chromeProfile = ++aBuffer;

    if (aBuffer >= bufferEnd)

      break;

    while (aBuffer < bufferEnd && *aBuffer != ',')

      ++aBuffer;

    *aBuffer = '\0';

    chromeLocType = ++aBuffer;

    if (aBuffer >= bufferEnd)

      break;

    while (aBuffer < bufferEnd && *aBuffer != ',')

      ++aBuffer;

    *aBuffer = '\0';

    chromeLocation = ++aBuffer;

    if (aBuffer >= bufferEnd)

      break;

    while (aBuffer < bufferEnd &&

           (*aBuffer != '\r' && *aBuffer != '\n' && *aBuffer != ' '))

      ++aBuffer;

    *aBuffer = '\0';

    // process the line

    // We don't do skin or locale selection from installed-chrome.txt since

    // ffox 0.9. Just ignore the "select" lines.

    if (strcmp(chromeLocType,"select")) {

      if (!strcmp(chromeLocType, "path")) {

        // location is a (full) path. convert it to an URL.

        /* this is some convoluted shit... this creates a file, inits it with

         * the path parsed above (chromeLocation), makes a url, and inits it

         * with the file created. the purpose of this is just to have the

         * canonical url of the stupid thing.

         */

        nsCOMPtr<nsILocalFile> chromeFile;

        rv = NS_NewNativeLocalFile(nsDependentCString(chromeLocation),

                                   PR_TRUE, getter_AddRefs(chromeFile));

        NS_ENSURE_SUCCESS(rv, rv);

        /* 

         * all we want here is the canonical url

         */

        rv = NS_NewFileURI(getter_AddRefs(baseURI), chromeFile);

        if (NS_FAILED(rv)) return rv;

      }

      else {

        rv = NS_NewURI(getter_AddRefs(baseURI), chromeLocation);

        if (NS_FAILED(rv)) return rv;

      }

      ProcessContentsManifest(baseURI, aManifest, baseURI, PR_TRUE,

                              strcmp(chromeType, "skin") == 0);

    }

    while (aBuffer < bufferEnd && (*aBuffer == '\0' || *aBuffer == ' ' || *aBuffer == '\r' || *aBuffer == '\n'))

      ++aBuffer;

  }

  return NS_OK;

}

#ifdef MOZ_XUL

static nsresult

GetContainerEnumerator(nsIRDFDataSource* ds, nsIRDFResource* res,

                       nsISimpleEnumerator* *aResult, PRInt32 *aCountResult = nsnull)

{

  nsresult rv;

  nsCOMPtr<nsIRDFContainer> container

    (do_CreateInstance("@mozilla.org/rdf/container;1"));

  NS_ENSURE_TRUE(container, NS_ERROR_FAILURE);

  rv = container->Init(ds, res);

  if (NS_FAILED(rv)) return rv;

  if (aCountResult)

    container->GetCount(aCountResult);

  return container->GetElements(aResult);

}

static void

FollowLiteral(nsIRDFDataSource* ds, nsIRDFResource* res,

              nsIRDFResource* arc, nsACString& result)

{

  nsresult rv;

  nsCOMPtr<nsIRDFNode> node;

  rv = ds->GetTarget(res, arc, PR_TRUE, getter_AddRefs(node));

  if (NS_FAILED(rv) || !node) {

    result.Truncate();

    return;

  }

  nsCOMPtr<nsIRDFLiteral> literal (do_QueryInterface(node));

  if (!literal) {

    NS_ERROR("Arc found, but doesn't point to expected literal!");

    result.Truncate();

    return;

  }

  const PRUnichar* value;

  literal->GetValueConst(&value);

  CopyUTF16toUTF8(value, result);

}

static void

FollowResource(nsIRDFDataSource* ds, nsIRDFResource* res, nsIRDFResource* arc,

               nsIRDFResource* *result)

{

  nsresult rv;

  nsCOMPtr<nsIRDFNode> node;

  rv = ds->GetTarget(res, arc, PR_TRUE, getter_AddRefs(node));

  if (NS_FAILED(rv) || !node) {

    *result = nsnull;

    return;

  }

  CallQueryInterface(node, result);

}

static void

GetRelativePath(nsIURI* base, nsIURI* relative, nsACString& result)

{

  nsresult rv;

  nsCOMPtr<nsIJARURI> jarrelative (do_QueryInterface(relative));

  if (jarrelative) {

    nsCOMPtr<nsIURI> jarbase;

    jarrelative->GetJARFile(getter_AddRefs(jarbase));

    nsCAutoString relativeBase;

    GetRelativePath(base, jarbase, relativeBase);

    nsCAutoString jarEntry;

    jarrelative->GetJAREntry(jarEntry);

    result.Assign(NS_LITERAL_CSTRING("jar:"));

    result.Append(relativeBase);

    result.Append(NS_LITERAL_CSTRING("!/"));

    result.Append(jarEntry);

    return;

  }

  nsCOMPtr<nsIURL> baseURL (do_QueryInterface(base));

  if (!baseURL) {

    relative->GetSpec(result);

    return;

  }

  rv = baseURL->GetRelativeSpec(relative, result);

  if (NS_FAILED(rv)) {

    relative->GetSpec(result);

  }

}

static const PRInt32 kNSPR_APPEND_FLAGS = PR_WRONLY | PR_CREATE_FILE | PR_APPEND;

static const PRInt32 kNSPR_TRUNCATE_FLAGS = PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE;

NS_IMETHODIMP

nsChromeRegistry::ProcessContentsManifest(nsIURI* aOldManifest, nsIURI* aFile,

                                          nsIURI* aBaseURI, PRBool aAppend,

                                          PRBool aSkinOnly)

{

  nsresult rv;

  nsCAutoString relativePath;

  GetRelativePath(aFile, aBaseURI, relativePath);

  nsCAutoString spec;

  aOldManifest->GetSpec(spec);

  NS_ASSERTION(spec.Last() == '/', "installed-chrome manifest URI doesn't end in a slash! It probably won't work.");

  spec.AppendLiteral("contents.rdf");

  nsCOMPtr<nsIRDFService> rdfs (do_GetService("@mozilla.org/rdf/rdf-service;1"));

  NS_ENSURE_TRUE(rdfs, NS_ERROR_FAILURE);

  nsCOMPtr<nsIRDFResource> namearc, platformarc;

  rdfs->GetResource(NS_LITERAL_CSTRING(kURICHROME_name),

                    getter_AddRefs(namearc));

  rdfs->GetResource(NS_LITERAL_CSTRING(kURICHROME_platformPackage),

                    getter_AddRefs(platformarc));

  if (!(namearc && platformarc))

    return NS_ERROR_FAILURE;

  nsCOMPtr<nsIRDFDataSource> ds;

  rv = rdfs->GetDataSourceBlocking(spec.get(), getter_AddRefs(ds));

  if (NS_FAILED(rv)) {

    LogMessage("Failed to load old-style contents.rdf at '%s'.",

               spec.get());

    return rv;

  }

  nsCOMPtr<nsIFileURL> fileURL (do_QueryInterface(aFile));

  NS_ENSURE_TRUE(fileURL, NS_ERROR_INVALID_ARG);

  nsCOMPtr<nsIFile> file;

  rv = fileURL->GetFile(getter_AddRefs(file));

  NS_ENSURE_SUCCESS(rv, rv);

  nsCOMPtr<nsILocalFile> lfile (do_QueryInterface(file));

  NS_ENSURE_TRUE(lfile, NS_ERROR_NO_INTERFACE);

  PRFileDesc* fd;

  rv = lfile->OpenNSPRFileDesc(aAppend ? kNSPR_APPEND_FLAGS : kNSPR_TRUNCATE_FLAGS,

                               0664, &fd);

  NS_ENSURE_SUCCESS(rv, rv);

  if (aAppend)

    PR_Write(fd, "\n", 1);

  nsCOMPtr<nsIRDFResource> root;

  rv = rdfs->GetResource(NS_LITERAL_CSTRING("urn:mozilla:skin:root"),

                         getter_AddRefs(root));

  if (NS_SUCCEEDED(rv))

    ProcessProvider(fd, rdfs, ds, root, PR_FALSE, relativePath);

  rv = rdfs->GetResource(NS_LITERAL_CSTRING("urn:mozilla:stylesheets"),

                         getter_AddRefs(root));

  if (NS_SUCCEEDED(rv))

    ProcessOverlays(fd, ds, root, NS_LITERAL_CSTRING("style"));

  if (!aSkinOnly) {

    rv = rdfs->GetResource(NS_LITERAL_CSTRING("urn:mozilla:locale:root"),

                           getter_AddRefs(root));

    if (NS_SUCCEEDED(rv))

      ProcessProvider(fd, rdfs, ds, root, PR_TRUE, relativePath);

    rv = rdfs->GetResource(NS_LITERAL_CSTRING("urn:mozilla:overlays"),

                         getter_AddRefs(root));

    if (NS_SUCCEEDED(rv))

      ProcessOverlays(fd, ds, root, NS_LITERAL_CSTRING("overlay"));

    /* content packages are easier, but different */

    rv = rdfs->GetResource(NS_LITERAL_CSTRING("urn:mozilla:package:root"),

                           getter_AddRefs(root));

    nsCOMPtr<nsISimpleEnumerator> packages;

    if (NS_SUCCEEDED(rv))

      rv = GetContainerEnumerator(ds, root, getter_AddRefs(packages));

    if (NS_SUCCEEDED(rv)) {

      PRBool more;

      nsCOMPtr<nsISupports> next;

      nsCOMPtr<nsIRDFResource> package;

      while (NS_SUCCEEDED(packages->HasMoreElements(&more)) && more) {

        packages->GetNext(getter_AddRefs(next));

        package = do_QueryInterface(next);

        if (!package) {

          NS_WARNING("Arc from urn:mozilla:package:root points to non-resource node.");

          continue;

        }

        nsCAutoString name;

        FollowLiteral(ds, package, namearc, name);

        if (name.IsEmpty())

          continue;

        nsCAutoString isPlatform;

        FollowLiteral(ds, package, platformarc, isPlatform);

        name.Insert(NS_LITERAL_CSTRING("content\t"), 0);

        name.Append('\t');

        name.Append(relativePath);

        if (!isPlatform.IsEmpty())

          name.AppendLiteral("\tplatform");

        name.AppendLiteral(NS_LINEBREAK);

        PR_Write(fd, name.get(), name.Length());

      }

    }

  }

  PR_Close(fd);

  return NS_OK;

}

static void

GetResourceName(nsIRDFResource* res, nsACString& result)

{

  // we need to get the provider name. Instead of doing something sane,

  // we munge the resource URI, looking from the right for colons.

  nsCAutoString providerURI;

  res->GetValueUTF8(providerURI);

  PRInt32 found = providerURI.RFindChar(':');

  if (found == kNotFound) {

    result.Truncate();

    return;

  }

  result.Assign(Substring(providerURI, found + 1));

}

void

nsChromeRegistry::ProcessProvider(PRFileDesc *fd, nsIRDFService* aRDFs,

                                  nsIRDFDataSource* aDS, nsIRDFResource* aRoot,

                                  PRBool aIsLocale, const nsACString& aBaseURL)

{

  NS_NAMED_LITERAL_CSTRING(kSlash, "/");

  NS_NAMED_LITERAL_CSTRING(kTab, "\t");

  nsresult rv;

  nsCOMPtr<nsIRDFResource> packagesarc;

  aRDFs->GetResource(NS_LITERAL_CSTRING(kURICHROME_packages),

                    getter_AddRefs(packagesarc));

  if (!packagesarc) return;

  nsCOMPtr<nsISimpleEnumerator> providers;

  rv = GetContainerEnumerator(aDS, aRoot, getter_AddRefs(providers));

  if (NS_FAILED(rv)) {

    return;

  }

  nsCOMPtr<nsISupports> next;

  PRBool more;

  while (NS_SUCCEEDED(providers->HasMoreElements(&more)) && more) {

    providers->GetNext(getter_AddRefs(next));

    NS_ASSERTION(next, "GetNext failed after HasMoreElements succeeded.");

    nsCOMPtr<nsIRDFResource> provider (do_QueryInterface(next));

    if (!provider) {

      NS_WARNING("Provider isn't a nsIRDFResource.");

      continue;

    }

    nsCAutoString providerName;

    GetResourceName(provider, providerName);

    if (providerName.IsEmpty()) {

      NS_WARNING("Couldn't calculate resource name.");

      continue;

    }

    nsCOMPtr<nsIRDFResource> packages;

    FollowResource(aDS, provider, packagesarc, getter_AddRefs(packages));

    if (!packages) {

      NS_WARNING("No chrome:packages arc found!");

      continue;

    }

    PRInt32 count;

    nsCOMPtr<nsISimpleEnumerator> packageList;

    rv = GetContainerEnumerator(aDS, packages, getter_AddRefs(packageList), &count);

    if (NS_FAILED(rv)) {

      NS_WARNING("chrome:packages was not a sequence.");

      continue;

    }

    nsCOMPtr<nsISupports> nextPackage;

    PRBool morePackages;

    while (NS_SUCCEEDED(packageList->HasMoreElements(&morePackages)) &&

           morePackages) {

      packageList->GetNext(getter_AddRefs(nextPackage));

      nsCOMPtr<nsIRDFResource> packageRes (do_QueryInterface(nextPackage));

      if (!packageRes) {

        NS_WARNING("chrome:packages Seq points to a non-resource!");

        continue;

      }

      nsCAutoString packageName;

      GetResourceName(packageRes, packageName);

      if (packageName.IsEmpty()) {

        NS_WARNING("couldn't extract a package name.");

        continue;

      }

      nsCAutoString line;

      if (aIsLocale)

        line.AppendLiteral("locale\t");

      else

        line.AppendLiteral("skin\t");

      line += packageName + kTab + providerName + kTab + aBaseURL;

      if (count > 1) {

        line += packageName + kSlash;

      }

      line.AppendLiteral(NS_LINEBREAK);

      PR_Write(fd, line.get(), line.Length());

    }

  }

}

static void

GetLiteralText(nsIRDFLiteral* lit, nsACString& result)

{

  const PRUnichar* value;

  lit->GetValueConst(&value);

  CopyUTF16toUTF8(value, result);

}

void

nsChromeRegistry::ProcessOverlays(PRFileDesc *fd, nsIRDFDataSource* aDS,

                                  nsIRDFResource* aRoot,

                                  const nsCSubstring& aType)

{

  NS_NAMED_LITERAL_CSTRING(kTab, "\t");

  NS_NAMED_LITERAL_CSTRING(kLinebreak, NS_LINEBREAK);

  nsresult rv;

  nsCOMPtr<nsISimpleEnumerator> overlaids;

  rv = GetContainerEnumerator(aDS, aRoot, getter_AddRefs(overlaids));

  if (NS_FAILED(rv)) {

    return;

  }

  nsCOMPtr<nsISupports> next;

  PRBool more;

  while (NS_SUCCEEDED(overlaids->HasMoreElements(&more)) && more) {

    overlaids->GetNext(getter_AddRefs(next));

    NS_ASSERTION(next, "GetNext failed after HasMoreElements succeeded.");

    nsCOMPtr<nsIRDFResource> overlaid (do_QueryInterface(next));

    if (!overlaid) {

      NS_WARNING("Overlay arc is not a nsIRDFResource.");

      continue;

    }

    nsCAutoString overlaidName;

    overlaid->GetValueUTF8(overlaidName);

    nsCOMPtr<nsISimpleEnumerator> overlays;

    rv = GetContainerEnumerator(aDS, overlaid, getter_AddRefs(overlays));

    if (NS_FAILED(rv))

      continue;

    while (NS_SUCCEEDED(overlays->HasMoreElements(&more)) && more) {

      overlays->GetNext(getter_AddRefs(next));

      NS_ASSERTION(next, "GetNext failed after HasMoreElements succeeded.");

      nsCOMPtr<nsIRDFLiteral> overlay (do_QueryInterface(next));

      if (!overlay) {

        NS_WARNING("Overlay was not an RDF literal.");

        continue;

      }

      nsCAutoString overlayName;

      GetLiteralText(overlay, overlayName);

      overlayName.Insert(aType + kTab + overlaidName + kTab, 0);

      overlayName.Append(kLinebreak);

      PR_Write(fd, overlayName.get(), overlayName.Length());

    }

  }

}

#else // MOZ_XUL

NS_IMETHODIMP

nsChromeRegistry::ProcessContentsManifest(nsIURI* aOldManifest, nsIURI* aFile,

                                          nsIURI* aBaseURI, PRBool aAppend,

                                          PRBool aSkinOnly)

{

  return NS_ERROR_NOT_IMPLEMENTED;

}

#endif // MOZ_XUL