Bug 990764 - Replace MOZ_ASSUME_UNREACHABLE with MOZ_CRASH in widget/android. r=blassey
authorChris Peterson <cpeterson@mozilla.com>
Sun, 27 Apr 2014 18:56:46 -0700
changeset 181045 c8744094c98540d3a07afcfd2992ffe042ace477
parent 181044 47feb777c154ee23f563912236e8180aa4ba645e
child 181046 2e077142ca7335f8286d764c79eafd2caffbcd2a
push id272
push userpvanderbeken@mozilla.com
push dateMon, 05 May 2014 16:31:18 +0000
reviewersblassey
bugs990764
milestone32.0a1
Bug 990764 - Replace MOZ_ASSUME_UNREACHABLE with MOZ_CRASH in widget/android. r=blassey
build/annotationProcessors/CodeGenerator.java
widget/android/GeneratedJNIWrappers.cpp
--- a/build/annotationProcessors/CodeGenerator.java
+++ b/build/annotationProcessors/CodeGenerator.java
@@ -323,17 +323,17 @@ public class CodeGenerator {
         if (aIsObjectReturningMethod) {
             localReferencesNeeded++;
         }
         wrapperMethodBodies.append(
                 "    if (env->PushLocalFrame(").append(localReferencesNeeded).append(") != 0) {\n");
         if (!aNoThrow) {
             wrapperMethodBodies.append(
                 "        AndroidBridge::HandleUncaughtException(env);\n" +
-                "        MOZ_ASSUME_UNREACHABLE(\"Exception should have caused crash.\");\n");
+                "        MOZ_CRASH(\"Exception should have caused crash.\");\n");
         } else {
             wrapperMethodBodies.append(
                 "        return").append(Utils.getFailureReturnForType(returnType)).append(";\n");
         }
         wrapperMethodBodies.append(
                 "    }\n\n");
     }
 
--- a/widget/android/GeneratedJNIWrappers.cpp
+++ b/widget/android/GeneratedJNIWrappers.cpp
@@ -174,29 +174,29 @@ GeckoAppShell* GeckoAppShell::Wrap(jobje
     env->DeleteLocalRef(obj);
     return ret;
 }
 
 void GeckoAppShell::AcknowledgeEvent() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jAcknowledgeEvent);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::AddPluginViewWrapper(jobject a0, jfloat a1, jfloat a2, jfloat a3, jfloat a4, bool a5) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jvalue args[6];
     args[0].l = a0;
     args[1].f = a1;
     args[2].f = a2;
     args[3].f = a3;
     args[4].f = a4;
@@ -206,17 +206,17 @@ void GeckoAppShell::AddPluginViewWrapper
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::AlertsProgressListener_OnProgress(const nsAString& a0, int64_t a1, int64_t a2, const nsAString& a3) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(2) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jvalue args[4];
     args[0].l = AndroidBridge::NewJavaString(env, a0);
     args[1].j = a1;
     args[2].j = a2;
     args[3].l = AndroidBridge::NewJavaString(env, a3);
 
@@ -224,81 +224,81 @@ void GeckoAppShell::AlertsProgressListen
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::CancelVibrate() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jCancelVibrate);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::CheckURIVisited(const nsAString& a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jstring j0 = AndroidBridge::NewJavaString(env, a0);
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jCheckURIVisited, j0);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::ClearMessageList(int32_t a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jClearMessageList, a0);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::CloseCamera() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jCloseCamera);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::CloseNotification(const nsAString& a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jstring j0 = AndroidBridge::NewJavaString(env, a0);
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jCloseNotification, j0);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::CreateMessageListWrapper(int64_t a0, int64_t a1, jobjectArray a2, int32_t a3, int32_t a4, bool a5, int32_t a6) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jvalue args[7];
     args[0].j = a0;
     args[1].j = a1;
     args[2].l = a2;
     args[3].i = a3;
     args[4].i = a4;
@@ -309,17 +309,17 @@ void GeckoAppShell::CreateMessageListWra
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::CreateShortcut(const nsAString& a0, const nsAString& a1, const nsAString& a2, const nsAString& a3) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(4) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jvalue args[4];
     args[0].l = AndroidBridge::NewJavaString(env, a0);
     args[1].l = AndroidBridge::NewJavaString(env, a1);
     args[2].l = AndroidBridge::NewJavaString(env, a2);
     args[3].l = AndroidBridge::NewJavaString(env, a3);
 
