--- a/browser/components/nsBrowserGlue.js
+++ b/browser/components/nsBrowserGlue.js
@@ -47,16 +47,21 @@ const Cc = Components.classes;
 const Cr = Components.results;
 const Cu = Components.utils;
 
 const XULNS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
 
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 Cu.import("resource://gre/modules/Services.jsm");
 
+XPCOMUtils.defineLazyGetter(this, "NetUtil", function() {
+  Cu.import("resource://gre/modules/NetUtil.jsm");
+  return NetUtil;
+});
+
 const PREF_EM_NEW_ADDONS_LIST = "extensions.newAddons";
 const PREF_PLUGINS_NOTIFYUSER = "plugins.update.notifyUser";
 const PREF_PLUGINS_UPDATEURL  = "plugins.update.url";
 
 // We try to backup bookmarks at idle times, to avoid doing that at shutdown.
 // Number of idle seconds before trying to backup bookmarks.  15 minutes.
 const BOOKMARKS_BACKUP_IDLE_TIME = 15 * 60;
 // Minimum interval in milliseconds between backups.
@@ -835,36 +840,38 @@ BrowserGlue.prototype = {
       } catch(ex) {}
       if (!autoExportHTML && smartBookmarksVersion != -1)
         Services.prefs.setIntPref("browser.places.smartBookmarksVersion", 0);
 
       // Get bookmarks.html file location
       var dirService = Cc["@mozilla.org/file/directory_service;1"].
                        getService(Ci.nsIProperties);
 
-      var bookmarksFile = null;
+      var bookmarksURI = null;
       if (restoreDefaultBookmarks) {
         // User wants to restore bookmarks.html file from default profile folder
-        bookmarksFile = dirService.get("profDef", Ci.nsILocalFile);
-        bookmarksFile.append("bookmarks.html");
+        bookmarksURI = NetUtil.newURI("resource:///defaults/profile/bookmarks.html");
       }
-      else
-        bookmarksFile = dirService.get("BMarks", Ci.nsILocalFile);
+      else {
+        var bookmarksFile = dirService.get("BMarks", Ci.nsILocalFile);
+        if (bookmarksFile.exists())
+          bookmarksURI = NetUtil.newURI(bookmarksFile);
+      }
 
-      if (bookmarksFile.exists()) {
+      if (bookmarksURI) {
         // Add an import observer.  It will ensure that smart bookmarks are
         // created once the operation is complete.
         Services.obs.addObserver(this, "bookmarks-restore-success", false);
         Services.obs.addObserver(this, "bookmarks-restore-failed", false);
 
         // Import from bookmarks.html file.
         try {
           var importer = Cc["@mozilla.org/browser/places/import-export-service;1"].
                          getService(Ci.nsIPlacesImportExportService);
-          importer.importHTMLFromFile(bookmarksFile, true /* overwrite existing */);
+          importer.importHTMLFromURI(bookmarksURI, true /* overwrite existing */);
         } catch (err) {
           // Report the error, but ignore it.
           Cu.reportError("Bookmarks.html file could be corrupt. " + err);
           Services.obs.removeObserver(this, "bookmarks-restore-success");
           Services.obs.removeObserver(this, "bookmarks-restore-failed");
         }
       }
       else

--- a/caps/tests/mochitest/Makefile.in
+++ b/caps/tests/mochitest/Makefile.in
@@ -46,10 +46,14 @@ include $(DEPTH)/config/autoconf.mk
 include $(topsrcdir)/config/rules.mk
 
 _TEST_FILES = 	test_bug423375.html \
                 test_bug246699.html \
                 test_bug292789.html \
 		test_bug470804.html \
 		$(NULL)
 
+test_bug292789.html : % : %.in
+	$(PYTHON) $(topsrcdir)/config/Preprocessor.py \
+	     $(AUTOMATION_PPARGS) $(DEFINES) $(ACDEFINES) $< > $@
+
 libs:: $(_TEST_FILES)
 	$(INSTALL) $(foreach f,$^,"$f") $(DEPTH)/_tests/testing/mochitest/tests/$(relativesrcdir)

rename from caps/tests/mochitest/test_bug292789.html
rename to caps/tests/mochitest/test_bug292789.html.in
--- a/caps/tests/mochitest/test_bug292789.html
+++ b/caps/tests/mochitest/test_bug292789.html.in
@@ -33,34 +33,42 @@ function testScriptSrc(aCallback) {
        "content can still load <script> from chrome://global");
     is(typeof XPInstallConfirm, "undefined",
        "content should not be able to load <script> from chrome://mozapps");
     
     /** make sure the last one didn't pass because someone
      ** moved the resource
      **/
     var resjs = document.createElement("script");
+#ifdef MOZ_CHROME_FILE_FORMAT_JAR
     resjs.src = "jar:resource://gre/chrome/toolkit.jar!/content/mozapps/xpinstall/xpinstallConfirm.js";
+#else
+    resjs.src = "resource://gre/chrome/toolkit/content/mozapps/xpinstall/xpinstallConfirm.js";
+#endif
     resjs.onload = scriptOnload;
     document.getElementById("content").appendChild(resjs);
 
     function scriptOnload() {
       is(typeof XPInstallConfirm, "object",
          "xpinstallConfirm.js has not moved unexpectedly");
   
       // trigger the callback
       if (aCallback)
         aCallback();
     }
 }
 
 /** <img src=""> tests **/
 var img_global = "chrome://global/skin/icons/Error.png";
 var img_mozapps = "chrome://mozapps/skin/passwordmgr/key.png";
+#ifdef MOZ_CHROME_FILE_FORMAT_JAR
 var res_mozapps = "jar:resource://gre/chrome/toolkit.jar!/skin/classic/mozapps/passwordmgr/key.png";
