return IPC_FAIL(this, "HTTPS-only mode: Illegal state");

   }

   nsCOMPtr<nsIURI> newURI;

   OriginAttributes originAttributes =

       TopWindowContext()->DocumentPrincipal()->OriginAttributesRef();

 ["browser_httpsonly_speculative_connect.js"]

 support-files = ["file_httpsonly_speculative_connect.html"]

 ["browser_iframe_test.js"]

 skip-if = [

   "os == 'linux' && bits == 64", # Bug 1735565

 import androidx.annotation.StyleRes

 import androidx.annotation.VisibleForTesting

 import androidx.appcompat.app.AlertDialog

 import mozilla.components.ui.widgets.withCenterAlignedButtons

 /**

  */

 class SimpleRedirectDialogFragment : RedirectDialogFragment() {

     @VisibleForTesting

     internal var testingContext: Context? = null

             return if (themeID == 0) AlertDialog.Builder(context) else AlertDialog.Builder(context, themeID)

         }

         return with(requireBundle()) {

             val dialogTitleText = getInt(KEY_TITLE_TEXT, R.string.mozac_feature_applinks_normal_confirm_dialog_title)

             val dialogMessageString = getString(KEY_MESSAGE_STRING, "")

             val themeResId = getInt(KEY_THEME_ID, 0)

             val cancelable = getBoolean(KEY_CANCELABLE, false)

                 .setTitle(dialogTitleText)

                 .setMessage(dialogMessageString)

                 .setNegativeButton(negativeButtonText) { _, _ ->

                     onCancelRedirect()

                 }

                 .setCancelable(cancelable)

                 .create()

         }

     }

         const val KEY_THEME_ID = "KEY_THEME_ID"

         const val KEY_CANCELABLE = "KEY_CANCELABLE"

     }

     private fun requireBundle(): Bundle {

 import mozilla.components.support.test.robolectric.testContext

 import org.junit.Assert.assertFalse

 import org.junit.Assert.assertTrue

 import org.junit.Test

 import org.junit.runner.RunWith

 import org.mockito.Mockito.doNothing

     private val themeResId = appcompatR.style.Theme_AppCompat_Light

     @Test

     fun `Dialog confirmed callback is called correctly`() {

         var onConfirmCalled = false

         var onCancelCalled = false

         assertFalse(onCancelCalled)

     }

     private fun mockFragmentManager(): FragmentManager {

         val fragmentManager: FragmentManager = mock()

         val transaction: FragmentTransaction = mock()

 package mozilla.components.feature.session

 import mozilla.components.browser.state.action.CrashAction

 import mozilla.components.browser.state.action.EngineAction

 import mozilla.components.browser.state.action.LastAccessAction

                     flags = flags,

                     additionalHeaders = additionalHeaders,

                 )

                 store.dispatch(

                     EngineAction.OptimizedLoadUrlTriggeredAction(

                         loadSessionId,

 import mozilla.components.browser.state.action.TabListAction

 import mozilla.components.browser.state.engine.EngineMiddleware

 import mozilla.components.browser.state.selector.findTab

 import mozilla.components.browser.state.state.BrowserState

 import mozilla.components.browser.state.state.TabSessionState

 import mozilla.components.browser.state.state.createCustomTab

             assertEquals("mozilla", action.tabId)

             assertEquals("https://getpocket.com", action.url)

         }

         useCases.loadUrl("https://www.mozilla.org", LoadUrlFlags.select(LoadUrlFlags.EXTERNAL))

         store.waitUntilIdle()

             assertEquals("https://www.mozilla.org", action.url)

             assertEquals(LoadUrlFlags.select(LoadUrlFlags.EXTERNAL), action.flags)

         }

         useCases.loadUrl("https://firefox.com", store.state.selectedTabId)

         store.waitUntilIdle()

             assertEquals("mozilla", action.tabId)

             assertEquals("https://firefox.com", action.url)

         }

         useCases.loadUrl.invoke(

             "https://developer.mozilla.org",

 * **feature-customtabs**

   * Fallback behaviour when failing to open a new window in custom tab will now be loading the URL directly in the same custom tab. [Bug 1832357](https://bugzilla.mozilla.org/show_bug.cgi?id=1832357)

 * **tooling-lint**

   * Added a lint rule to detect when `Response#close` may not have been called. Note: Currently, this rule only runs on Android Components.

             verifyPageContent(tabCrashMessage)

         }.openTabDrawer(activityTestRule) {

             verifyExistingOpenTabs(firstWebPage.title)

         }.closeTabDrawer {

         }.goToHomescreen {

             verifyExistingTopSitesList()

 import android.content.Context;

 import android.content.res.AssetFileDescriptor;

 import android.os.Build;

 import android.text.TextUtils;

 import android.util.Log;

 import java.io.ByteArrayOutputStream;

    * @return true if copy is successful.

    */

   @WrapForJNI(calledFrom = "gecko")

   }

   /**

    */

   @WrapForJNI(calledFrom = "gecko")

   private static boolean setHTML(

   }

   /**

    * @param clipData a {@link android.content.ClipData} to set to clipboard

    * @return true if copy is successful.

    */

     // In API Level 11 and above, CLIPBOARD_SERVICE returns android.content.ClipboardManager,

     // which is a subclass of android.text.ClipboardManager.

     final ClipboardManager cm =

         (ClipboardManager) context.getSystemService(Context.CLIPBOARD_SERVICE);

     try {

       cm.setPrimaryClip(clipData);

     } catch (final NullPointerException e) {

   @WrapForJNI(calledFrom = "gecko")

   private static void clear(final Context context) {

     if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.P) {

       return;

     }

     // Although we don't know more details of https://crbug.com/1203377, Blink doesn't use

   private ExtractedTextRequest mUpdateRequest;

   private final InputConnection mKeyInputConnection;

   private CursorAnchorInfo.Builder mCursorAnchorInfoBuilder;

   public static SessionTextInput.InputConnectionClient create(

       final GeckoSession session,

         // If selection is empty, we'll select everything

         if (selStart == selEnd) {

           // Fill the clipboard

           editable.clear();

         } else {

           Clipboard.setText(

               view.getContext(),

           editable.delete(selStart, selEnd);

         }

         break;

                 : editable

                     .toString()

                     .substring(Math.min(selStart, selEnd), Math.max(selStart, selEnd));

         break;

     }

     return true;

       outAttrs.imeOptions |= EditorInfo.IME_FLAG_NO_EXTRACT_UI | EditorInfo.IME_FLAG_NO_FULLSCREEN;

     }

     if (DEBUG) {

       Log.d(

           LOGTAG,

           inert

         ></button>

       </div>

       <div class="suggestion-box" hidden>

         <h2 data-l10n-id="about-httpsonly-suggestion-box-header"></h2>

       </div>

   document

     .getElementById("learnMoreLink")

     .setAttribute("href", baseSupportURL + "https-only-prefs");

   document

     .getElementById("openInsecure")

     .addEventListener("click", onOpenInsecureButtonClick);

   const delay = RPMGetIntPref("security.dialog_enable_delay", 1000);

   setTimeout(() => {

     document.getElementById("openInsecure").removeAttribute("inert");

   }, delay);

   const hasWWWPrefix = pageUrl.href.startsWith("https://www.");

     // HTTPS-Only generally simply replaces http: with https:;

     // here we additionally try to add www and see if that allows to upgrade the connection if it is top level

 about-httpsonly-explanation-nosupport = Most likely, the website simply does not support HTTPS.

 about-httpsonly-explanation-risk = It’s also possible that an attacker is involved. If you decide to visit the website, you should not enter any sensitive information like passwords, emails, or credit card details.

 about-httpsonly-explanation-continue = If you continue, HTTPS-Only Mode will be turned off temporarily for this site.

 about-httpsonly-button-continue-to-site = Continue to HTTP Site

 about-httpsonly-button-go-back = Go Back

     return rv;

   }

   if (!html.IsEmpty() &&

       java::Clipboard::SetHTML(java::GeckoAppShell::GetApplicationContext(),

     return NS_OK;

   }

   if (!text.IsEmpty() &&

       java::Clipboard::SetText(java::GeckoAppShell::GetApplicationContext(),

     return NS_OK;

   }