@@ -327,315 +327,315 @@ void GeckoAppShell::CreateShortcut(const
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::DeleteMessageWrapper(int32_t a0, int32_t a1) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jDeleteMessageWrapper, a0, a1);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::DisableBatteryNotifications() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jDisableBatteryNotifications);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::DisableNetworkNotifications() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jDisableNetworkNotifications);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::DisableScreenOrientationNotifications() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jDisableScreenOrientationNotifications);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::DisableSensor(int32_t a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jDisableSensor, a0);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::EnableBatteryNotifications() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jEnableBatteryNotifications);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::EnableLocation(bool a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jEnableLocation, a0);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::EnableLocationHighAccuracy(bool a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jEnableLocationHighAccuracy, a0);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::EnableNetworkNotifications() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jEnableNetworkNotifications);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::EnableScreenOrientationNotifications() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jEnableScreenOrientationNotifications);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::EnableSensor(int32_t a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jEnableSensor, a0);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 jobject GeckoAppShell::GetContext() {
     JNIEnv *env = GetJNIForThread();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jobject temp = env->CallStaticObjectMethod(mGeckoAppShellClass, jGetContext);
     AndroidBridge::HandleUncaughtException(env);
     jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
     return ret;
 }
 
 jdoubleArray GeckoAppShell::GetCurrentBatteryInformationWrapper() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jobject temp = env->CallStaticObjectMethod(mGeckoAppShellClass, jGetCurrentBatteryInformationWrapper);
     AndroidBridge::HandleUncaughtException(env);
     jdoubleArray ret = static_cast<jdoubleArray>(env->PopLocalFrame(temp));
     return ret;
 }
 
 jdoubleArray GeckoAppShell::GetCurrentNetworkInformationWrapper() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jobject temp = env->CallStaticObjectMethod(mGeckoAppShellClass, jGetCurrentNetworkInformationWrapper);
     AndroidBridge::HandleUncaughtException(env);
     jdoubleArray ret = static_cast<jdoubleArray>(env->PopLocalFrame(temp));
     return ret;
 }
 
 jfloat GeckoAppShell::GetDensity() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jfloat temp = env->CallStaticFloatMethod(mGeckoAppShellClass, jGetDensity);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
     return temp;
 }
 
 int32_t GeckoAppShell::GetDpiWrapper() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     int32_t temp = env->CallStaticIntMethod(mGeckoAppShellClass, jGetDpiWrapper);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
     return temp;
 }
 
 jstring GeckoAppShell::GetExtensionFromMimeTypeWrapper(const nsAString& a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(2) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jstring j0 = AndroidBridge::NewJavaString(env, a0);
 
     jobject temp = env->CallStaticObjectMethod(mGeckoAppShellClass, jGetExtensionFromMimeTypeWrapper, j0);
     AndroidBridge::HandleUncaughtException(env);
     jstring ret = static_cast<jstring>(env->PopLocalFrame(temp));
     return ret;
 }
 
 jobjectArray GeckoAppShell::GetHandlersForMimeTypeWrapper(const nsAString& a0, const nsAString& a1) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(3) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jstring j0 = AndroidBridge::NewJavaString(env, a0);
     jstring j1 = AndroidBridge::NewJavaString(env, a1);
 
     jobject temp = env->CallStaticObjectMethod(mGeckoAppShellClass, jGetHandlersForMimeTypeWrapper, j0, j1);
     AndroidBridge::HandleUncaughtException(env);
     jobjectArray ret = static_cast<jobjectArray>(env->PopLocalFrame(temp));
     return ret;
 }
 
 jobjectArray GeckoAppShell::GetHandlersForURLWrapper(const nsAString& a0, const nsAString& a1) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(3) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jstring j0 = AndroidBridge::NewJavaString(env, a0);
     jstring j1 = AndroidBridge::NewJavaString(env, a1);
 
     jobject temp = env->CallStaticObjectMethod(mGeckoAppShellClass, jGetHandlersForURLWrapper, j0, j1);
     AndroidBridge::HandleUncaughtException(env);
     jobjectArray ret = static_cast<jobjectArray>(env->PopLocalFrame(temp));
     return ret;
 }
 
 jbyteArray GeckoAppShell::GetIconForExtensionWrapper(const nsAString& a0, int32_t a1) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(2) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jstring j0 = AndroidBridge::NewJavaString(env, a0);
 
     jobject temp = env->CallStaticObjectMethod(mGeckoAppShellClass, jGetIconForExtensionWrapper, j0, a1);
     AndroidBridge::HandleUncaughtException(env);
     jbyteArray ret = static_cast<jbyteArray>(env->PopLocalFrame(temp));
     return ret;
 }
 
 void GeckoAppShell::GetMessageWrapper(int32_t a0, int32_t a1) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jGetMessageWrapper, a0, a1);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 jstring GeckoAppShell::GetMimeTypeFromExtensionsWrapper(const nsAString& a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(2) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jstring j0 = AndroidBridge::NewJavaString(env, a0);
 
     jobject temp = env->CallStaticObjectMethod(mGeckoAppShellClass, jGetMimeTypeFromExtensionsWrapper, j0);
     AndroidBridge::HandleUncaughtException(env);
     jstring ret = static_cast<jstring>(env->PopLocalFrame(temp));
     return ret;
 }
 
 void GeckoAppShell::GetNextMessageInListWrapper(int32_t a0, int32_t a1) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jGetNextMessageInListWrapper, a0, a1);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 jstring GeckoAppShell::GetProxyForURIWrapper(const nsAString& a0, const nsAString& a1, const nsAString& a2, int32_t a3) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(4) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jvalue args[4];
     args[0].l = AndroidBridge::NewJavaString(env, a0);
     args[1].l = AndroidBridge::NewJavaString(env, a1);
     args[2].l = AndroidBridge::NewJavaString(env, a2);
     args[3].i = a3;
 