+#else
+var res_mozapps = "resource://gre/chrome/toolkit/skin/classic/mozapps/passwordmgr/key.png";
+#endif
 
 var imgTests = [[img_global, "success"],
                 [img_mozapps, "fail"],
                 [res_mozapps, "success"]];
 
 var curImgTest = 0;
 
 function runImgTest() {

--- a/config/system-headers
+++ b/config/system-headers
@@ -1031,9 +1031,12 @@ conic/conicconnectionevent.h
 conic/conicstatisticsevent.h
 #endif
 #if MOZ_NATIVE_LIBEVENT==1
 event.h
 #endif
 #ifdef MOZ_ENABLE_LIBPROXY
 proxy.h
 #endif
+#if MOZ_PLATFORM_MAEMO==6
+contentaction/contentaction.h
+#endif
 

--- a/content/html/content/src/nsHTMLDNSPrefetch.cpp
+++ b/content/html/content/src/nsHTMLDNSPrefetch.cpp
@@ -101,16 +101,21 @@ nsHTMLDNSPrefetch::Initialize()
   sDisablePrefetchHTTPSPref = 
     nsContentUtils::GetBoolPref("network.dns.disablePrefetchFromHTTPS", PR_TRUE);
   
   NS_IF_RELEASE(sDNSService);
   nsresult rv;
   rv = CallGetService(kDNSServiceCID, &sDNSService);
   if (NS_FAILED(rv)) return rv;
   
+#ifdef MOZ_IPC
+  if (mozilla::net::IsNeckoChild())
+    mozilla::net::NeckoChild::InitNeckoChild();
+#endif
+
   sInitialized = PR_TRUE;
   return NS_OK;
 }
 
 nsresult
 nsHTMLDNSPrefetch::Shutdown()
 {
   if (!sInitialized) {

--- a/dom/ipc/ContentParent.cpp
+++ b/dom/ipc/ContentParent.cpp
@@ -48,16 +48,18 @@
 #include "nsIPrefLocalizedString.h"
 #include "nsIObserverService.h"
 #include "nsContentUtils.h"
 #include "nsAutoPtr.h"
 #include "nsCOMPtr.h"
 #include "nsServiceManagerUtils.h"
 #include "nsThreadUtils.h"
 #include "nsChromeRegistryChrome.h"
+#include "nsExternalHelperAppService.h"
+#include "nsCExternalHandlerService.h"
 
 #ifdef ANDROID
 #include "AndroidBridge.h"
 using namespace mozilla;
 #endif
 
 using namespace mozilla::ipc;
 using namespace mozilla::net;
@@ -465,16 +467,27 @@ ContentParent::RecvSetURITitle(const IPC
                                       const nsString& title)
 {
     nsCOMPtr<nsIURI> ourURI(uri);
     IHistory *history = nsContentUtils::GetHistory(); 
     history->SetURITitle(ourURI, title);
     return true;
 }
 
+bool
+ContentParent::RecvLoadURIExternal(const IPC::URI& uri)
+{
+    nsCOMPtr<nsIExternalProtocolService> extProtService(do_GetService(NS_EXTERNALPROTOCOLSERVICE_CONTRACTID));
+    if (!extProtService)
+        return true;
+    nsCOMPtr<nsIURI> ourURI(uri);
+    extProtService->LoadURI(ourURI, nsnull);
+    return true;
+}
+
 /* void onDispatchedEvent (in nsIThreadInternal thread); */
 NS_IMETHODIMP
 ContentParent::OnDispatchedEvent(nsIThreadInternal *thread)
 {
     if (mOldObserver)
         return mOldObserver->OnDispatchedEvent(thread);
 
     return NS_OK;

--- a/dom/ipc/ContentParent.h
+++ b/dom/ipc/ContentParent.h
@@ -157,16 +157,18 @@ private:
     
     virtual bool RecvNotifyIME(const int&, const int&);
 
     virtual bool RecvNotifyIMEChange(const nsString&, const PRUint32&, const int&, 
                                const int&, const int&)
 ;
 
 
+    virtual bool RecvLoadURIExternal(const IPC::URI& uri);
+
     mozilla::Monitor mMonitor;
 
     GeckoChildProcessHost* mSubprocess;
 
     int mRunToCompletionDepth;
     bool mShouldCallUnblockChild;
     nsCOMPtr<nsIThreadObserver> mOldObserver;
 

--- a/dom/ipc/Makefile.in
+++ b/dom/ipc/Makefile.in
@@ -77,13 +77,14 @@ include $(topsrcdir)/ipc/chromium/chromi
 include $(topsrcdir)/config/rules.mk
 
 LOCAL_INCLUDES += \
 		-I$(srcdir)/../../content/base/src \
 		-I$(srcdir)/../../content/events/src \
 		-I$(srcdir)/../../toolkit/components/places/src \
 		-I$(srcdir)/../src/geolocation \
 		-I$(topsrcdir)/chrome/src \
+		-I$(topsrcdir)/uriloader/exthandler \
 		$(NULL)
 
 CXXFLAGS += $(TK_CFLAGS)
 
 DEFINES += -DBIN_SUFFIX='"$(BIN_SUFFIX)"'

--- a/dom/ipc/PContent.ipdl
+++ b/dom/ipc/PContent.ipdl
@@ -76,16 +76,18 @@ parent:
     PNecko();
 
     // Services remoting
 
     async StartVisitedQuery(URI uri);
     async VisitURI(URI uri, URI referrer, PRUint32 flags);
     async SetURITitle(URI uri, nsString title);
 
+    async LoadURIExternal(URI uri);
+
     // PrefService messages
     sync GetPrefType(nsCString prefName) returns (PRInt32 retValue, nsresult rv);
     sync GetBoolPref(nsCString prefName) returns (PRBool retValue, nsresult rv);
     sync GetIntPref(nsCString prefName)  returns (PRInt32 retValue, nsresult rv);
     sync GetCharPref(nsCString prefName) returns (nsCString retValue, nsresult rv);
     sync GetPrefLocalizedString(nsCString prefName) returns (nsString retValue, nsresult rv);
     sync PrefHasUserValue(nsCString prefName) returns (PRBool retValue, nsresult rv);
     sync PrefIsLocked(nsCString prefName) returns (PRBool retValue, nsresult rv);

--- a/embedding/android/AndroidManifest.xml.in
+++ b/embedding/android/AndroidManifest.xml.in
@@ -9,17 +9,18 @@
     <uses-sdk android:minSdkVersion="5"
               android:targetSdkVersion="5"/>
 
     <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/> 
     <uses-permission android:name="android.permission.INTERNET"/> 
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/> 
 
     <application android:label="@MOZ_APP_DISPLAYNAME@"
-		 android:icon="@drawable/icon">
+		 android:icon="@drawable/icon"
+		 android:debuggable="true">
         <activity android:name="App"
                   android:label="@MOZ_APP_DISPLAYNAME@"
                   android:configChanges="keyboard|keyboardHidden|orientation|mcc|mnc"
                   android:windowSoftInputMode="stateUnspecified|adjustResize"
                   android:launchMode="singleInstance">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
                 <category android:name="android.intent.category.LAUNCHER" />

--- a/embedding/android/GeckoAppShell.java
+++ b/embedding/android/GeckoAppShell.java
@@ -152,17 +152,17 @@ class GeckoAppShell
         GeckoAppShell.nativeInit();
 
         // Tell Gecko where the target surface view is for rendering
         GeckoAppShell.setSurfaceView(GeckoApp.surfaceView);
 
         sGeckoRunning = true;
 
         // First argument is the .apk path
-        String combinedArgs = apkPath;
+        String combinedArgs = apkPath + " -omnijar " + apkPath;
         if (args != null)
             combinedArgs += " " + args;
         if (url != null)
             combinedArgs += " " + url;
         // and go
         GeckoAppShell.nativeRun(combinedArgs);
     }
 

--- a/embedding/browser/webBrowser/nsWebBrowser.cpp
+++ b/embedding/browser/webBrowser/nsWebBrowser.cpp
@@ -86,16 +86,17 @@
 // Printing Includes
 #ifdef NS_PRINTING
 #include "nsIWebBrowserPrint.h"
 #include "nsIContentViewer.h"
 #endif
 
 // PSM2 includes
 #include "nsISecureBrowserUI.h"
+#include "nsXULAppAPI.h"
 
 using namespace mozilla::layers;
 
 static NS_DEFINE_IID(kWindowCID, NS_WINDOW_CID);
 static NS_DEFINE_CID(kChildCID, NS_CHILD_CID);
 static NS_DEFINE_CID(kLookAndFeelCID, NS_LOOKANDFEEL_CID);
 
 
@@ -785,16 +786,17 @@ NS_IMETHODIMP nsWebBrowser::SetProperty(
         }
         break;
     case nsIWebBrowserSetup::SETUP_ALLOW_DNS_PREFETCH:
         {
             NS_ENSURE_STATE(mDocShell);
             NS_ENSURE_TRUE((aValue == PR_TRUE || aValue == PR_FALSE), NS_ERROR_INVALID_ARG);
             mDocShell->SetAllowDNSPrefetch(!!aValue);
         }
+        break;
     case nsIWebBrowserSetup::SETUP_USE_GLOBAL_HISTORY:
         {
            NS_ENSURE_STATE(mDocShell);
            NS_ENSURE_TRUE((aValue == PR_TRUE || aValue == PR_FALSE), NS_ERROR_INVALID_ARG);
            rv = EnableGlobalHistory(!!aValue);
            mShouldEnableHistory = aValue;
         }
         break;
@@ -1225,20 +1227,22 @@ NS_IMETHODIMP nsWebBrowser::Create()
    // events from subframes. To solve that we install our own chrome event handler
    // that always gets called (even for subframes) for any bubbling event.
 
     if (!mInitInfo->sessionHistory) {
         mInitInfo->sessionHistory = do_CreateInstance(NS_SHISTORY_CONTRACTID, &rv);
         NS_ENSURE_SUCCESS(rv, rv);
     }
    mDocShellAsNav->SetSessionHistory(mInitInfo->sessionHistory);
-   
-   // Hook up global history. Do not fail if we can't - just warn.
-    rv = EnableGlobalHistory(mShouldEnableHistory);
-   NS_WARN_IF_FALSE(NS_SUCCEEDED(rv), "EnableGlobalHistory() failed");
+
+   if (XRE_GetProcessType() == GeckoProcessType_Default) {
+       // Hook up global history. Do not fail if we can't - just warn.
+       rv = EnableGlobalHistory(mShouldEnableHistory);
+       NS_WARN_IF_FALSE(NS_SUCCEEDED(rv), "EnableGlobalHistory() failed");
+   }
 
    NS_ENSURE_SUCCESS(mDocShellAsWin->Create(), NS_ERROR_FAILURE);
 
     // Hook into the OnSecurityChange() notification for lock/unlock icon
    // updates
    nsCOMPtr<nsIDOMWindow> domWindow;
    rv = GetContentDOMWindow(getter_AddRefs(domWindow));
    if (NS_SUCCEEDED(rv))

--- a/intl/locale/src/nsLocaleService.cpp
+++ b/intl/locale/src/nsLocaleService.cpp
@@ -55,16 +55,19 @@
 #  include "nsIOS2Locale.h"
 #elif defined(XP_MACOSX)
 #  include <Carbon/Carbon.h>
 #  include "nsIMacLocale.h"
 #elif defined(XP_UNIX) || defined(XP_BEOS)
 #  include <locale.h>
 #  include <stdlib.h>
 #  include "nsIPosixLocale.h"
+#if (MOZ_PLATFORM_MAEMO >= 6)
+#  include "nsIGConfService.h"
+#endif
 #endif
 
 //
 // implementation constants
 const int LocaleListLength = 6;
 const char* LocaleList[LocaleListLength] = 
 {
 	NSILOCALE_COLLATE,
@@ -169,34 +172,53 @@ nsLocaleService::nsLocaleService(void)
         nsAutoString category, category_platform;
         nsLocale* resultLocale;
         int i;
 
         resultLocale = new nsLocale();
         if ( resultLocale == NULL ) { 
             return; 
         }
+
+        // Get system configuration
+        char* lang = getenv("LANG");
+#if (MOZ_PLATFORM_MAEMO >= 6)
+        nsCAutoString gconfLocaleString;
+        nsresult rv;
+        nsCOMPtr<nsIGConfService> gconf =
+            do_GetService(NS_GCONFSERVICE_CONTRACTID, &rv);
+        if (NS_SUCCEEDED(rv)) {
+            rv = gconf->GetString(NS_LITERAL_CSTRING("/meegotouch/i18n/language"),
+                                  gconfLocaleString);
+            if (NS_SUCCEEDED(rv) && !gconfLocaleString.IsEmpty()) {
+                lang = static_cast<const char*>(gconfLocaleString.get());
+                // For setlocale() doing the right thing we need to export
+                // this as LANG to the environment
+                setenv("LANG", lang, 1);
+            }
+        }
+#endif
         for( i = 0; i < LocaleListLength; i++ ) {
             nsresult result;
+            // setlocale( , "") evaluates LC_* and LANG
             char* lc_temp = setlocale(posix_locale_category[i], "");
             CopyASCIItoUTF16(LocaleList[i], category);
-            category_platform = category; 
+            category_platform = category;
             category_platform.AppendLiteral("##PLATFORM");
             if (lc_temp != nsnull) {
                 result = posixConverter->GetXPLocale(lc_temp, xpLocale);
                 CopyASCIItoUTF16(lc_temp, platformLocale);
             } else {
-                char* lang = getenv("LANG");
                 if ( lang == nsnull ) {
                     platformLocale.AssignLiteral("en_US");
                     result = posixConverter->GetXPLocale("en-US", xpLocale);
                 }
                 else {
                     CopyASCIItoUTF16(lang, platformLocale);
-                    result = posixConverter->GetXPLocale(lang, xpLocale); 
+                    result = posixConverter->GetXPLocale(lang, xpLocale);
                 }
             }
             if (NS_FAILED(result)) {
                 return;
             }
             resultLocale->AddCategory(category, xpLocale);
             resultLocale->AddCategory(category_platform, platformLocale);
         }

--- a/ipc/chromium/src/chrome/common/child_process_host.cc
+++ b/ipc/chromium/src/chrome/common/child_process_host.cc
@@ -6,16 +6,17 @@
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/singleton.h"
 #include "base/waitable_event.h"
 #ifdef CHROMIUM_MOZILLA_BUILD
+#include "mozilla/ipc/ProcessChild.h"
 #include "mozilla/ipc/BrowserProcessSubThread.h"
 typedef mozilla::ipc::BrowserProcessSubThread ChromeThread;
 #else
 #include "chrome/browser/chrome_thread.h"
 #endif
 #include "chrome/common/ipc_logging.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
@@ -117,16 +118,18 @@ bool ChildProcessHost::Send(IPC::Message
   }
   return channel_->Send(msg);
 }
 
 void ChildProcessHost::Notify(NotificationType type) {
 #ifdef CHROMIUM_MOZILLA_BUILD
   MessageLoop* loop = ChromeThread::GetMessageLoop(ChromeThread::IO);
   if (!loop)
+      loop = mozilla::ipc::ProcessChild::message_loop();
+  if (!loop)
       loop = MessageLoop::current();
   loop->PostTask(
 #else
   resource_dispatcher_host_->ui_loop()->PostTask(
 #endif
       FROM_HERE, new ChildNotificationTask(type, this));
 }
 

--- a/ipc/glue/GeckoChildProcessHost.cpp
+++ b/ipc/glue/GeckoChildProcessHost.cpp
@@ -249,24 +249,16 @@ GeckoChildProcessHost::PerformAsyncLaunc
 #ifdef OS_LINUX
 #ifdef ANDROID
     path += "/lib";
 #endif
     newEnvVars["LD_LIBRARY_PATH"] = path.get();
 #elif OS_MACOSX
     newEnvVars["DYLD_LIBRARY_PATH"] = path.get();
 #endif
-#ifdef MOZ_OMNIJAR
-    // Make sure the child process can find the omnijar
-    // See ScopedXPCOMStartup::Initialize in nsAppRunner.cpp
-    nsCAutoString omnijarPath;
-    if (mozilla::OmnijarPath())
-      mozilla::OmnijarPath()->GetNativePath(omnijarPath);
-    newEnvVars["OMNIJAR_PATH"] = omnijarPath.get();
-#endif
   }
   else {
     exePath = FilePath(CommandLine::ForCurrentProcess()->argv()[0]);
     exePath = exePath.DirName();
   }
 
 #ifdef OS_MACOSX
   // We need to use an App Bundle on OS X so that we can hide
@@ -291,16 +283,27 @@ GeckoChildProcessHost::PerformAsyncLaunc
   // other end of the socketpair() from us
 
   std::vector<std::string> childArgv;
 
   childArgv.push_back(exePath.value());
 
   childArgv.insert(childArgv.end(), aExtraOpts.begin(), aExtraOpts.end());
 
+#ifdef MOZ_OMNIJAR
+  // Make sure the child process can find the omnijar
+  // See XRE_InitCommandLine in nsAppRunner.cpp
+  nsCAutoString omnijarPath;
+  if (mozilla::OmnijarPath()) {
+    mozilla::OmnijarPath()->GetNativePath(omnijarPath);
+    childArgv.push_back("-omnijar");
+    childArgv.push_back(omnijarPath.get());
+  }
+#endif
+
   childArgv.push_back(pidstring);
   childArgv.push_back(childProcessType);
 
 #if defined(MOZ_CRASHREPORTER)
 #  if defined(OS_LINUX)
   int childCrashFd, childCrashRemapFd;
   if (!CrashReporter::CreateNotificationPipeForChild(
         &childCrashFd, &childCrashRemapFd))
@@ -341,16 +344,28 @@ GeckoChildProcessHost::PerformAsyncLaunc
 
   for (std::vector<std::string>::iterator it = aExtraOpts.begin();
        it != aExtraOpts.end();
        ++it) {
       cmdLine.AppendLooseValue(UTF8ToWide(*it));
   }
 
   cmdLine.AppendLooseValue(std::wstring(mGroupId.get()));
+
+#ifdef MOZ_OMNIJAR
+  // Make sure the child process can find the omnijar
+  // See XRE_InitCommandLine in nsAppRunner.cpp
+  nsAutoString omnijarPath;
+  if (mozilla::OmnijarPath()) {
+    mozilla::OmnijarPath()->GetPath(omnijarPath);
+    cmdLine.AppendLooseValue(UTF8ToWide("-omnijar"));
+    cmdLine.AppendLooseValue(omnijarPath.get());
+  }
+#endif
+
   cmdLine.AppendLooseValue(UTF8ToWide(pidstring));
   cmdLine.AppendLooseValue(UTF8ToWide(childProcessType));
 #if defined(MOZ_CRASHREPORTER)
   cmdLine.AppendLooseValue(
     UTF8ToWide(CrashReporter::GetChildNotificationPipe()));
 #endif
 
   base::LaunchApp(cmdLine, false, false, &process);

--- a/ipc/testshell/XPCShellEnvironment.cpp
+++ b/ipc/testshell/XPCShellEnvironment.cpp
@@ -1210,16 +1210,19 @@ XPCShellEnvironment::Init()
 
     return true;
 }
 
 bool
 XPCShellEnvironment::EvaluateString(const nsString& aString,
                                     nsString* aResult)
 {
+  XPCShellEnvironment* env = Environment(mCx);
+  XPCShellEnvironment::AutoContextPusher pusher(env);
+
   JSAutoRequest ar(mCx);
 
   JS_ClearPendingException(mCx);
 
   JSObject* global = GetGlobalObject();
 
   JSScript* script =
       JS_CompileUCScriptForPrincipals(mCx, global, GetPrincipal(),

--- a/js/src/config/system-headers
+++ b/js/src/config/system-headers
@@ -1031,9 +1031,12 @@ conic/conicconnectionevent.h
 conic/conicstatisticsevent.h
 #endif
 #if MOZ_NATIVE_LIBEVENT==1
 event.h
 #endif
 #ifdef MOZ_ENABLE_LIBPROXY
 proxy.h
 #endif
+#if MOZ_PLATFORM_MAEMO==6
+contentaction/contentaction.h
+#endif
 

--- a/js/src/xpconnect/tests/unit/test_import.js
+++ b/js/src/xpconnect/tests/unit/test_import.js
@@ -62,23 +62,22 @@ function run_test() {
   // try on a new object
   var scope2 = {};
   Components.utils.import("resource://gre/modules/XPCOMUtils.jsm", scope2);
   do_check_eq(typeof(scope2.XPCOMUtils), "object");
   do_check_eq(typeof(scope2.XPCOMUtils.generateNSGetFactory), "function");
   
   do_check_true(scope2.XPCOMUtils == scope.XPCOMUtils);
 
-  // try on a new object using a file URL
+  // try on a new object using the resolved URL
   var res = Components.classes["@mozilla.org/network/protocol;1?name=resource"]
                       .getService(Components.interfaces.nsIResProtocolHandler);
   var resURI = res.newURI("resource://gre/modules/XPCOMUtils.jsm", null, null);
   dump("resURI: " + resURI + "\n");
   var filePath = res.resolveURI(resURI);
-  do_check_eq(filePath.indexOf("file://"), 0);
   var scope3 = {};
   Components.utils.import(filePath, scope3);
   do_check_eq(typeof(scope3.XPCOMUtils), "object");
   do_check_eq(typeof(scope3.XPCOMUtils.generateNSGetFactory), "function");
   
   do_check_true(scope3.XPCOMUtils == scope.XPCOMUtils);
 
   // make sure we throw when the second arg is bogus

--- a/netwerk/protocol/http/HttpChannelChild.cpp
+++ b/netwerk/protocol/http/HttpChannelChild.cpp
@@ -44,33 +44,50 @@
 #include "mozilla/net/NeckoChild.h"
 #include "mozilla/net/HttpChannelChild.h"
 
 #include "nsStringStream.h"
 #include "nsHttpHandler.h"
 #include "nsMimeTypes.h"
 #include "nsNetUtil.h"
 
-class Callback
+namespace mozilla {
+namespace net {
+
+class ChildChannelEvent
 {
  public:
-  virtual bool Run() = 0;
+  virtual void Run() = 0;
 };
 
-namespace mozilla {
-namespace net {
+// Ensures any incoming IPDL msgs are queued during its lifetime, and flushes
+// the queue when it goes out of scope.
+class AutoEventEnqueuer 
+{
+public:
+  AutoEventEnqueuer(HttpChannelChild* channel) : mChannel(channel) 
+  {
+    mChannel->BeginEventQueueing();
+  }
+  ~AutoEventEnqueuer() 
+  { 
+    mChannel->FlushEventQueue(); 
+  }
+private:
+    HttpChannelChild *mChannel;
+};
 
 // C++ file contents
 HttpChannelChild::HttpChannelChild()
   : mIsFromCache(PR_FALSE)
   , mCacheEntryAvailable(PR_FALSE)
   , mCacheExpirationTime(nsICache::NO_EXPIRATION_TIME)
   , mState(HCC_NEW)
   , mIPCOpen(false)
-  , mShouldBuffer(true)
+  , mQueuePhase(PHASE_UNQUEUED)
 {
   LOG(("Creating HttpChannelChild @%x\n", this));
 }
 
 HttpChannelChild::~HttpChannelChild()
 {
   LOG(("Destroying HttpChannelChild @%x\n", this));
 }
@@ -113,96 +130,166 @@ HttpChannelChild::AddIPDLReference()
 void
 HttpChannelChild::ReleaseIPDLReference()
 {
   NS_ABORT_IF_FALSE(mIPCOpen, "Attempt to release nonexistent IPDL reference");
   mIPCOpen = false;
   Release();
 }
 
+void
+HttpChannelChild::FlushEventQueue()
+{
+  NS_ABORT_IF_FALSE(mQueuePhase != PHASE_UNQUEUED,
+                    "Queue flushing should not occur if PHASE_UNQUEUED");
+  
+  // Queue already being flushed.
+  if (mQueuePhase != PHASE_QUEUEING)
+    return;
+  
+  if (mEventQueue.Length() > 0) {
+    // It is possible for new callbacks to be enqueued as we are
+    // flushing the queue, so the queue must not be cleared until
+    // all callbacks have run.
+    mQueuePhase = PHASE_FLUSHING;
+    
+    nsCOMPtr<nsIHttpChannel> kungFuDeathGrip(this);
+    for (PRUint32 i = 0; i < mEventQueue.Length(); i++) {
+      mEventQueue[i]->Run();
+    }
+    mEventQueue.Clear();
+  }
+
+  mQueuePhase = PHASE_UNQUEUED;
+}
+
+class StartRequestEvent : public ChildChannelEvent
+{
+ public:
+  StartRequestEvent(HttpChannelChild* child,
+                    const nsHttpResponseHead& responseHead,
+                    const PRBool& useResponseHead,
+                    const PRBool& isFromCache,
+                    const PRBool& cacheEntryAvailable,
+                    const PRUint32& cacheExpirationTime,
+                    const nsCString& cachedCharset)
+  : mChild(child)
+  , mResponseHead(responseHead)
+  , mUseResponseHead(useResponseHead)
+  , mIsFromCache(isFromCache)
+  , mCacheEntryAvailable(cacheEntryAvailable)
+  , mCacheExpirationTime(cacheExpirationTime)
+  , mCachedCharset(cachedCharset)
+  {}
+
+  void Run() 
+  { 
+    mChild->OnStartRequest(mResponseHead, mUseResponseHead, mIsFromCache, 
+                           mCacheEntryAvailable, mCacheExpirationTime, 
+                           mCachedCharset);
+  }
+ private:
+  HttpChannelChild* mChild;
+  nsHttpResponseHead mResponseHead;
+  PRBool mUseResponseHead;
+  PRBool mIsFromCache;
+  PRBool mCacheEntryAvailable;
+  PRUint32 mCacheExpirationTime;
+  nsCString mCachedCharset;
+};
+
 bool 
 HttpChannelChild::RecvOnStartRequest(const nsHttpResponseHead& responseHead,
                                      const PRBool& useResponseHead,
                                      const PRBool& isFromCache,
                                      const PRBool& cacheEntryAvailable,
                                      const PRUint32& cacheExpirationTime,
                                      const nsCString& cachedCharset)
 {
+  if (ShouldEnqueue()) {
+    EnqueueEvent(new StartRequestEvent(this, responseHead, useResponseHead,
+                                       isFromCache, cacheEntryAvailable,
+                                       cacheExpirationTime, cachedCharset));
+  } else {
+    OnStartRequest(responseHead, useResponseHead, isFromCache,
+                   cacheEntryAvailable, cacheExpirationTime, cachedCharset);
+  }
+  return true;
+}
+
+void 
+HttpChannelChild::OnStartRequest(const nsHttpResponseHead& responseHead,
+                                 const PRBool& useResponseHead,
+                                 const PRBool& isFromCache,
+                                 const PRBool& cacheEntryAvailable,
+                                 const PRUint32& cacheExpirationTime,
+                                 const nsCString& cachedCharset)
+{
   LOG(("HttpChannelChild::RecvOnStartRequest [this=%x]\n", this));
 
   mState = HCC_ONSTART;
 
   if (useResponseHead)
     mResponseHead = new nsHttpResponseHead(responseHead);
   else
     mResponseHead = nsnull;
  
   mIsFromCache = isFromCache;
   mCacheEntryAvailable = cacheEntryAvailable;
   mCacheExpirationTime = cacheExpirationTime;
   mCachedCharset = cachedCharset;
 
+  AutoEventEnqueuer ensureSerialDispatch(this);
+
   nsresult rv = mListener->OnStartRequest(this, mListenerContext);
-  if (NS_FAILED(rv)) {
+  if (NS_SUCCEEDED(rv)) {
+    if (mResponseHead)
+      SetCookie(mResponseHead->PeekHeader(nsHttp::Set_Cookie));
+  } else {
     // TODO: Cancel request: (bug 536317)
     //  - Send Cancel msg to parent 
     //  - drop any in flight OnDataAvail msgs we receive
     //  - make sure we do call OnStopRequest eventually
-    return true;  
   }
-
-  if (mResponseHead)
-    SetCookie(mResponseHead->PeekHeader(nsHttp::Set_Cookie));
-
-  bool ret = true;
-  nsCOMPtr<nsIHttpChannel> kungFuDeathGrip(this);
-  for (PRUint32 i = 0; i < mBufferedCallbacks.Length(); i++) {
-    ret = mBufferedCallbacks[i]->Run();
-    if (!ret)
-      break;
-  }
-  mBufferedCallbacks.Clear();
-  mShouldBuffer = false;
-  return ret;
 }
 
-class DataAvailableEvent : public Callback
+class DataAvailableEvent : public ChildChannelEvent
 {
  public:
   DataAvailableEvent(HttpChannelChild* child,
                      const nsCString& data,
                      const PRUint32& offset,
                      const PRUint32& count)
   : mChild(child)
   , mData(data)
   , mOffset(offset)
   , mCount(count) {}
 
-  bool Run()
-  {
-    return mChild->OnDataAvailable(mData, mOffset, mCount);
-  }
-
+  void Run() { mChild->OnDataAvailable(mData, mOffset, mCount); }
  private:
   HttpChannelChild* mChild;
   nsCString mData;
   PRUint32 mOffset;
   PRUint32 mCount;
 };
 
 bool 
 HttpChannelChild::RecvOnDataAvailable(const nsCString& data,
                                       const PRUint32& offset,
                                       const PRUint32& count)
 {
-  DataAvailableEvent* event = new DataAvailableEvent(this, data, offset, count);
-  return BufferOrDispatch(event);
+  if (ShouldEnqueue()) {
+    EnqueueEvent(new DataAvailableEvent(this, data, offset, count));
+  } else {
+    OnDataAvailable(data, offset, count);
+  }
+  return true;
 }
 
-bool 
+void 
 HttpChannelChild::OnDataAvailable(const nsCString& data,
                                   const PRUint32& offset,
                                   const PRUint32& count)
 {
   LOG(("HttpChannelChild::RecvOnDataAvailable [this=%x]\n", this));
 
   mState = HCC_ONDATA;
 
@@ -213,188 +300,182 @@ HttpChannelChild::OnDataAvailable(const 
   // rest.
   nsCOMPtr<nsIInputStream> stringStream;
   nsresult rv = NS_NewByteInputStream(getter_AddRefs(stringStream),
                                       data.get(),
                                       count,
                                       NS_ASSIGNMENT_DEPEND);
   if (NS_FAILED(rv)) {
     // TODO:  what to do here?  Cancel request?  Very unlikely to fail.
-    return false;  
+    return;
   }
+
+  AutoEventEnqueuer ensureSerialDispatch(this);
+
   rv = mListener->OnDataAvailable(this, mListenerContext,
                                   stringStream, offset, count);
   stringStream->Close();
   if (NS_FAILED(rv)) {
     // TODO: Cancel request: see OnStartRequest. Bug 536317
   }
-  return true;
 }
 
-class StopRequestEvent : public Callback
+class StopRequestEvent : public ChildChannelEvent
 {
  public:
   StopRequestEvent(HttpChannelChild* child,
                    const nsresult& statusCode)
   : mChild(child)
   , mStatusCode(statusCode) {}
 
-  bool Run()
-  {
-    return mChild->OnStopRequest(mStatusCode);
-  }
-
+  void Run() { mChild->OnStopRequest(mStatusCode); }
  private:
   HttpChannelChild* mChild;
   nsresult mStatusCode;
 };
 
 bool 
 HttpChannelChild::RecvOnStopRequest(const nsresult& statusCode)
 {
-  StopRequestEvent* event = new StopRequestEvent(this, statusCode);
-  return BufferOrDispatch(event);
+  if (ShouldEnqueue()) {
+    EnqueueEvent(new StopRequestEvent(this, statusCode));
+  } else {
+    OnStopRequest(statusCode);
+  }
+  return true;
 }
 
-bool 
+void 
 HttpChannelChild::OnStopRequest(const nsresult& statusCode)
 {
   LOG(("HttpChannelChild::RecvOnStopRequest [this=%x status=%u]\n", 
            this, statusCode));
 
   mState = HCC_ONSTOP;
 
   mIsPending = PR_FALSE;
   mStatus = statusCode;
-  mListener->OnStopRequest(this, mListenerContext, statusCode);
-  mListener = 0;
-  mListenerContext = 0;
-  mCacheEntryAvailable = PR_FALSE;
 
-  if (mLoadGroup)
-    mLoadGroup->RemoveRequest(this, nsnull, statusCode);
+  { // We must flush the queue before we Send__delete__, 
+    // so make sure this goes out of scope before then.
+    AutoEventEnqueuer ensureSerialDispatch(this);
+    
+    mListener->OnStopRequest(this, mListenerContext, statusCode);
+    mListener = 0;
+    mListenerContext = 0;
+    mCacheEntryAvailable = PR_FALSE;
+
+    if (mLoadGroup)
+      mLoadGroup->RemoveRequest(this, nsnull, statusCode);
+  }
 
   // This calls NeckoChild::DeallocPHttpChannel(), which deletes |this| if IPDL
   // holds the last reference.  Don't rely on |this| existing after here.
   PHttpChannelChild::Send__delete__(this);
-  return true;
 }
 
-class ProgressEvent : public Callback
+class ProgressEvent : public ChildChannelEvent
 {
  public:
   ProgressEvent(HttpChannelChild* child,
                 const PRUint64& progress,
                 const PRUint64& progressMax)
   : mChild(child)
   , mProgress(progress)
   , mProgressMax(progressMax) {}
 
-  bool Run()
-  {
-    return mChild->OnProgress(mProgress, mProgressMax);
-  }
-
+  void Run() { mChild->OnProgress(mProgress, mProgressMax); }
  private:
   HttpChannelChild* mChild;
   PRUint64 mProgress, mProgressMax;
 };
 
 bool
 HttpChannelChild::RecvOnProgress(const PRUint64& progress,
                                  const PRUint64& progressMax)
 {
-  ProgressEvent* event = new ProgressEvent(this, progress, progressMax);
-  return BufferOrDispatch(event);
+  if (ShouldEnqueue())  {
+    EnqueueEvent(new ProgressEvent(this, progress, progressMax));
+  } else {
+    OnProgress(progress, progressMax);
+  }
+  return true;
 }
 
-bool
+void
 HttpChannelChild::OnProgress(const PRUint64& progress,
                              const PRUint64& progressMax)
 {
   LOG(("HttpChannelChild::RecvOnProgress [this=%p progress=%llu/%llu]\n",
        this, progress, progressMax));
 
   // cache the progress sink so we don't have to query for it each time.
   if (!mProgressSink)
     GetCallback(mProgressSink);
 
+  AutoEventEnqueuer ensureSerialDispatch(this);
+
   // block socket status event after Cancel or OnStopRequest has been called.
   if (mProgressSink && NS_SUCCEEDED(mStatus) && mIsPending && 
       !(mLoadFlags & LOAD_BACKGROUND)) 
   {
      if (progress > 0) {
       NS_ASSERTION(progress <= progressMax, "unexpected progress values");
       mProgressSink->OnProgress(this, nsnull, progress, progressMax);
     }
   }
-
-  return true;
 }
 
-class StatusEvent : public Callback
+class StatusEvent : public ChildChannelEvent
 {
  public:
   StatusEvent(HttpChannelChild* child,
               const nsresult& status,
               const nsString& statusArg)
   : mChild(child)
   , mStatus(status)
   , mStatusArg(statusArg) {}
 
-  bool Run()
-  {
-    return mChild->OnStatus(mStatus, mStatusArg);
-  }
-
+  void Run() { mChild->OnStatus(mStatus, mStatusArg); }
  private:
   HttpChannelChild* mChild;
   nsresult mStatus;
   nsString mStatusArg;
 };
 
 bool
 HttpChannelChild::RecvOnStatus(const nsresult& status,
                                const nsString& statusArg)
 {
-  StatusEvent* event = new StatusEvent(this, status, statusArg);
-  return BufferOrDispatch(event);
+  if (ShouldEnqueue()) {
+    EnqueueEvent(new StatusEvent(this, status, statusArg));
+  } else {
+    OnStatus(status, statusArg);
+  }
+  return true;
 }
 
-bool
+void
 HttpChannelChild::OnStatus(const nsresult& status,
                            const nsString& statusArg)
 {
   LOG(("HttpChannelChild::RecvOnStatus [this=%p status=%x]\n", this, status));
 
   // cache the progress sink so we don't have to query for it each time.
   if (!mProgressSink)
     GetCallback(mProgressSink);
 
+  AutoEventEnqueuer ensureSerialDispatch(this);
+  
   // block socket status event after Cancel or OnStopRequest has been called.
   if (mProgressSink && NS_SUCCEEDED(mStatus) && mIsPending && 
       !(mLoadFlags & LOAD_BACKGROUND)) 
   {
     mProgressSink->OnStatus(this, nsnull, status, statusArg.get());
   }
-
-  return true;
-}
-
-bool
-HttpChannelChild::BufferOrDispatch(Callback* callback)
-{
-  if (mShouldBuffer) {
-      mBufferedCallbacks.AppendElement(callback);
-      return true;
-  }
-
-  bool result = callback->Run();
-  delete callback;
-  return result;
 }
 
 //-----------------------------------------------------------------------------
 // HttpChannelChild::nsIRequest
 //-----------------------------------------------------------------------------
 
 NS_IMETHODIMP
 HttpChannelChild::Cancel(nsresult status)

--- a/netwerk/protocol/http/HttpChannelChild.h
+++ b/netwerk/protocol/http/HttpChannelChild.h
@@ -53,24 +53,22 @@
 #include "nsICacheInfoChannel.h"
 #include "nsIApplicationCache.h"
 #include "nsIApplicationCacheChannel.h"
 #include "nsIEncodedChannel.h"
 #include "nsIUploadChannel2.h"
 #include "nsIResumableChannel.h"
 #include "nsIProxiedChannel.h"
 #include "nsITraceableChannel.h"
-#include "mozilla/Mutex.h"
-
-class nsIRunnable;
-class Callback;
 
 namespace mozilla {
 namespace net {
 
+class ChildChannelEvent;
+
 // TODO: replace with IPDL states: bug 536319
 enum HttpChannelChildState {
   HCC_NEW,
   HCC_OPENED,
   HCC_ONSTART,
   HCC_ONDATA,
   HCC_ONSTOP
 };
@@ -143,35 +141,76 @@ private:
   PRPackedBool mCacheEntryAvailable;
   PRUint32     mCacheExpirationTime;
   nsCString    mCachedCharset;
 
   // FIXME: replace with IPDL states (bug 536319) 
   enum HttpChannelChildState mState;
   bool mIPCOpen;
 
-  // Workaround for Necko re-entrancy dangers. We buffer all messages
-  // received until OnStartRequest completes.
-  nsTArray<nsAutoPtr<Callback> > mBufferedCallbacks;
-  bool mShouldBuffer;
+  // Workaround for Necko re-entrancy dangers. We buffer IPDL messages in a
+  // queue if still dispatching previous one(s) to listeners/observers.
+  // Otherwise synchronous XMLHttpRequests and/or other code that spins the
+  // event loop (ex: IPDL rpc) could cause listener->OnDataAvailable (for
+  // instance) to be called before mListener->OnStartRequest has completed.
+  void BeginEventQueueing();
+  void FlushEventQueue();
+  void EnqueueEvent(ChildChannelEvent* callback);
+  bool ShouldEnqueue();
 
-  bool BufferOrDispatch(Callback* callback);
+  nsTArray<nsAutoPtr<ChildChannelEvent> > mEventQueue;
+  enum {
+    PHASE_UNQUEUED,
+    PHASE_QUEUEING,
+    PHASE_FLUSHING
+  } mQueuePhase;
 
-  // This class does not actually implement the stream listener interface.
-  // These functions actually perform the actions associated with the
-  // corresponding IPDL receivers above.
-  bool OnDataAvailable(const nsCString& data, 
+  void OnStartRequest(const nsHttpResponseHead& responseHead,
+                          const PRBool& useResponseHead,
+                          const PRBool& isFromCache,
+                          const PRBool& cacheEntryAvailable,
+                          const PRUint32& cacheExpirationTime,
+                          const nsCString& cachedCharset);
+  void OnDataAvailable(const nsCString& data, 
                        const PRUint32& offset,
                        const PRUint32& count);
-  bool OnStopRequest(const nsresult& statusCode);
-  bool OnProgress(const PRUint64& progress, const PRUint64& progressMax);
-  bool OnStatus(const nsresult& status, const nsString& statusArg);
+  void OnStopRequest(const nsresult& statusCode);
+  void OnProgress(const PRUint64& progress, const PRUint64& progressMax);
+  void OnStatus(const nsresult& status, const nsString& statusArg);
 
+  friend class AutoEventEnqueuer;
+  friend class StartRequestEvent;
   friend class StopRequestEvent;
   friend class DataAvailableEvent;
   friend class ProgressEvent;
   friend class StatusEvent;
 };
 
+//-----------------------------------------------------------------------------
+// inline functions
+//-----------------------------------------------------------------------------
+
+inline void
+HttpChannelChild::BeginEventQueueing()
+{
+  if (mQueuePhase == PHASE_FLUSHING)
+    return;
+  // Store incoming IPDL messages for later.
+  mQueuePhase = PHASE_QUEUEING;
+}
+
+inline bool
+HttpChannelChild::ShouldEnqueue()
+{
+  return mQueuePhase != PHASE_UNQUEUED;
+}
+
+inline void
+HttpChannelChild::EnqueueEvent(ChildChannelEvent* callback)
+{
+  mEventQueue.AppendElement(callback);
+}
+
+
 } // namespace net
 } // namespace mozilla
 
 #endif // mozilla_net_HttpChannelChild_h

--- a/netwerk/protocol/http/nsHttpChannel.cpp
+++ b/netwerk/protocol/http/nsHttpChannel.cpp
@@ -3244,16 +3244,19 @@ nsHttpChannel::AsyncOpen(nsIStreamListen
     LOG(("nsHttpChannel::AsyncOpen [this=%p]\n", this));
 
     NS_ENSURE_ARG_POINTER(listener);
     NS_ENSURE_TRUE(!mIsPending, NS_ERROR_IN_PROGRESS);
     NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_ALREADY_OPENED);
 
     nsresult rv;
 
+    if (mCanceled)
+        return mStatus;
+
     rv = NS_CheckPortSafety(mURI);
     if (NS_FAILED(rv))
         return rv;
 
     if (!(mConnectionInfo && mConnectionInfo->UsingHttpProxy())) {
         // Start a DNS lookup very early in case the real open is queued the DNS can 
         // happen in parallel. Do not do so in the presence of an HTTP proxy as 
         // all lookups other than for the proxy itself are done by the proxy.

--- a/netwerk/protocol/res/nsResProtocolHandler.cpp
+++ b/netwerk/protocol/res/nsResProtocolHandler.cpp
@@ -90,35 +90,30 @@ nsresult
 nsResURL::EnsureFile()
 {
     nsresult rv;
 
     NS_ENSURE_TRUE(gResHandler, NS_ERROR_NOT_AVAILABLE);
 
     nsCAutoString spec;
     rv = gResHandler->ResolveURI(this, spec);
-    if (NS_FAILED(rv)) return rv;
+    if (NS_FAILED(rv))
+        return rv;
 
-#if defined(MOZ_CHROME_FILE_FORMAT_JAR) || defined(MOZ_OMNIJAR)
-    nsCAutoString host;
-    rv = GetHost(host);
+    nsCAutoString scheme;
+    rv = net_ExtractURLScheme(spec, nsnull, nsnull, &scheme);
     if (NS_FAILED(rv))
         return rv;
-    // Deal with the fact resource://gre-resouces/ urls do not resolve to files
-    if (host.Equals(kGRE_RESOURCES))
+
+    // Bug 585869:
+    // In most cases, the scheme is jar if it's not file.
+    // Regardless, net_GetFileFromURLSpec should be avoided
+    // when the scheme isn't file.
+    if (!scheme.Equals(NS_LITERAL_CSTRING("file")))
         return NS_ERROR_NO_INTERFACE;
-#endif
-#ifdef MOZ_OMNIJAR
-    if (mozilla::OmnijarPath()) {
-        if (host.Equals(kGRE))
-            return NS_ERROR_NO_INTERFACE;
-        if (host.IsEmpty())
-            return NS_ERROR_NO_INTERFACE;
-    }
-#endif
 
     rv = net_GetFileFromURLSpec(spec, getter_AddRefs(mFile));
 #ifdef DEBUG_bsmedberg
     if (NS_SUCCEEDED(rv)) {
         PRBool exists = PR_TRUE;
         mFile->Exists(&exists);
         if (!exists) {
             printf("resource %s doesn't exist!\n", spec.get());

--- a/netwerk/test/unit/test_progress.js
+++ b/netwerk/test/unit/test_progress.js
@@ -5,48 +5,103 @@ var httpserver = new nsHttpServer();
 var testpath = "/simple";
 var httpbody = "0123456789";
 
 var last = 0, max = 0;
 
 const STATUS_RECEIVING_FROM = 0x804b0006;
 const LOOPS = 50000;
 
+const TYPE_ONSTATUS = 1;
+const TYPE_ONPROGRESS = 2;
+const TYPE_ONSTARTREQUEST = 3;
+const TYPE_ONDATAAVAILABLE = 4;
+const TYPE_ONSTOPREQUEST = 5;
+
 var progressCallback = {
+  _listener: null,
+  _got_onstartrequest: false,
+  _got_onstatus_after_onstartrequest: false,
+  _last_callback_handled: null,
+
   QueryInterface: function (iid) {
-    if (iid.equals(Ci.nsISupports) || iid.equals(Ci.nsIProgressEventSink))
+    if (iid.equals(Ci.nsISupports) ||
+	iid.equals(Ci.nsIProgressEventSink) ||
+        iid.equals(Ci.nsIStreamListener) ||
+        iid.equals(Ci.nsIRequestObserver))
       return this;
     throw Cr.NS_ERROR_NO_INTERFACE;
   },
 
   getInterface: function (iid) {
-    if (iid.equals(Ci.nsIProgressEventSink))
+    if (iid.equals(Ci.nsIProgressEventSink) ||
+        iid.equals(Ci.nsIStreamListener) ||
+        iid.equals(Ci.nsIRequestObserver))
       return this;
     throw Cr.NS_ERROR_NO_INTERFACE;
   },
 
+  onStartRequest: function(request, context) {
+    do_check_eq(this._last_callback_handled, TYPE_ONSTATUS);
+    this._got_onstartrequest = true;
+    this._last_callback_handled = TYPE_ONSTARTREQUEST;
+
+    this._listener = new ChannelListener(checkRequest, request);
+    this._listener.onStartRequest(request, context);
+  },
+
+  onDataAvailable: function(request, context, data, offset, count) {
+    do_check_eq(this._last_callback_handled, TYPE_ONPROGRESS);
+    this._last_callback_handled = TYPE_ONDATAAVAILABLE;
+
+    this._listener.onDataAvailable(request, context, data, offset, count);
+  },
+
+  onStopRequest: function(request, context, status) {
+    do_check_eq(this._last_callback_handled, TYPE_ONDATAAVAILABLE);
+    do_check_true(this._got_onstatus_after_onstartrequest);
+    this._last_callback_handled = TYPE_ONSTOPREQUEST;
+
+    this._listener.onStopRequest(request, context, status);
+    delete this._listener;
+  },
+
   onProgress: function (request, context, progress, progressMax) {
+    do_check_eq(this._last_callback_handled, TYPE_ONSTATUS);
+    this._last_callback_handled = TYPE_ONPROGRESS;
+
     do_check_eq(mStatus, STATUS_RECEIVING_FROM);
     last = progress;
     max = progressMax;
   },
 
   onStatus: function (request, context, status, statusArg) {
+    if (!this._got_onstartrequest) {
+      // Ensure that all messages before onStartRequest are onStatus
+      if (this._last_callback_handled)
+        do_check_eq(this._last_callback_handled, TYPE_ONSTATUS);
+    } else if (this._last_callback_handled == TYPE_ONSTARTREQUEST) {
+      this._got_onstatus_after_onstartrequest = true;
+    } else {
+      do_check_eq(this._last_callback_handled, TYPE_ONDATAAVAILABLE);
+    }
+    this._last_callback_handled = TYPE_ONSTATUS;
+
     do_check_eq(statusArg, "localhost");
     mStatus = status;
   },
 
   mStatus: 0,
 };
 
 function run_test() {
   httpserver.registerPathHandler(testpath, serverHandler);
   httpserver.start(4444);
   var channel = setupChannel(testpath);
-  channel.asyncOpen(new ChannelListener(checkRequest, channel), null);
+  channel.asyncOpen(progressCallback, null);
   do_test_pending();
 }
 
 function setupChannel(path) {
   var ios = Cc["@mozilla.org/network/io-service;1"].
                        getService(Ci.nsIIOService);
   var chan = ios.newChannel("http://localhost:4444" + path, "", null);
   chan.QueryInterface(Ci.nsIHttpChannel);

--- a/netwerk/test/unit/test_xmlhttprequest.js
+++ b/netwerk/test/unit/test_xmlhttprequest.js
@@ -1,36 +1,53 @@
 
 do_load_httpd_js();
 
 var httpserver = new nsHttpServer();
 var testpath = "/simple";
 var httpbody = "<?xml version='1.0' ?><root>0123456789</root>";
 
+function createXHR(async)
+{
+  var xhr = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"]
+            .createInstance(Ci.nsIXMLHttpRequest);
+  xhr.open("GET", "http://localhost:4444" + testpath, async);
+  return xhr;
+}
+
+function checkResults(xhr)
+{
+  if (xhr.readyState != 4)
+    return false;
+
+  do_check_eq(xhr.status, 200);
+  do_check_eq(xhr.responseText, httpbody);
+
+  var root_node = xhr.responseXML.getElementsByTagName('root').item(0);
+  do_check_eq(root_node.firstChild.data, "0123456789");
+  return true;
+}
+
 function run_test()
 {
   httpserver.registerPathHandler(testpath, serverHandler);
   httpserver.start(4444);
 
-  var xhr = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"]
-              .createInstance(Ci.nsIXMLHttpRequest);
-  xhr.open("GET", "http://localhost:4444" + testpath, true);
-  xhr.onreadystatechange = function(event) {
-    if (xhr.readyState == 4) {
-      do_check_eq(xhr.status, 200);
-      do_check_eq(xhr.responseText, httpbody);
+  // Test sync XHR sending
+  var sync = createXHR(false);
+  sync.send(null);
+  checkResults(sync);
 
-      var root_node = xhr.responseXML.getElementsByTagName('root').item(0);
-      do_check_eq(root_node.firstChild.data, "0123456789");
-
+  // Test async XHR sending
+  let async = createXHR(true);
+  async.onreadystatechange = function(event) {
+    if (checkResults(async))
       httpserver.stop(do_test_finished);
-    }
-  }
-  xhr.send(null);
-
+  };
+  async.send(null);
   do_test_pending();
 }
 
 function serverHandler(metadata, response)
 {
   response.setHeader("Content-Type", "text/xml", false);
   response.bodyOutputStream.write(httpbody, httpbody.length);
 }

--- a/netwerk/test/unit_ipc/test_xmlhttprequest_wrap.js
+++ b/netwerk/test/unit_ipc/test_xmlhttprequest_wrap.js
@@ -1,4 +1,3 @@
 function run_test() {
-  _dump('FIXME/bug 564351: temporarily disabled for perma-crash on e10s tinderbox');
-  //run_test_in_child("../unit/test_xmlhttprequest.js");
+  run_test_in_child("../unit/test_xmlhttprequest.js");
 }

--- a/toolkit/components/places/public/nsIPlacesImportExportService.idl
+++ b/toolkit/components/places/public/nsIPlacesImportExportService.idl
@@ -34,23 +34,24 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsISupports.idl"
 
 interface nsILocalFile;
+interface nsIURI;
 
 /**
  * The PlacesImportExport interface provides methods for importing
  * and exporting Places data.
  */
 
-[scriptable, uuid(21c00314-fa63-11db-8314-0800200c9a66)]
+[scriptable, uuid(47a4a09e-c708-4e68-b2f2-664d982ce026)]
 interface nsIPlacesImportExportService: nsISupports
 {
   /**
    * Loads the given bookmarks.html file and replaces it with the current
    * bookmarks hierarchy (if aIsInitialImport is true) or appends it
    * (if aIsInitialImport is false).
    *
    * Three nsIObserverService notifications are fired as a result of the
@@ -60,16 +61,21 @@ interface nsIPlacesImportExportService: 
    * fired right after a failure occurs when importing the bookmarks.
    * Observers will be passed through their data parameters either "html"
    * if aIsInitialImport is false or "html-initial" if aIsInitialImport is
    * true.  The observer subject will be null.
    */
   void importHTMLFromFile(in nsILocalFile aFile, in boolean aIsInitialImport);
 
   /**
+   * Same thing as importHTMLFromFile, but takes a URI instead
+   */
+  void importHTMLFromURI(in nsIURI aURI, in boolean aIsInitialImport);
+
+  /**
    * Loads the given bookmarks.html file and puts it in the given folder
    *
    * Three nsIObserverService notifications are fired as a result of the
    * import.  "bookmarks-restore-begin" is fired just before the import is
    * started.  "bookmarks-restore-success" is fired right after the
    * bookmarks are successfully imported.  "bookmarks-restore-failed" is
    * fired right after a failure occurs when importing the bookmarks.
    * Observers will be passed through their data parameters either "html"

--- a/toolkit/components/places/src/nsPlacesImportExportService.cpp
+++ b/toolkit/components/places/src/nsPlacesImportExportService.cpp
@@ -2177,16 +2177,43 @@ nsPlacesImportExportService::ImportHTMLF
                           aIsInitialImport);
   }
 
   return rv;
 }
 
 
 NS_IMETHODIMP
+nsPlacesImportExportService::ImportHTMLFromURI(nsIURI* aURI,
+                                               PRBool aIsInitialImport)
+{
+  NotifyImportObservers(RESTORE_BEGIN_NSIOBSERVER_TOPIC, -1, aIsInitialImport);
+
+  // this version is exposed on the interface and disallows changing of roots
+  nsresult rv = ImportHTMLFromURIInternal(aURI,
+                                          PR_FALSE,
+                                          0,
+                                          aIsInitialImport);
+
+  if (NS_FAILED(rv)) {
+    NotifyImportObservers(RESTORE_FAILED_NSIOBSERVER_TOPIC,
+                          -1,
+                          aIsInitialImport);
+  }
+  else {
+    NotifyImportObservers(RESTORE_SUCCESS_NSIOBSERVER_TOPIC,
+                          -1,
+                          aIsInitialImport);
+  }
+
+  return rv;
+}
+
+
+NS_IMETHODIMP
 nsPlacesImportExportService::ImportHTMLFromFileToFolder(nsILocalFile* aFile,
                                                         PRInt64 aFolderId,
                                                         PRBool aIsInitialImport)
 {
   NotifyImportObservers(RESTORE_BEGIN_NSIOBSERVER_TOPIC,
                         aFolderId,
                         aIsInitialImport);
 
@@ -2212,18 +2239,17 @@ nsPlacesImportExportService::ImportHTMLF
 
 
 nsresult
 nsPlacesImportExportService::ImportHTMLFromFileInternal(nsILocalFile* aFile,
                                                         PRBool aAllowRootChanges,
                                                         PRInt64 aFolder,
                                                         PRBool aIsImportDefaults)
 {
-  nsresult rv = EnsureServiceState();
-  NS_ENSURE_SUCCESS(rv, rv);
+  nsresult rv;
 
   nsCOMPtr<nsIFile> file = do_QueryInterface(aFile);
   NS_ENSURE_STATE(file);
 
 #ifdef DEBUG_IMPORT
   nsAutoString path;
   file->GetPath(path);
   printf("\nImporting %s\n", NS_ConvertUTF16toUTF8(path).get());
@@ -2232,39 +2258,54 @@ nsPlacesImportExportService::ImportHTMLF
   // Confirm file to be imported exists.
   PRBool exists;
   rv = file->Exists(&exists);
   NS_ENSURE_SUCCESS(rv, rv);
   if (!exists) {
     return NS_ERROR_INVALID_ARG;
   }
 
+  nsCOMPtr<nsIIOService> ioservice = do_GetIOService(&rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIURI> fileURI;
+  rv = ioservice->NewFileURI(file, getter_AddRefs(fileURI));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return ImportHTMLFromURIInternal(fileURI, aAllowRootChanges, aFolder, aIsImportDefaults);
+}
+
+nsresult
+nsPlacesImportExportService::ImportHTMLFromURIInternal(nsIURI* aURI,
+                                                       PRBool aAllowRootChanges,
+                                                       PRInt64 aFolder,
+                                                       PRBool aIsImportDefaults)
+{
+  nsresult rv = EnsureServiceState();
+  NS_ENSURE_SUCCESS(rv, rv);
+
   nsCOMPtr<nsIParser> parser = do_CreateInstance(kParserCID);
   NS_ENSURE_TRUE(parser, NS_ERROR_OUT_OF_MEMORY);
 
   nsCOMPtr<BookmarkContentSink> sink = new BookmarkContentSink();
   NS_ENSURE_TRUE(sink, NS_ERROR_OUT_OF_MEMORY);
   rv = sink->Init(aAllowRootChanges, aFolder, aIsImportDefaults);
   NS_ENSURE_SUCCESS(rv, rv);
   parser->SetContentSink(sink);
 
   // Set the content type on the channel, otherwise the default "unknown" type
   // will confuse the parser.
   nsCOMPtr<nsIIOService> ioservice = do_GetIOService(&rv);
   NS_ENSURE_SUCCESS(rv, rv);
-  nsCOMPtr<nsIURI> fileURI;
-  rv = ioservice->NewFileURI(file, getter_AddRefs(fileURI));
-  NS_ENSURE_SUCCESS(rv, rv);
-  rv = ioservice->NewChannelFromURI(fileURI, getter_AddRefs(mImportChannel));
+  rv = ioservice->NewChannelFromURI(aURI, getter_AddRefs(mImportChannel));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = mImportChannel->SetContentType(NS_LITERAL_CSTRING("text/html"));
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Init parser.
-  rv = parser->Parse(fileURI, nsnull);
+  rv = parser->Parse(aURI, nsnull);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Run the import in batch mode, so it will be executed in a transaction
   // and will be faster.
   mIsImportDefaults = aIsImportDefaults;
   mBookmarksService->RunInBatchMode(this, parser);
   mImportChannel = nsnull;
 

--- a/toolkit/components/places/src/nsPlacesImportExportService.h
+++ b/toolkit/components/places/src/nsPlacesImportExportService.h
@@ -45,16 +45,18 @@ class nsPlacesImportExportService : publ
     nsCOMPtr<nsILivemarkService> mLivemarkService;
     nsCOMPtr<nsIMicrosummaryService> mMicrosummaryService;
 
     nsCOMPtr<nsIChannel> mImportChannel;
     PRBool mIsImportDefaults;
 
     nsresult ImportHTMLFromFileInternal(nsILocalFile* aFile, PRBool aAllowRootChanges,
                                        PRInt64 aFolder, PRBool aIsImportDefaults);
+    nsresult ImportHTMLFromURIInternal(nsIURI* aURI, PRBool aAllowRootChanges,
+                                       PRInt64 aFolder, PRBool aIsImportDefaults);
     nsresult WriteContainer(nsINavHistoryResultNode* aFolder, const nsACString& aIndent, nsIOutputStream* aOutput);
     nsresult WriteContainerHeader(nsINavHistoryResultNode* aFolder, const nsACString& aIndent, nsIOutputStream* aOutput);
     nsresult WriteTitle(nsINavHistoryResultNode* aItem, nsIOutputStream* aOutput);
     nsresult WriteItem(nsINavHistoryResultNode* aItem, const nsACString& aIndent, nsIOutputStream* aOutput);
     nsresult WriteLivemark(nsINavHistoryResultNode* aFolder, const nsACString& aIndent, nsIOutputStream* aOutput);
     nsresult WriteContainerContents(nsINavHistoryResultNode* aFolder, const nsACString& aIndent, nsIOutputStream* aOutput);
     nsresult WriteSeparator(nsINavHistoryResultNode* aItem, const nsACString& aIndent, nsIOutputStream* aOutput);
     nsresult WriteDescription(PRInt64 aId, PRInt32 aType, nsIOutputStream* aOutput);

--- a/toolkit/xre/MozMeegoAppService.h
+++ b/toolkit/xre/MozMeegoAppService.h
@@ -1,30 +1,42 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
 /* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
  * 1.1 (the "License"); you may not use this file except in compliance with
  * the License. You may obtain a copy of the License at
  * http://www.mozilla.org/MPL/
  *
  * Software distributed under the License is distributed on an "AS IS" basis,
  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  * for the specific language governing rights and limitations under the
  * License.
  *
- * The Original Code is mozilla.org code.
+ * The Original Code is Nokia.
  *
- * The Initial Developer of the Original Code is
- * Nokia Corporation.
+ * The Initial Developer of the Original Code is Nokia Corporation.
  * Portions created by the Initial Developer are Copyright (C) 2010
  * the Initial Developer. All Rights Reserved.
  *
- * Contributor(s): 
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef MOZMEEGOAPPSERVICE_H
 #define MOZMEEGOAPPSERVICE_H
 
 #include <MApplicationService>
 

--- a/toolkit/xre/nsAppRunner.cpp
+++ b/toolkit/xre/nsAppRunner.cpp
@@ -1109,20 +1109,16 @@ ScopedXPCOMStartup::~ScopedXPCOMStartup(
       appStartup->DestroyHiddenWindow();
 
     gDirServiceProvider->DoShutdown();
 
     WriteConsoleLog();
 
     NS_ShutdownXPCOM(mServiceManager);
     mServiceManager = nsnull;
-
-#ifdef MOZ_OMNIJAR
-    mozilla::SetOmnijar(nsnull);
-#endif
   }
 }
 
 // {95d89e3e-a169-41a3-8e56-719978e15b12}
 #define APPINFO_CID \
   { 0x95d89e3e, 0xa169, 0x41a3, { 0x8e, 0x56, 0x71, 0x99, 0x78, 0xe1, 0x5b, 0x12 } }
 
 // {0C4A446C-EE82-41f2-8D04-D366D2C7A7D4}
@@ -1170,26 +1166,16 @@ static const mozilla::Module kXREModule 
 NSMODULE_DEFN(Apprunner) = &kXREModule;
 
 nsresult
 ScopedXPCOMStartup::Initialize()
 {
   NS_ASSERTION(gDirServiceProvider, "Should not get here!");
 
   nsresult rv;
-#ifdef MOZ_OMNIJAR
-  nsCOMPtr<nsILocalFile> lf;
-  char *omnijarPath = getenv("OMNIJAR_PATH");
-  if (omnijarPath)
-    rv = NS_NewNativeLocalFile(nsDependentCString(omnijarPath), PR_TRUE, getter_AddRefs(lf));
-  else
-    rv = XRE_GetBinaryPath(gArgv[0], getter_AddRefs(lf));
-  if (NS_SUCCEEDED(rv))
-    mozilla::SetOmnijar(lf);
-#endif
 
 #ifndef MOZ_ENABLE_LIBXUL
 #ifndef _BUILD_STATIC_BIN
   XRE_AddStaticComponent(&kXREModule);
 #else
   for (const mozilla::Module *const *staticModules = kPStaticModules;
        *staticModules; ++staticModules)
       XRE_AddStaticComponent(*staticModules);
@@ -3772,26 +3758,16 @@ XRE_InitCommandLine(int aArgc, char* aAr
 {
   nsresult rv = NS_OK;
 
 #if defined(MOZ_IPC)
 
 #if defined(OS_WIN)
   CommandLine::Init(aArgc, aArgv);
 #else
-#ifdef MOZ_OMNIJAR
-  nsCOMPtr<nsILocalFile> lf;
-  char *omnijarPath = getenv("OMNIJAR_PATH");
-  if (omnijarPath)
-    rv = NS_NewNativeLocalFile(nsDependentCString(omnijarPath), PR_TRUE, getter_AddRefs(lf));
-  else
-    rv = XRE_GetBinaryPath(gArgv[0], getter_AddRefs(lf));
-  if (NS_SUCCEEDED(rv))
-    mozilla::SetOmnijar(lf);
-#endif
 
   // these leak on error, but that's OK: we'll just exit()
   char** canonArgs = new char*[aArgc];
 
   // get the canonical version of the binary's path
   nsCOMPtr<nsILocalFile> binFile;
   rv = XRE_GetBinaryPath(aArgv[0], getter_AddRefs(binFile));
   if (NS_FAILED(rv))
@@ -3813,16 +3789,35 @@ XRE_InitCommandLine(int aArgc, char* aAr
   NS_ASSERTION(!CommandLine::IsInitialized(), "Bad news!");
   CommandLine::Init(aArgc, canonArgs);
 
   for (int i = 0; i < aArgc; ++i)
       free(canonArgs[i]);
   delete[] canonArgs;
 #endif
 #endif
+
+#ifdef MOZ_OMNIJAR
+  const char *omnijarPath = nsnull;
+  ArgResult ar = CheckArg("omnijar", PR_FALSE, &omnijarPath);
+  if (ar == ARG_BAD) {
+    PR_fprintf(PR_STDERR, "Error: argument -omnijar requires an omnijar path\n");
+    return NS_ERROR_FAILURE;
+  }
+
+  if (!omnijarPath)
+    return rv;
+
+  nsCOMPtr<nsILocalFile> omnijar;
+  rv = NS_NewNativeLocalFile(nsDependentCString(omnijarPath), PR_TRUE,
+                             getter_AddRefs(omnijar));
+  if (NS_SUCCEEDED(rv))
+    mozilla::SetOmnijar(omnijar);
+#endif
+
   return rv;
 }
 
 nsresult
 XRE_DeinitCommandLine()
 {
   nsresult rv = NS_OK;
 

--- a/uriloader/exthandler/Makefile.in
+++ b/uriloader/exthandler/Makefile.in
@@ -170,16 +170,18 @@ EXTRA_COMPONENTS = \
   nsHandlerService.manifest \
   nsWebHandlerApp.js \
   nsWebHandlerApp.manifest \
   $(NULL)
 
 # we don't want the shared lib, but we want to force the creation of a static lib.
 FORCE_STATIC_LIB = 1
 SRCS_IN_OBJDIR	= 1
+include $(topsrcdir)/config/config.mk
+include $(topsrcdir)/ipc/chromium/chromium-config.mk
 include $(topsrcdir)/config/rules.mk
 
 ifneq (,$(filter qt gtk2, $(MOZ_WIDGET_TOOLKIT)))
 CXXFLAGS += $(TK_CFLAGS) $(MOZ_DBUS_GLIB_CFLAGS)
 endif
 
 # the use of multiple VPATH dirs is broken in cygwin make
 ifeq ($(OS_ARCH),WINNT WINCE)

--- a/uriloader/exthandler/android/nsMIMEInfoAndroid.cpp
+++ b/uriloader/exthandler/android/nsMIMEInfoAndroid.cpp
@@ -37,17 +37,17 @@
 #include "nsMIMEInfoAndroid.h"
 #include "AndroidBridge.h"
 #include "nsAndroidHandlerApp.h"
 #include "nsArrayUtils.h"
 #include "nsISupportsUtils.h"
 #include "nsStringEnumerator.h"
 #include "nsNetUtil.h"
 
-NS_IMPL_ISUPPORTS1(nsMIMEInfoAndroid, nsIMIMEInfo)
+NS_IMPL_ISUPPORTS2(nsMIMEInfoAndroid, nsIMIMEInfo, nsIHandlerInfo)
 
 nsMIMEInfoAndroid::~nsMIMEInfoAndroid()
 {
 }
 
 NS_IMETHODIMP
 nsMIMEInfoAndroid::LaunchDefaultWithFile(nsIFile* aFile)
 {
@@ -225,19 +225,17 @@ nsMIMEInfoAndroid::SetPreferredAction(ns
 {
   mPrefAction = aPrefAction;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsMIMEInfoAndroid::GetAlwaysAskBeforeHandling(PRBool* aAlwaysAsk)
 {
-  // the chooser dialog currently causes a crash on Android, avoid this by returning false here
-  // but be sure to return mAlwaysAsk when that gets fixed (bug 584896)
-  *aAlwaysAsk = PR_FALSE;
+  *aAlwaysAsk = mAlwaysAsk;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsMIMEInfoAndroid::SetAlwaysAskBeforeHandling(PRBool aAlwaysAsk)
 {
   mAlwaysAsk = aAlwaysAsk;
   return NS_OK;

--- a/uriloader/exthandler/nsExternalHelperAppService.cpp
+++ b/uriloader/exthandler/nsExternalHelperAppService.cpp
@@ -37,16 +37,25 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
+#ifdef MOZ_LOGGING
+#define FORCE_PR_LOG
+#endif
+
+#ifdef MOZ_IPC
+#include "mozilla/dom/ContentChild.h"
+#include "nsXULAppAPI.h"
+#endif
+
 #include "nsExternalHelperAppService.h"
 #include "nsCExternalHandlerService.h"
 #include "nsIURI.h"
 #include "nsIURL.h"
 #include "nsIFile.h"
 #include "nsIFileURL.h"
 #include "nsIChannel.h"
 #include "nsIDirectoryService.h"
@@ -856,16 +865,23 @@ static const char kExternalProtocolPrefP
 static const char kExternalProtocolDefaultPref[] = "network.protocol-handler.external-default";
 
 NS_IMETHODIMP 
 nsExternalHelperAppService::LoadURI(nsIURI *aURI,
                                     nsIInterfaceRequestor *aWindowContext)
 {
   NS_ENSURE_ARG_POINTER(aURI);
 
+#ifdef MOZ_IPC
+  if (XRE_GetProcessType() == GeckoProcessType_Content) {
+    mozilla::dom::ContentChild::GetSingleton()->SendLoadURIExternal(aURI);
+    return NS_OK;
+  }
+#endif
+
   nsCAutoString spec;
   aURI->GetSpec(spec);
 
   if (spec.Find("%00") != -1)
     return NS_ERROR_MALFORMED_URI;
 
   spec.ReplaceSubstring("\"", "%22");
   spec.ReplaceSubstring("`", "%60");

--- a/widget/src/qt/nsWindow.cpp
+++ b/widget/src/qt/nsWindow.cpp
@@ -2077,17 +2077,19 @@ nsWindow::createQWidget(MozQWidget *pare
         widget->setFocusPolicy(Qt::WheelFocus);
     }
 
     // create a QGraphicsView if this is a new toplevel window
 
     if (mIsTopLevel) {
         QGraphicsView* newView = nsnull;
 #ifdef MOZ_ENABLE_MEEGOTOUCH
-        newView = new MozMGraphicsView(widget);
+        if (XRE_GetProcessType() == GeckoProcessType_Default) {
+            newView = new MozMGraphicsView(widget);
+        } else
 #else
         newView = new MozQGraphicsView(widget);
 #endif
         if (!newView) {
             delete widget;
             return nsnull;
         }
 

--- a/xpcom/base/nsDebugImpl.cpp
+++ b/xpcom/base/nsDebugImpl.cpp
@@ -388,18 +388,20 @@ RealBreak()
 #endif
 #elif defined(XP_OS2)
    asm("int $3");
 #elif defined(XP_BEOS)
 #elif defined(XP_MACOSX)
    raise(SIGTRAP);
 #elif defined(__GNUC__) && (defined(__i386__) || defined(__i386) || defined(__x86_64__))
    asm("int $3");
+#elif defined(__arm__)
+   asm("BKPT #0");
 #else
-   // don't know how to break on this platform
+#warning don't know how to break on this platform  
 #endif
 }
 
 // Abort() calls this function, don't call it!
 static void
 Break(const char *aMsg)
 {
 #if defined(_WIN32)
@@ -488,18 +490,20 @@ Break(const char *aMsg)
 #elif defined(XP_MACOSX)
    /* Note that we put this Mac OS X test above the GNUC/x86 test because the
     * GNUC/x86 test is also true on Intel Mac OS X and we want the PPC/x86
     * impls to be the same.
     */
    RealBreak();
 #elif defined(__GNUC__) && (defined(__i386__) || defined(__i386) || defined(__x86_64__))
    RealBreak();
+#elif defined(__arm__)
+   RealBreak();
 #else
-   // don't know how to break on this platform
+#warning don't know how to break on this platform
 #endif
 }
 
 static const nsDebugImpl kImpl;
 
 nsresult
 nsDebugImpl::Create(nsISupports* outer, const nsIID& aIID, void* *aInstancePtr)
 {

--- a/xpcom/build/Omnijar.cpp
+++ b/xpcom/build/Omnijar.cpp
@@ -40,49 +40,62 @@
 
 #include "nsILocalFile.h"
 #include "nsXULAppAPI.h"
 #include "nsZipArchive.h"
 
 static nsILocalFile* sOmnijarPath = nsnull;
 static nsZipArchive* sOmnijarReader = nsnull;
 
+static void
+SetupReader()
+{
+    if (!sOmnijarPath) {
+        return;
+    }
+
+    nsZipArchive* zipReader = new nsZipArchive();
+    if (!zipReader) {
+        NS_IF_RELEASE(sOmnijarPath);
+        return;
+    }
+
+    if (NS_FAILED(zipReader->OpenArchive(sOmnijarPath))) {
+        delete zipReader;
+        NS_IF_RELEASE(sOmnijarPath);
+        return;
+    }
+
+    sOmnijarReader = zipReader;
+}
+
 nsILocalFile*
 mozilla::OmnijarPath()
 {
+    if (!sOmnijarReader)
+        SetupReader();
+
     return sOmnijarPath;
 }
 
 nsZipArchive*
 mozilla::OmnijarReader()
 {
+    if (!sOmnijarReader)
+        SetupReader();
+
     return sOmnijarReader;
 }
 
 void
 mozilla::SetOmnijar(nsILocalFile* aPath)
 {
     NS_IF_RELEASE(sOmnijarPath);
     if (sOmnijarReader) {
         sOmnijarReader->CloseArchive();
         delete sOmnijarReader;
         sOmnijarReader = nsnull;
     }
 
-    if (!aPath) {
-        return;
-    }
-
-    nsZipArchive* zipReader = new nsZipArchive();
-    if (!zipReader) {
-        return;
-    }
-
-    if (NS_FAILED(zipReader->OpenArchive(aPath))) {
-        delete zipReader;
-        return;
-    }
-
-    sOmnijarReader = zipReader;
     sOmnijarPath = aPath;
-    NS_ADDREF(sOmnijarPath);
+    NS_IF_ADDREF(sOmnijarPath);
 }
 

--- a/xpcom/build/nsXPComInit.cpp
+++ b/xpcom/build/nsXPComInit.cpp
@@ -137,16 +137,17 @@ extern nsresult nsStringInputStreamConst
 #endif
 
 #include "nsSystemInfo.h"
 #include "nsMemoryReporterManager.h"
 
 #include <locale.h>
 #include "mozilla/Services.h"
 #include "mozilla/FunctionTimer.h"
+#include "mozilla/Omnijar.h"
 
 #include "nsChromeRegistry.h"
 #include "nsChromeProtocolHandler.h"
 
 #ifdef MOZ_IPC
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
@@ -414,16 +415,17 @@ NS_InitXPCOM2(nsIServiceManager* *result
         setlocale(LC_ALL, "");
 #endif
 
 #if defined(XP_UNIX) || defined(XP_OS2)
     NS_TIME_FUNCTION_MARK("Next: startup native charset utils");
 
     NS_StartupNativeCharsetUtils();
 #endif
+
     NS_TIME_FUNCTION_MARK("Next: startup local file");
 
     NS_StartupLocalFile();
 
     StartupSpecialSystemDirectory();
 
     rv = nsDirectoryService::RealInit();
     if (NS_FAILED(rv))
@@ -452,16 +454,36 @@ NS_InitXPCOM2(nsIServiceManager* *result
         nsDirectoryService::gService->Set(NS_XPCOM_LIBRARY_FILE, xpcomLib);
     }
     
     if (appFileLocationProvider) {
         rv = nsDirectoryService::gService->RegisterProvider(appFileLocationProvider);
         if (NS_FAILED(rv)) return rv;
     }
 
+#ifdef MOZ_OMNIJAR
+    NS_TIME_FUNCTION_MARK("Next: Omnijar init");
+
+    if (!mozilla::OmnijarPath()) {
+        nsCOMPtr<nsILocalFile> omnijar;
+        nsCOMPtr<nsIFile> file;
+
+        rv = NS_ERROR_FAILURE;
+        nsDirectoryService::gService->Get(NS_GRE_DIR,
+                                          NS_GET_IID(nsIFile),
+                                          getter_AddRefs(file));
+        if (file)
+            rv = file->Append(NS_LITERAL_STRING("omni.jar"));
+        if (NS_SUCCEEDED(rv))
+            omnijar = do_QueryInterface(file);
+        if (NS_SUCCEEDED(rv))
+            mozilla::SetOmnijar(omnijar);
+    }
+#endif
+
 #ifdef MOZ_IPC
     if ((sCommandLineWasInitialized = !CommandLine::IsInitialized())) {
         NS_TIME_FUNCTION_MARK("Next: IPC command line init");
 
 #ifdef OS_WIN
         CommandLine::Init(0, nsnull);
 #else
         nsCOMPtr<nsIFile> binaryFile;
@@ -729,14 +751,18 @@ ShutdownXPCOM(nsIServiceManager* servMgr
         sCommandLineWasInitialized = false;
     }
     if (sExitManager) {
         delete sExitManager;
         sExitManager = nsnull;
     }
 #endif
 
+#ifdef MOZ_OMNIJAR
+    mozilla::SetOmnijar(nsnull);
+#endif
+
     NS_LogTerm();
 
     return NS_OK;
 }
 
 } // namespace mozilla

--- a/xpcom/components/nsComponentManager.cpp
+++ b/xpcom/components/nsComponentManager.cpp
@@ -521,16 +521,19 @@ GetExtension(nsILocalFile* file)
     CutExtension(extension);
     return extension;
 }
 
 #ifdef MOZ_OMNIJAR
 void
 nsComponentManagerImpl::RegisterOmnijar(const char* aPath, bool aChromeOnly)
 {
+    if (!mozilla::OmnijarPath())
+        return;
+
     nsCOMPtr<nsIInputStream> is = mManifestLoader->LoadEntry(aPath);
 
     PRUint32 flen;
     is->Available(&flen);
 
     nsAutoArrayPtr<char> whole(new char[flen + 1]);
     if (!whole)
         return;