@@ -644,69 +644,69 @@ jstring GeckoAppShell::GetProxyForURIWra
     jstring ret = static_cast<jstring>(env->PopLocalFrame(temp));
     return ret;
 }
 
 int32_t GeckoAppShell::GetScreenDepthWrapper() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     int32_t temp = env->CallStaticIntMethod(mGeckoAppShellClass, jGetScreenDepthWrapper);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
     return temp;
 }
 
 int16_t GeckoAppShell::GetScreenOrientationWrapper() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     int16_t temp = env->CallStaticShortMethod(mGeckoAppShellClass, jGetScreenOrientationWrapper);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
     return temp;
 }
 
 bool GeckoAppShell::GetShowPasswordSetting() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     bool temp = env->CallStaticBooleanMethod(mGeckoAppShellClass, jGetShowPasswordSetting);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
     return temp;
 }
 
 jintArray GeckoAppShell::GetSystemColoursWrapper() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jobject temp = env->CallStaticObjectMethod(mGeckoAppShellClass, jGetSystemColoursWrapper);
     AndroidBridge::HandleUncaughtException(env);
     jintArray ret = static_cast<jintArray>(env->PopLocalFrame(temp));
     return ret;
 }
 
 void GeckoAppShell::HandleGeckoMessageWrapper(jobject a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jHandleGeckoMessageWrapper, a0);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::HandleUncaughtException(jobject a0, jthrowable a1) {
@@ -718,29 +718,29 @@ void GeckoAppShell::HandleUncaughtExcept
     env->CallStaticVoidMethod(mGeckoAppShellClass, jHandleUncaughtException, a0, a1);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::HideProgressDialog() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jHideProgressDialog);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 jintArray GeckoAppShell::InitCameraWrapper(const nsAString& a0, int32_t a1, int32_t a2, int32_t a3) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(2) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jvalue args[4];
     args[0].l = AndroidBridge::NewJavaString(env, a0);
     args[1].i = a1;
     args[2].i = a2;
     args[3].i = a3;
 
@@ -749,159 +749,159 @@ jintArray GeckoAppShell::InitCameraWrapp
     jintArray ret = static_cast<jintArray>(env->PopLocalFrame(temp));
     return ret;
 }
 
 bool GeckoAppShell::IsNetworkLinkKnown() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     bool temp = env->CallStaticBooleanMethod(mGeckoAppShellClass, jIsNetworkLinkKnown);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
     return temp;
 }
 
 bool GeckoAppShell::IsNetworkLinkUp() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     bool temp = env->CallStaticBooleanMethod(mGeckoAppShellClass, jIsNetworkLinkUp);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
     return temp;
 }
 
 bool GeckoAppShell::IsTablet() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     bool temp = env->CallStaticBooleanMethod(mGeckoAppShellClass, jIsTablet);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
     return temp;
 }
 
 void GeckoAppShell::KillAnyZombies() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jKillAnyZombies);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 jclass GeckoAppShell::LoadPluginClass(const nsAString& a0, const nsAString& a1) {
     JNIEnv *env = GetJNIForThread();
     if (env->PushLocalFrame(3) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jstring j0 = AndroidBridge::NewJavaString(env, a0);
     jstring j1 = AndroidBridge::NewJavaString(env, a1);
 
     jobject temp = env->CallStaticObjectMethod(mGeckoAppShellClass, jLoadPluginClass, j0, j1);
     AndroidBridge::HandleUncaughtException(env);
     jclass ret = static_cast<jclass>(env->PopLocalFrame(temp));
     return ret;
 }
 
 void GeckoAppShell::LockScreenOrientation(int32_t a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jLockScreenOrientation, a0);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::MarkURIVisited(const nsAString& a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jstring j0 = AndroidBridge::NewJavaString(env, a0);
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jMarkURIVisited, j0);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::MoveTaskToBack() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jMoveTaskToBack);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 int32_t GeckoAppShell::NetworkLinkType() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     int32_t temp = env->CallStaticIntMethod(mGeckoAppShellClass, jNetworkLinkType);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
     return temp;
 }
 
 void GeckoAppShell::NotifyDefaultPrevented(bool a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jNotifyDefaultPrevented, a0);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::NotifyIME(int32_t a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jNotifyIME, a0);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::NotifyIMEChange(const nsAString& a0, int32_t a1, int32_t a2, int32_t a3) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jvalue args[4];
     args[0].l = AndroidBridge::NewJavaString(env, a0);
     args[1].i = a1;
     args[2].i = a2;
     args[3].i = a3;
 
@@ -909,17 +909,17 @@ void GeckoAppShell::NotifyIMEChange(cons
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::NotifyIMEContext(int32_t a0, const nsAString& a1, const nsAString& a2, const nsAString& a3) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(3) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jvalue args[4];
     args[0].i = a0;
     args[1].l = AndroidBridge::NewJavaString(env, a1);
     args[2].l = AndroidBridge::NewJavaString(env, a2);
     args[3].l = AndroidBridge::NewJavaString(env, a3);
 
@@ -927,44 +927,44 @@ void GeckoAppShell::NotifyIMEContext(int
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::NotifyWakeLockChanged(const nsAString& a0, const nsAString& a1) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(2) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jstring j0 = AndroidBridge::NewJavaString(env, a0);
     jstring j1 = AndroidBridge::NewJavaString(env, a1);
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jNotifyWakeLockChanged, j0, j1);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::NotifyXreExit() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jNotifyXreExit);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 bool GeckoAppShell::OpenUriExternal(const nsAString& a0, const nsAString& a1, const nsAString& a2, const nsAString& a3, const nsAString& a4, const nsAString& a5) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(6) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jvalue args[6];
     args[0].l = AndroidBridge::NewJavaString(env, a0);
     args[1].l = AndroidBridge::NewJavaString(env, a1);
     args[2].l = AndroidBridge::NewJavaString(env, a2);
     args[3].l = AndroidBridge::NewJavaString(env, a3);
     args[4].l = AndroidBridge::NewJavaString(env, a4);
@@ -975,149 +975,149 @@ bool GeckoAppShell::OpenUriExternal(cons
     env->PopLocalFrame(nullptr);
     return temp;
 }
 
 void GeckoAppShell::PerformHapticFeedback(bool a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jPerformHapticFeedback, a0);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 bool GeckoAppShell::PumpMessageLoop() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     bool temp = env->CallStaticBooleanMethod(mGeckoAppShellClass, jPumpMessageLoop);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
     return temp;
 }
 
 void GeckoAppShell::RegisterSurfaceTextureFrameListener(jobject a0, int32_t a1) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jRegisterSurfaceTextureFrameListener, a0, a1);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::RemovePluginView(jobject a0, bool a1) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jRemovePluginView, a0, a1);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::ScanMedia(const nsAString& a0, const nsAString& a1) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(2) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jstring j0 = AndroidBridge::NewJavaString(env, a0);
     jstring j1 = AndroidBridge::NewJavaString(env, a1);
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jScanMedia, j0, j1);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::ScheduleRestart() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jScheduleRestart);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::SendMessageWrapper(const nsAString& a0, const nsAString& a1, int32_t a2) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(2) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jvalue args[3];
     args[0].l = AndroidBridge::NewJavaString(env, a0);
     args[1].l = AndroidBridge::NewJavaString(env, a1);
     args[2].i = a2;
 
     env->CallStaticVoidMethodA(mGeckoAppShellClass, jSendMessageWrapper, args);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::SetFullScreen(bool a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jSetFullScreen, a0);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::SetKeepScreenOn(bool a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jSetKeepScreenOn, a0);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::SetURITitle(const nsAString& a0, const nsAString& a1) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(2) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jstring j0 = AndroidBridge::NewJavaString(env, a0);
     jstring j1 = AndroidBridge::NewJavaString(env, a1);
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jSetURITitle, j0, j1);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::ShowAlertNotificationWrapper(const nsAString& a0, const nsAString& a1, const nsAString& a2, const nsAString& a3, const nsAString& a4) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(5) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jvalue args[5];
     args[0].l = AndroidBridge::NewJavaString(env, a0);
     args[1].l = AndroidBridge::NewJavaString(env, a1);
     args[2].l = AndroidBridge::NewJavaString(env, a2);
     args[3].l = AndroidBridge::NewJavaString(env, a3);
     args[4].l = AndroidBridge::NewJavaString(env, a4);
@@ -1126,78 +1126,78 @@ void GeckoAppShell::ShowAlertNotificatio
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::ShowInputMethodPicker() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jShowInputMethodPicker);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 bool GeckoAppShell::UnlockProfile() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     bool temp = env->CallStaticBooleanMethod(mGeckoAppShellClass, jUnlockProfile);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
     return temp;
 }
 
 void GeckoAppShell::UnlockScreenOrientation() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jUnlockScreenOrientation);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::UnregisterSurfaceTextureFrameListener(jobject a0) {
     JNIEnv *env = GetJNIForThread();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jUnregisterSurfaceTextureFrameListener, a0);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::Vibrate1(int64_t a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jVibrate1, a0);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoAppShell::VibrateA(jlongArray a0, int32_t a1) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoAppShellClass, jVibrateA, a0, a1);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 jclass JavaDomKeyLocation::mDomKeyLocationClass = 0;
 jmethodID JavaDomKeyLocation::jvalueOf = 0;
@@ -1230,32 +1230,32 @@ JavaDomKeyLocation* JavaDomKeyLocation::
     env->DeleteLocalRef(obj);
     return ret;
 }
 
 jobject JavaDomKeyLocation::valueOf(const nsAString& a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(2) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jstring j0 = AndroidBridge::NewJavaString(env, a0);
 
     jobject temp = env->CallStaticObjectMethod(mDomKeyLocationClass, jvalueOf, j0);
     AndroidBridge::HandleUncaughtException(env);
     jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
     return ret;
 }
 
 jobjectArray JavaDomKeyLocation::values() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jobject temp = env->CallStaticObjectMethod(mDomKeyLocationClass, jvalues);
     AndroidBridge::HandleUncaughtException(env);
     jobjectArray ret = static_cast<jobjectArray>(env->PopLocalFrame(temp));
     return ret;
 }
 
@@ -1320,17 +1320,17 @@ GeckoJavaSampler* GeckoJavaSampler::Wrap
     env->DeleteLocalRef(obj);
     return ret;
 }
 
 jstring GeckoJavaSampler::GetFrameNameJavaProfilingWrapper(int32_t a0, int32_t a1, int32_t a2) {
     JNIEnv *env = GetJNIForThread();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jvalue args[3];
     args[0].i = a0;
     args[1].i = a1;
     args[2].i = a2;
 
     jobject temp = env->CallStaticObjectMethodA(mGeckoJavaSamplerClass, jGetFrameNameJavaProfilingWrapper, args);
@@ -1338,79 +1338,79 @@ jstring GeckoJavaSampler::GetFrameNameJa
     jstring ret = static_cast<jstring>(env->PopLocalFrame(temp));
     return ret;
 }
 
 jdouble GeckoJavaSampler::GetSampleTimeJavaProfiling(int32_t a0, int32_t a1) {
     JNIEnv *env = GetJNIForThread();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jdouble temp = env->CallStaticDoubleMethod(mGeckoJavaSamplerClass, jGetSampleTimeJavaProfiling, a0, a1);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
     return temp;
 }
 
 jstring GeckoJavaSampler::GetThreadNameJavaProfilingWrapper(int32_t a0) {
     JNIEnv *env = GetJNIForThread();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jobject temp = env->CallStaticObjectMethod(mGeckoJavaSamplerClass, jGetThreadNameJavaProfilingWrapper, a0);
     AndroidBridge::HandleUncaughtException(env);
     jstring ret = static_cast<jstring>(env->PopLocalFrame(temp));
     return ret;
 }
 
 void GeckoJavaSampler::PauseJavaProfiling() {
     JNIEnv *env = GetJNIForThread();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoJavaSamplerClass, jPauseJavaProfiling);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoJavaSampler::StartJavaProfiling(int32_t a0, int32_t a1) {
     JNIEnv *env = GetJNIForThread();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoJavaSamplerClass, jStartJavaProfiling, a0, a1);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoJavaSampler::StopJavaProfiling() {
     JNIEnv *env = GetJNIForThread();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoJavaSamplerClass, jStopJavaProfiling);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoJavaSampler::UnpauseJavaProfiling() {
     JNIEnv *env = GetJNIForThread();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mGeckoJavaSamplerClass, jUnpauseJavaProfiling);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 jclass SurfaceBits::mSurfaceBitsClass = 0;
 jmethodID SurfaceBits::jSurfaceBits = 0;
@@ -1435,17 +1435,17 @@ SurfaceBits* SurfaceBits::Wrap(jobject o
     env->DeleteLocalRef(obj);
     return ret;
 }
 
 SurfaceBits::SurfaceBits() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     Init(env->NewObject(mSurfaceBitsClass, jSurfaceBits), env);
     env->PopLocalFrame(nullptr);
 }
 
 jobject SurfaceBits::getbuffer() {
     JNIEnv *env = GetJNIForThread();
@@ -1501,17 +1501,17 @@ ThumbnailHelper* ThumbnailHelper::Wrap(j
     env->DeleteLocalRef(obj);
     return ret;
 }
 
 void ThumbnailHelper::SendThumbnail(jobject a0, int32_t a1, bool a2) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jvalue args[3];
     args[0].l = a0;
     args[1].i = a1;
     args[2].z = a2;
 
     env->CallStaticVoidMethodA(mThumbnailHelperClass, jSendThumbnail, args);
@@ -1537,17 +1537,17 @@ DisplayPortMetrics* DisplayPortMetrics::
     env->DeleteLocalRef(obj);
     return ret;
 }
 
 DisplayPortMetrics::DisplayPortMetrics(jfloat a0, jfloat a1, jfloat a2, jfloat a3, jfloat a4) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jvalue args[5];
     args[0].f = a0;
     args[1].f = a1;
     args[2].f = a2;
     args[3].f = a3;
     args[4].f = a4;
@@ -1580,17 +1580,17 @@ GLController* GLController::Wrap(jobject
     env->DeleteLocalRef(obj);
     return ret;
 }
 
 jobject GLController::CreateEGLSurfaceForCompositorWrapper() {
     JNIEnv *env = GetJNIForThread();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jobject temp = env->CallObjectMethod(wrapped_obj, jCreateEGLSurfaceForCompositorWrapper);
     AndroidBridge::HandleUncaughtException(env);
     jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
     return ret;
 }
 jclass GeckoLayerClient::mGeckoLayerClientClass = 0;
@@ -1628,66 +1628,66 @@ GeckoLayerClient* GeckoLayerClient::Wrap
     env->DeleteLocalRef(obj);
     return ret;
 }
 
 void GeckoLayerClient::ActivateProgram() {
     JNIEnv *env = GetJNIForThread();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallVoidMethod(wrapped_obj, jActivateProgram);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoLayerClient::ContentDocumentChanged() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallVoidMethod(wrapped_obj, jContentDocumentChanged);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 jobject GeckoLayerClient::CreateFrame() {
     JNIEnv *env = GetJNIForThread();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jobject temp = env->CallObjectMethod(wrapped_obj, jCreateFrame);
     AndroidBridge::HandleUncaughtException(env);
     jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
     return ret;
 }
 
 void GeckoLayerClient::DeactivateProgram() {
     JNIEnv *env = GetJNIForThread();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallVoidMethod(wrapped_obj, jDeactivateProgram);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 jobject GeckoLayerClient::GetDisplayPort(bool a0, bool a1, int32_t a2, jobject a3) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(2) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jvalue args[4];
     args[0].z = a0;
     args[1].z = a1;
     args[2].i = a2;
     args[3].l = a3;
 
@@ -1696,30 +1696,30 @@ jobject GeckoLayerClient::GetDisplayPort
     jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
     return ret;
 }
 
 bool GeckoLayerClient::IsContentDocumentDisplayed() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     bool temp = env->CallBooleanMethod(wrapped_obj, jIsContentDocumentDisplayed);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
     return temp;
 }
 
 jobject GeckoLayerClient::ProgressiveUpdateCallback(bool a0, jfloat a1, jfloat a2, jfloat a3, jfloat a4, jfloat a5, bool a6) {
     JNIEnv *env = GetJNIForThread();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jvalue args[7];
     args[0].z = a0;
     args[1].f = a1;
     args[2].f = a2;
     args[3].f = a3;
     args[4].f = a4;
@@ -1731,17 +1731,17 @@ jobject GeckoLayerClient::ProgressiveUpd
     jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
     return ret;
 }
 
 void GeckoLayerClient::SetFirstPaintViewport(jfloat a0, jfloat a1, jfloat a2, jfloat a3, jfloat a4, jfloat a5, jfloat a6) {
     JNIEnv *env = GetJNIForThread();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jvalue args[7];
     args[0].f = a0;
     args[1].f = a1;
     args[2].f = a2;
     args[3].f = a3;
     args[4].f = a4;
@@ -1752,17 +1752,17 @@ void GeckoLayerClient::SetFirstPaintView
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void GeckoLayerClient::SetPageRect(jfloat a0, jfloat a1, jfloat a2, jfloat a3) {
     JNIEnv *env = GetJNIForThread();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jvalue args[4];
     args[0].f = a0;
     args[1].f = a1;
     args[2].f = a2;
     args[3].f = a3;
 
@@ -1770,17 +1770,17 @@ void GeckoLayerClient::SetPageRect(jfloa
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 jobject GeckoLayerClient::SyncFrameMetrics(jfloat a0, jfloat a1, jfloat a2, jfloat a3, jfloat a4, jfloat a5, jfloat a6, bool a7, int32_t a8, int32_t a9, int32_t a10, int32_t a11, jfloat a12, bool a13) {
     JNIEnv *env = GetJNIForThread();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jvalue args[14];
     args[0].f = a0;
     args[1].f = a1;
     args[2].f = a2;
     args[3].f = a3;
     args[4].f = a4;
@@ -1799,17 +1799,17 @@ jobject GeckoLayerClient::SyncFrameMetri
     jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
     return ret;
 }
 
 jobject GeckoLayerClient::SyncViewportInfo(int32_t a0, int32_t a1, int32_t a2, int32_t a3, jfloat a4, bool a5) {
     JNIEnv *env = GetJNIForThread();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jvalue args[6];
     args[0].i = a0;
     args[1].i = a1;
     args[2].i = a2;
     args[3].i = a3;
     args[4].f = a4;
@@ -1835,17 +1835,17 @@ ImmutableViewportMetrics* ImmutableViewp
     env->DeleteLocalRef(obj);
     return ret;
 }
 
 ImmutableViewportMetrics::ImmutableViewportMetrics(jfloat a0, jfloat a1, jfloat a2, jfloat a3, jfloat a4, jfloat a5, jfloat a6, jfloat a7, jfloat a8, jfloat a9, jfloat a10, jfloat a11, jfloat a12) {
     JNIEnv *env = GetJNIForThread();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jvalue args[13];
     args[0].f = a0;
     args[1].f = a1;
     args[2].f = a2;
     args[3].f = a3;
     args[4].f = a4;
@@ -1876,17 +1876,17 @@ LayerView* LayerView::Wrap(jobject obj) 
     env->DeleteLocalRef(obj);
     return ret;
 }
 
 jobject LayerView::RegisterCompositorWrapper() {
     JNIEnv *env = GetJNIForThread();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jobject temp = env->CallStaticObjectMethod(mLayerViewClass, jRegisterCompositorWrapper);
     AndroidBridge::HandleUncaughtException(env);
     jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
     return ret;
 }
 jclass NativePanZoomController::mNativePanZoomControllerClass = 0;
@@ -1906,29 +1906,29 @@ NativePanZoomController* NativePanZoomCo
     env->DeleteLocalRef(obj);
     return ret;
 }
 
 void NativePanZoomController::PostDelayedCallbackWrapper(int64_t a0) {
     JNIEnv *env = GetJNIForThread();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallVoidMethod(wrapped_obj, jPostDelayedCallbackWrapper, a0);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void NativePanZoomController::RequestContentRepaintWrapper(jfloat a0, jfloat a1, jfloat a2, jfloat a3, jfloat a4) {
     JNIEnv *env = GetJNIForThread();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jvalue args[5];
     args[0].f = a0;
     args[1].f = a1;
     args[2].f = a2;
     args[3].f = a3;
     args[4].f = a4;
@@ -1966,28 +1966,28 @@ ProgressiveUpdateData* ProgressiveUpdate
     env->DeleteLocalRef(obj);
     return ret;
 }
 
 ProgressiveUpdateData::ProgressiveUpdateData() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     Init(env->NewObject(mProgressiveUpdateDataClass, jProgressiveUpdateData), env);
     env->PopLocalFrame(nullptr);
 }
 
 void ProgressiveUpdateData::setViewport(jobject a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallVoidMethod(wrapped_obj, jsetViewport, a0);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 bool ProgressiveUpdateData::getabort() {
@@ -2082,17 +2082,17 @@ ViewTransform* ViewTransform::Wrap(jobje
     env->DeleteLocalRef(obj);
     return ret;
 }
 
 ViewTransform::ViewTransform(jfloat a0, jfloat a1, jfloat a2) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jvalue args[3];
     args[0].f = a0;
     args[1].f = a1;
     args[2].f = a2;
 
     Init(env->NewObjectA(mViewTransformClass, jViewTransform, args), env);
@@ -2203,17 +2203,17 @@ NativeZip* NativeZip::Wrap(jobject obj) 
     env->DeleteLocalRef(obj);
     return ret;
 }
 
 jobject NativeZip::CreateInputStream(jobject a0, int32_t a1) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(2) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jobject temp = env->CallObjectMethod(wrapped_obj, jCreateInputStream, a0, a1);
     AndroidBridge::HandleUncaughtException(env);
     jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
     return ret;
 }
 jclass MatrixBlobCursor::mMatrixBlobCursorClass = 0;
@@ -2239,63 +2239,63 @@ MatrixBlobCursor* MatrixBlobCursor::Wrap
     env->DeleteLocalRef(obj);
     return ret;
 }
 
 MatrixBlobCursor::MatrixBlobCursor(jobjectArray a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     Init(env->NewObject(mMatrixBlobCursorClass, jMatrixBlobCursor, a0), env);
     env->PopLocalFrame(nullptr);
 }
 
 MatrixBlobCursor::MatrixBlobCursor(jobjectArray a0, int32_t a1) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     Init(env->NewObject(mMatrixBlobCursorClass, jMatrixBlobCursor0, a0, a1), env);
     env->PopLocalFrame(nullptr);
 }
 
 void MatrixBlobCursor::AddRow(jobject a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallVoidMethod(wrapped_obj, jAddRow, a0);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void MatrixBlobCursor::AddRow(jobject a0, int32_t a1) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallVoidMethod(wrapped_obj, jAddRow1, a0, a1);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 void MatrixBlobCursor::AddRow(jobjectArray a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallVoidMethod(wrapped_obj, jAddRow2, a0);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 jclass SQLiteBridgeException::mSQLiteBridgeExceptionClass = 0;
 jmethodID SQLiteBridgeException::jSQLiteBridgeException = 0;
@@ -2316,28 +2316,28 @@ SQLiteBridgeException* SQLiteBridgeExcep
     env->DeleteLocalRef(obj);
     return ret;
 }
 
 SQLiteBridgeException::SQLiteBridgeException() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     Init(env->NewObject(mSQLiteBridgeExceptionClass, jSQLiteBridgeException), env);
     env->PopLocalFrame(nullptr);
 }
 
 SQLiteBridgeException::SQLiteBridgeException(const nsAString& a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jstring j0 = AndroidBridge::NewJavaString(env, a0);
 
     Init(env->NewObject(mSQLiteBridgeExceptionClass, jSQLiteBridgeException0, j0), env);
     env->PopLocalFrame(nullptr);
 }
 
@@ -2366,55 +2366,55 @@ Clipboard* Clipboard::Wrap(jobject obj) 
     env->DeleteLocalRef(obj);
     return ret;
 }
 
 void Clipboard::ClearText() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     env->CallStaticVoidMethod(mClipboardClass, jClearText);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }
 
 jstring Clipboard::GetClipboardTextWrapper() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jobject temp = env->CallStaticObjectMethod(mClipboardClass, jGetClipboardTextWrapper);
     AndroidBridge::HandleUncaughtException(env);
     jstring ret = static_cast<jstring>(env->PopLocalFrame(temp));
     return ret;
 }
 
 bool Clipboard::HasText() {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(0) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     bool temp = env->CallStaticBooleanMethod(mClipboardClass, jHasText);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
     return temp;
 }
 
 void Clipboard::SetClipboardText(const nsAString& a0) {
     JNIEnv *env = AndroidBridge::GetJNIEnv();
     if (env->PushLocalFrame(1) != 0) {
         AndroidBridge::HandleUncaughtException(env);
-        MOZ_ASSUME_UNREACHABLE("Exception should have caused crash.");
+        MOZ_CRASH("Exception should have caused crash.");
     }
 
     jstring j0 = AndroidBridge::NewJavaString(env, a0);
 
     env->CallStaticVoidMethod(mClipboardClass, jSetClipboardText, j0);
     AndroidBridge::HandleUncaughtException(env);
     env->PopLocalFrame(nullptr);
 }