/*
    * Copyright (c) 2002-2026 Gargoyle Software Inc.
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    * https://www.apache.org/licenses/LICENSE-2.0
    *
    * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.htmlunit;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.Serializable;
  import java.net.InetAddress;
  import java.net.URL;
  import java.security.KeyStore;
  import java.security.KeyStoreException;
  import java.security.NoSuchAlgorithmException;
  import java.security.cert.CertificateException;
  
  import javax.net.ssl.SSLContext;
  
  import org.apache.commons.io.FileUtils;
  
  /**
   * Configuration options for {@link WebClient} instances.
   * This class provides fine-grained control over client behavior including:
   * <ul>
   *   <li>JavaScript and CSS processing</li>
   *   <li>SSL/TLS configuration and certificates</li>
   *   <li>HTTP timeouts and proxy settings</li>
   *   <li>Memory management and temporary file handling</li>
   *   <li>WebSocket and geolocation support</li>
   * </ul>
   *
   * <p>All options have sensible defaults and can be modified independently.</p>
   *
   * @author Ahmed Ashour
   * @author Marc Guillemot
   * @author Madis Pärn
   * @author Ronald Brill
   */
  @SuppressWarnings("PMD.TooManyFields")
  public class WebClientOptions implements Serializable {
  
      /** 1920. */
      private static final int DEFAULT_SCRREN_WIDTH = 1920;
      /** 1080. */
      private static final int DEFAULT_SCRREN_HEIGHT = 1080;
  
      private boolean javaScriptEnabled_ = true;
      private boolean cssEnabled_ = true;
      private boolean printContentOnFailingStatusCode_ = true;
      private boolean throwExceptionOnFailingStatusCode_ = true;
      private boolean throwExceptionOnScriptError_ = true;
      private boolean popupBlockerEnabled_;
      private boolean isRedirectEnabled_ = true;
      // strange value 72 used to be backward compatible with 4.14.0
      private int pageRefreshLimit_ = 72;
      private File tempFileDirectory_;
  
      private transient KeyStore sslClientCertificateStore_;
      private char[] sslClientCertificatePassword_;
      private transient KeyStore sslTrustStore_;
      private String[] sslClientProtocols_;
      private String[] sslClientCipherSuites_;
  
      private transient SSLContext sslContext_;
      private boolean useInsecureSSL_; // default is secure SSL
      private String sslInsecureProtocol_;
  
      private boolean doNotTrackEnabled_;
      private String homePage_ = "https://www.htmlunit.org/";
      private ProxyConfig proxyConfig_;
      private int timeout_ = 90_000; // like Firefox 16 default's value for network.http.connection-timeout
      private long connectionTimeToLive_ = -1; // HttpClient default
  
      private boolean fileProtocolForXMLHttpRequestsAllowed_;
  
      private int maxInMemory_ = 500 * 1024;
      private int historySizeLimit_ = 50;
      private int historyPageCacheLimit_ = Integer.MAX_VALUE;
      private InetAddress localAddress_;
      private boolean downloadImages_;
      private int screenWidth_ = DEFAULT_SCRREN_WIDTH;
      private int screenHeight_ = DEFAULT_SCRREN_HEIGHT;
  
      private boolean geolocationEnabled_;
      private Geolocation geolocation_;
  
      private int nekoReaderBufferSize_ = -1;
  
     private boolean webSocketEnabled_ = true;
     private int webSocketMaxTextMessageSize_ = -1;
     private int webSocketMaxBinaryMessageSize_ = -1;
 
     private boolean isFetchPolyfillEnabled_;
 
     /**
      * Sets the SSLContext; if this is set it is used and some other settings are
      * ignored (protocol, keyStore, keyStorePassword, trustStore,
      * sslClientCertificateStore, sslClientCertificatePassword).
      * <p>
      * This property is transient (because SSLContext is not serializable)
      * </p>
      *
      * @param sslContext the SSLContext, {@code null} to use for default value
      */
     public void setSSLContext(final SSLContext sslContext) {
         sslContext_ = sslContext;
     }
 
     /**
      * Gets the SSLContext; if this is set this is used and some other settings are
      * ignored (protocol, keyStore, keyStorePassword, trustStore,
      * sslClientCertificateStore, sslClientCertificatePassword).
      * <p>
      * This property is transient (because SSLContext is not serializable)
      * </p>
      *
      * @return the SSLContext
      */
     public SSLContext getSSLContext() {
         return sslContext_;
     }
 
     /**
      * If set to {@code true}, the client will accept connections to any host,
      * regardless of whether they have valid certificates or not. This is especially
      * useful when you are trying to connect to a server with expired or corrupt
      * certificates.
      *
      * @param useInsecureSSL whether or not to use insecure SSL
      */
     public void setUseInsecureSSL(final boolean useInsecureSSL) {
         useInsecureSSL_ = useInsecureSSL;
     }
 
     /**
      * Indicates if insecure SSL should be used.
      *
      * @return {@code true} if insecure SSL should be used. Default is
      *         {@code false}.
      */
     public boolean isUseInsecureSSL() {
         return useInsecureSSL_;
     }
 
     /**
      * Sets whether or not redirections will be followed automatically on receipt of
      * a redirect status code from the server.
      *
      * @param enabled true to enable automatic redirection
      */
     public void setRedirectEnabled(final boolean enabled) {
         isRedirectEnabled_ = enabled;
     }
 
     /**
      * Sets the redirect limit for page refresh operations using HTTP refresh
      * headers or meta tags. This prevents infinite refresh loops by limiting the
      * number of consecutive refreshes allowed. Set to -1 to allow unlimited
      * refreshes.
      *
      * <p>
      * Note: The {@link NiceRefreshHandler} and {@link ImmediateRefreshHandler} have
      * additional loop protection that may trigger before this limit.
      * </p>
      *
      * @param pageRefreshLimit the maximum number of refresh loops, or -1 for
      *                         unlimited
      */
     public void setPageRefreshLimit(final int pageRefreshLimit) {
         pageRefreshLimit_ = pageRefreshLimit;
     }
 
     /**
      * Returns the directory to be used for storing the response content in a
      * temporary file see {@link #getMaxInMemory()}.
      *
      * @return the directory to be used for storing temp files or null to use the
      *         system default
      */
     public File getTempFileDirectory() {
         return tempFileDirectory_;
     }
 
     /**
      * Sets the directory to be used for storing response content in temporary
      * files. See {@link #setMaxInMemory(int)} for when temporary files are created.
      * If the directory doesn't exist, it will be created automatically.
      *
      * @param tempFileDirectory the directory to use, or {@code null} for system
      *                          default
      * @throws IOException              if directory creation fails
      * @throws IllegalArgumentException if the path points to an existing file
      */
     public void setTempFileDirectory(final File tempFileDirectory) throws IOException {
         if (tempFileDirectory != null) {
             if (tempFileDirectory.exists() && !tempFileDirectory.isDirectory()) {
                 throw new IllegalArgumentException("The provided file '" + tempFileDirectory
                         + "' points to an already existing file");
             }
 
             if (!tempFileDirectory.exists()) {
                 FileUtils.forceMkdir(tempFileDirectory);
             }
         }
         tempFileDirectory_ = tempFileDirectory;
     }
 
     /**
      * Returns whether or not redirections will be followed automatically on receipt
      * of a redirect status code from the server.
      *
      * @return true if automatic redirection is enabled
      */
     public boolean isRedirectEnabled() {
         return isRedirectEnabled_;
     }
 
     /**
      * Returns the limit to be used when a page refreshes itself by using a http
      * refresh header or meta tag. Negative values are interpreted as endless
      * refresh support.
      *
      * @return pageRefreshLimit the number of refresh loops before throwing an
      *         exception
      */
     public int getPageRefreshLimit() {
         return pageRefreshLimit_;
     }
 
     /**
      * Sets the SSL client certificate {@link KeyStore} to use.
      * <p>
      * If the web server requires Renegotiation, you have to set system property
      * "sun.security.ssl.allowUnsafeRenegotiation" to true, as hinted in <a href=
      * "http://www.oracle.com/technetwork/java/javase/documentation/tlsreadme2-176330.html">
      * TLS Renegotiation Issue</a>.
      * </p>
      * <p>
      * In some cases the impl seems to pick old certificates from the
      * {@link KeyStore}. To avoid that, wrap your {@link KeyStore} inside your own
      * {@link KeyStore} impl and filter out outdated certificates.
      * </p>
      * <p>
      * This property is transient (because KeyStore is not serializable)
      * </p>
      *
      * @param keyStore         {@link KeyStore} to use
      * @param keyStorePassword the keystore password
      */
     public void setSSLClientCertificateKeyStore(final KeyStore keyStore, final char[] keyStorePassword) {
         sslClientCertificateStore_ = keyStore;
         sslClientCertificatePassword_ = keyStorePassword;
     }
 
     /**
      * Sets the SSL client certificate to use. The needed parameters are used to
      * construct a {@link java.security.KeyStore}.
      * <p>
      * If the web server requires Renegotiation, you have to set system property
      * "sun.security.ssl.allowUnsafeRenegotiation" to true, as hinted in <a href=
      * "http://www.oracle.com/technetwork/java/javase/documentation/tlsreadme2-176330.html">
      * TLS Renegotiation Issue</a>.
      * </p>
      * <p>
      * This property is transient (because KeyStore is not serializable)
      * </p>
      *
      * @param keyStoreUrl      the URL which locates the certificate
      *                         {@link KeyStore}
      * @param keyStorePassword the certificate {@link KeyStore} password
      * @param keyStoreType     the type of certificate {@link KeyStore}, usually
      *                         {@code jks} or {@code pkcs12}
      *
      */
     public void setSSLClientCertificateKeyStore(final URL keyStoreUrl, final String keyStorePassword,
             final String keyStoreType) {
         try (InputStream is = keyStoreUrl.openStream()) {
             sslClientCertificateStore_ = getKeyStore(is, keyStorePassword, keyStoreType);
             sslClientCertificatePassword_ = keyStorePassword == null ? null : keyStorePassword.toCharArray();
         }
         catch (final Exception e) {
             throw new RuntimeException(e);
         }
     }
 
     /**
      * Sets the SSL client certificate {@link KeyStore} to use. The parameters are
      * used to construct the {@link KeyStore}.
      * <p>
      * If the web server requires Renegotiation, you have to set system property
      * "sun.security.ssl.allowUnsafeRenegotiation" to true, as hinted in <a href=
      * "http://www.oracle.com/technetwork/java/javase/documentation/tlsreadme2-176330.html">
      * TLS Renegotiation Issue</a>.
      * </p>
      * <p>
      * In some cases the impl seems to pick old certificates from the
      * {@link KeyStore}. To avoid that, wrap your {@link KeyStore} inside your own
      * {@link KeyStore} impl and filter out outdated certificates. Provide the
      * {@link KeyStore} to the options instead of the input stream.
      * </p>
      *
      * @param keyStoreInputStream the input stream which represents the
      *                            {@link KeyStore} holding the certificates
      * @param keyStorePassword    the {@link KeyStore} password
      * @param keyStoreType        the type of {@link KeyStore}, usually {@code jks}
      *                            or {@code pkcs12}
      */
     public void setSSLClientCertificateKeyStore(final InputStream keyStoreInputStream, final String keyStorePassword,
             final String keyStoreType) {
         try {
             setSSLClientCertificateKeyStore(getKeyStore(keyStoreInputStream, keyStorePassword, keyStoreType),
                     keyStorePassword.toCharArray());
         }
         catch (final Exception e) {
             throw new RuntimeException(e);
         }
     }
 
     /**
      * Gets the SSLClientCertificateStore.
      * <p>
      * This property is transient (because KeyStore is not serializable)
      * </p>
      *
      * @return the KeyStore for use on SSL connections
      */
     public KeyStore getSSLClientCertificateStore() {
         return sslClientCertificateStore_;
     }
 
     /**
      * Gets the SSLClientCertificatePassword.
      *
      * @return the password
      */
     public char[] getSSLClientCertificatePassword() {
         return sslClientCertificatePassword_;
     }
 
     /**
      * Gets the protocol versions enabled for use on SSL connections.
      *
      * @return the protocol versions enabled for use on SSL connections
      * @see #setSSLClientProtocols(String...)
      */
     public String[] getSSLClientProtocols() {
         return sslClientProtocols_;
     }
 
     /**
      * Sets the protocol versions enabled for use on SSL connections, {@code null}
      * to use default ones.
      *
      * @param sslClientProtocols the protocol versions
      * @see javax.net.ssl.SSLSocket#setEnabledProtocols(String[])
      * @see #getSSLClientProtocols()
      * @see #setSSLClientCipherSuites(String...)
      * @see #setUseInsecureSSL(boolean)
      */
     public void setSSLClientProtocols(final String... sslClientProtocols) {
         sslClientProtocols_ = sslClientProtocols;
     }
 
     /**
      * Gets the cipher suites enabled for use on SSL connections.
      *
      * @return the cipher suites enabled for use on SSL connections
      * @see #setSSLClientCipherSuites(String...)
      */
     public String[] getSSLClientCipherSuites() {
         return sslClientCipherSuites_;
     }
 
     /**
      * Sets the cipher suites enabled for use on SSL connections, {@code null} to
      * use default ones.
      *
      * @param sslClientCipherSuites the cipher suites
      * @see javax.net.ssl.SSLSocket#setEnabledCipherSuites(String[])
      * @see #getSSLClientCipherSuites()
      */
     public void setSSLClientCipherSuites(final String... sslClientCipherSuites) {
         sslClientCipherSuites_ = sslClientCipherSuites;
     }
 
     /**
      * Enables/disables JavaScript support. By default, this property is enabled.
      *
      * @param enabled {@code true} to enable JavaScript support
      */
     public void setJavaScriptEnabled(final boolean enabled) {
         javaScriptEnabled_ = enabled;
     }
 
     /**
      * Returns {@code true} if JavaScript is enabled and the script engine was
      * loaded successfully.
      *
      * @return {@code true} if JavaScript is enabled
      */
     public boolean isJavaScriptEnabled() {
         return javaScriptEnabled_;
     }
 
     /**
      * Enables/disables CSS support. By default, this property is enabled. If
      * disabled HtmlUnit will not download the linked css files and also not
      * triggered the associated onload/onerror events.
      *
      * @param enabled {@code true} to enable CSS support
      */
     public void setCssEnabled(final boolean enabled) {
         cssEnabled_ = enabled;
     }
 
     /**
      * Returns {@code true} if CSS is enabled.
      *
      * @return {@code true} if CSS is enabled
      */
     public boolean isCssEnabled() {
         return cssEnabled_;
     }
 
     /**
      * Enable/disable the popup window blocker. By default, the popup blocker is
      * disabled, and popup windows are allowed. When set to {@code true},
      * <code>window.open()</code> has no effect and returns {@code null}.
      *
      * @param enabled {@code true} to enable the popup window blocker
      */
     public void setPopupBlockerEnabled(final boolean enabled) {
         popupBlockerEnabled_ = enabled;
     }
 
     /**
      * Returns {@code true} if the popup window blocker is enabled.
      *
      * @return {@code true} if the popup window blocker is enabled
      */
     public boolean isPopupBlockerEnabled() {
         return popupBlockerEnabled_;
     }
 
     /**
      * Enables/disables "Do Not Track" support. By default, this property is
      * disabled.
      *
      * @param enabled {@code true} to enable "Do Not Track" support
      */
     public void setDoNotTrackEnabled(final boolean enabled) {
         doNotTrackEnabled_ = enabled;
     }
 
     /**
      * Returns {@code true} if "Do Not Track" is enabled.
      *
      * @return {@code true} if "Do Not Track" is enabled
      */
     public boolean isDoNotTrackEnabled() {
         return doNotTrackEnabled_;
     }
 
     /**
      * Specify whether or not the content of the resulting document will be printed
      * to the console in the event of a failing response code. Successful response
      * codes are in the range 200-299. The default is true.
      *
      * @param enabled True to enable this feature
      */
     public void setPrintContentOnFailingStatusCode(final boolean enabled) {
         printContentOnFailingStatusCode_ = enabled;
     }
 
     /**
      * Returns {@code true} if the content of the resulting document will be printed
      * to the console in the event of a failing response code.
      *
      * @return {@code true} if the content of the resulting document will be printed
      *         to the console in the event of a failing response code
      * @see #setPrintContentOnFailingStatusCode
      */
     public boolean isPrintContentOnFailingStatusCode() {
         return printContentOnFailingStatusCode_;
     }
 
     /**
      * Specify whether or not an exception will be thrown in the event of a failing
      * status code. Successful status codes are in the range 200-299. The default is
      * true.
      *
      * @param enabled {@code true} to enable this feature
      */
     public void setThrowExceptionOnFailingStatusCode(final boolean enabled) {
         throwExceptionOnFailingStatusCode_ = enabled;
     }
 
     /**
      * Returns {@code true} if an exception will be thrown in the event of a failing
      * response code.
      *
      * @return {@code true} if an exception will be thrown in the event of a failing
      *         response code
      * @see #setThrowExceptionOnFailingStatusCode
      */
     public boolean isThrowExceptionOnFailingStatusCode() {
         return throwExceptionOnFailingStatusCode_;
     }
 
     /**
      * Indicates if an exception should be thrown when a script execution fails (the
      * default) or if it should be caught and just logged to allow page execution to
      * continue.
      *
      * @return {@code true} if an exception is thrown on script error (the default)
      */
     public boolean isThrowExceptionOnScriptError() {
         return throwExceptionOnScriptError_;
     }
 
     /**
      * Changes the behavior of this webclient when a script error occurs.
      *
      * @param enabled indicates if exception should be thrown or not
      */
     public void setThrowExceptionOnScriptError(final boolean enabled) {
         throwExceptionOnScriptError_ = enabled;
     }
 
     /**
      * Returns the client's current homepage.
      *
      * @return the client's current homepage
      */
     public String getHomePage() {
         return homePage_;
     }
 
     /**
      * Sets the client's homepage.
      *
      * @param homePage the new homepage URL
      */
     public void setHomePage(final String homePage) {
         homePage_ = homePage;
     }
 
     /**
      * Returns the proxy configuration for this client.
      *
      * @return the proxy configuration for this client
      */
     public ProxyConfig getProxyConfig() {
         return proxyConfig_;
     }
 
     /**
      * Sets the proxy configuration for this client.
      *
      * @param proxyConfig the proxy configuration for this client
      */
     public void setProxyConfig(final ProxyConfig proxyConfig) {
         WebAssert.notNull("proxyConfig", proxyConfig);
         proxyConfig_ = proxyConfig;
     }
 
     /**
      * Gets the timeout value for the {@link WebConnection}. The default timeout is
      * 90 seconds.
      *
      * @return the timeout value in milliseconds
      * @see #setTimeout(int)
      * @see #setConnectionTimeToLive(long)
      */
     public int getTimeout() {
         return timeout_;
     }
 
     /**
      * <p>
      * Sets the timeout of the {@link WebConnection}. Set to zero for an infinite
      * wait.
      * </p>
      *
      * <p>
      * Note: The timeout is used twice. The first is for making the socket
      * connection, the second is for data retrieval. If the time is critical you
      * must allow for twice the time specified here.
      * </p>
      *
      * @param timeout the value of the timeout in milliseconds
      */
     public void setTimeout(final int timeout) {
         timeout_ = timeout;
     }
 
     /**
      * Gets the connTimeToLive value for the HttpClient connection pool.
      *
      * @return the timeout value in milliseconds
      */
     public long getConnectionTimeToLive() {
         return connectionTimeToLive_;
     }
 
     /**
      * Sets the connection time-to-live for the HttpClient connection pool. This is
      * useful when working with web pages behind DNS-based load balancers where IP
      * addresses may change frequently.
      *
      * @param connectionTimeToLive the timeout in milliseconds, or -1 to disable
      *                             (default)
      */
     public void setConnectionTimeToLive(final long connectionTimeToLive) {
         connectionTimeToLive_ = connectionTimeToLive;
     }
 
     /**
      * Sets the SSL protocol, used only when {@link #setUseInsecureSSL(boolean)} is
      * set to {@code true}.
      *
      * @param sslInsecureProtocol the SSL protocol for insecure SSL connections,
      *                            {@code null} to use for default value
      */
     public void setSSLInsecureProtocol(final String sslInsecureProtocol) {
         sslInsecureProtocol_ = sslInsecureProtocol;
     }
 
     /**
      * Gets the SSL protocol, to be used only when
      * {@link #setUseInsecureSSL(boolean)} is set to {@code true}.
      *
      * @return the SSL protocol for insecure SSL connections
      */
     public String getSSLInsecureProtocol() {
         return sslInsecureProtocol_;
     }
 
     /**
      * Sets the SSL server certificate trust store. All server certificates will be
      * validated against this trust store.
      * <p>
      * This property is transient (because KeyStore is not serializable)
      * </p>
      * <p>
      * The needed parameters are used to construct a {@link java.security.KeyStore}.
      * </p>
      *
      * @param sslTrustStoreUrl      the URL which locates the trust store
      * @param sslTrustStorePassword the trust store password
      * @param sslTrustStoreType     the type of trust store, usually {@code jks} or
      *                              {@code pkcs12}
      */
     public void setSSLTrustStore(final URL sslTrustStoreUrl, final String sslTrustStorePassword,
             final String sslTrustStoreType) {
         try (InputStream is = sslTrustStoreUrl.openStream()) {
             sslTrustStore_ = getKeyStore(is, sslTrustStorePassword, sslTrustStoreType);
         }
         catch (final Exception e) {
             throw new RuntimeException(e);
         }
     }
 
     void setSSLTrustStore(final KeyStore keyStore) {
         sslTrustStore_ = keyStore;
     }
 
     /**
      * Gets the SSL TrustStore.
      * <p>
      * This property is transient (because KeyStore is not serializable)
      * </p>
      *
      * @return the SSL TrustStore for insecure SSL connections
      */
     public KeyStore getSSLTrustStore() {
         return sslTrustStore_;
     }
 
     private static KeyStore getKeyStore(final InputStream inputStream, final String keystorePassword,
             final String keystoreType)
             throws IOException, KeyStoreException, NoSuchAlgorithmException, CertificateException {
         if (inputStream == null) {
             return null;
         }
 
         final KeyStore keyStore = KeyStore.getInstance(keystoreType);
         final char[] passwordChars = keystorePassword == null ? null : keystorePassword.toCharArray();
         keyStore.load(inputStream, passwordChars);
         return keyStore;
     }
 
     /**
      * Returns the maximum bytes stored in memory before content is saved to
      * temporary files. When response content exceeds this limit, it will be written
      * to a temporary file in the directory specified by
      * {@link #getTempFileDirectory()}.
      *
      * @return the maximum bytes in memory (default: 500 * 1024)
      * @see #setMaxInMemory(int)
      * @see #setTempFileDirectory(File)
      */
     public int getMaxInMemory() {
         return maxInMemory_;
     }
 
     /**
      * Sets the maximum bytes to have in memory, after which the content is saved to
      * a temporary file. Set this to zero or -1 to deactivate the saving at all.
      *
      * @param maxInMemory maximum bytes in memory
      */
     public void setMaxInMemory(final int maxInMemory) {
         maxInMemory_ = maxInMemory;
     }
 
     /**
      * Returns the maximum number of {@link Page pages} kept in
      * {@link WebWindow#getHistory()}.
      *
      * @return the maximum number of pages in history
      */
     public int getHistorySizeLimit() {
         return historySizeLimit_;
     }
 
     /**
      * Sets the History size limit. HtmlUnit uses SoftReferences&lt;Page&gt; for
      * storing the pages that are part of the history. If you like to fine tune this
      * you can use {@link #setHistoryPageCacheLimit(int)} to limit the number of
      * page references stored by the history.
      *
      * @param historySizeLimit maximum number of pages in history
      */
     public void setHistorySizeLimit(final int historySizeLimit) {
         historySizeLimit_ = historySizeLimit;
     }
 
     /**
      * Returns the maximum number of {@link Page pages} to cache in history.
      *
      * @return the maximum number of pages to cache in history
      */
     public int getHistoryPageCacheLimit() {
         return historyPageCacheLimit_;
     }
 
     /**
      * Sets the maximum number of {@link Page pages} to cache in history. If this
      * value is smaller than the {{@link #getHistorySizeLimit()} than HtmlUnit will
      * only use soft references for the first historyPageCacheLimit entries in the
      * history. For older entries only the url is saved; the page will be
      * (re)retrieved on demand.
      *
      * @param historyPageCacheLimit maximum number of pages to cache in history
      *                              default is Integer.MAX_VALUE; negative values
      *                              are having the same effect as setting this to
      *                              zero.
      */
     public void setHistoryPageCacheLimit(final int historyPageCacheLimit) {
         historyPageCacheLimit_ = historyPageCacheLimit;
     }
 
     /**
      * Returns local address to be used for request execution.
      * <p>
      * On machines with multiple network interfaces, this parameter can be used to
      * select the network interface from which the connection originates.
      * </p>
      * <p>
      * Default: {@code null}
      * </p>
      *
      * @return the local address
      */
     public InetAddress getLocalAddress() {
         return localAddress_;
     }
 
     /**
      * Sets the local network interface address for outgoing HTTP requests. Useful
      * on multi-homed machines to control which network interface is used.
      *
      * @param localAddress the local IP address to bind to, or {@code null} for
      *                     automatic selection
      */
     public void setLocalAddress(final InetAddress localAddress) {
         localAddress_ = localAddress;
     }
 
     /**
      * Sets whether to automatically download images by default, or not.
      *
      * @param downloadImages whether to automatically download images by default, or
      *                       not
      */
     public void setDownloadImages(final boolean downloadImages) {
         downloadImages_ = downloadImages;
     }
 
     /**
      * Returns whether to automatically download images by default, or not.
      *
      * @return whether to automatically download images by default, or not.
      */
     public boolean isDownloadImages() {
         return downloadImages_;
     }
 
     /**
      * Sets the screen width. This value is used by JavaScript's screen.width
      * property.
      *
      * @param screenWidth the screen width in pixels (must be positive)
      */
     public void setScreenWidth(final int screenWidth) {
         screenWidth_ = screenWidth;
     }
 
     /**
      * Returns the screen width.
      *
      * @return the screen width
      */
     public int getScreenWidth() {
         return screenWidth_;
     }
 
     /**
      * Sets the screen height.
      *
      * @param screenHeight the screen height
      */
     public void setScreenHeight(final int screenHeight) {
         screenHeight_ = screenHeight;
     }
 
     /**
      * Returns the screen height.
      *
      * @return the screen height
      */
     public int getScreenHeight() {
         return screenHeight_;
     }
 
     /**
      * Returns the Neko HTML parser reader buffer size. This controls the internal
      * buffer size used by the NekoHTML parser for reading HTML content. Larger
      * buffers can improve performance for large documents but consume more memory.
      *
      * @return the buffer size in bytes, or -1 for parser default
      */
     public int getNekoReaderBufferSize() {
         return nekoReaderBufferSize_;
     }
 
     /**
      * Sets the Neko HTML parser reader buffer size. A larger buffer size can
      * improve parsing performance for large HTML documents but will consume more
      * memory. Set to -1 to use the parser's default buffer size.
      *
      * @param nekoReaderBufferSize the buffer size in bytes, or -1 for default
      */
     public void setNekoReaderBufferSize(final int nekoReaderBufferSize) {
         nekoReaderBufferSize_ = nekoReaderBufferSize;
     }
 
     /**
      * Enables/disables WebSocket support. By default, this property is enabled.
      *
      * @param enabled {@code true} to enable WebSocket support
      */
     public void setWebSocketEnabled(final boolean enabled) {
         webSocketEnabled_ = enabled;
     }
 
     /**
      * Returns {@code true} if WebSockets are enabled.
      *
      * @return {@code true} if WebSockets are enabled
      */
     public boolean isWebSocketEnabled() {
         return webSocketEnabled_;
     }
 
     /**
      * Returns the maximum size in bytes for WebSocket text messages. Set to -1 to
      * use the default.
      *
      * @return the maximum text message size in bytes, or -1 for default
      */
     public int getWebSocketMaxTextMessageSize() {
         return webSocketMaxTextMessageSize_;
     }
 
     /**
      * Sets the maximum size in bytes for WebSocket text messages. This limit
      * applies to individual text frames received by the WebSocket.
      *
      * @param webSocketMaxTextMessageSize the maximum size in bytes, or -1 for
      *                                    default
      */
     public void setWebSocketMaxTextMessageSize(final int webSocketMaxTextMessageSize) {
         webSocketMaxTextMessageSize_ = webSocketMaxTextMessageSize;
     }
 
     /**
      * Returns the maximum size in bytes for WebSocket binary messages. Set to -1 to
      * use the default.
      *
      * @return the maximum binary message size in bytes, or -1 for default
      */
     public int getWebSocketMaxBinaryMessageSize() {
         return webSocketMaxBinaryMessageSize_;
     }
 
     /**
      * Sets the maximum size in bytes for WebSocket binary messages. This limit
      * applies to individual binary frames received by the WebSocket.
      *
      * @param webSocketMaxBinaryMessageSize the maximum size in bytes, or -1 for
      *                                      default
      */
     public void setWebSocketMaxBinaryMessageSize(final int webSocketMaxBinaryMessageSize) {
         webSocketMaxBinaryMessageSize_ = webSocketMaxBinaryMessageSize;
     }
 
     /**
      * Sets whether or not fetch polyfill should be used.
      *
      * @param enabled true to enable fetch polyfill
      */
     public void setFetchPolyfillEnabled(final boolean enabled) {
         isFetchPolyfillEnabled_ = enabled;
     }
 
     /**
      * Returns true if the fetch api polyfill is enabled.
      *
      * @return true if the fetch api polyfill is enabled
      */
     public boolean isFetchPolyfillEnabled() {
         return isFetchPolyfillEnabled_;
     }
 
     /**
      * Enables/disables Geolocation support. By default, this property is disabled.
      *
      * @param enabled {@code true} to enable Geolocation support
      */
     public void setGeolocationEnabled(final boolean enabled) {
         geolocationEnabled_ = enabled;
     }
 
     /**
      * Returns {@code true} if Geolocation is enabled.
      *
      * @return {@code true} if Geolocation is enabled
      */
     public boolean isGeolocationEnabled() {
         return geolocationEnabled_;
     }
 
     /**
      * Returns the {@link Geolocation}.
      *
      * @return the {@link Geolocation}
      */
     public Geolocation getGeolocation() {
         return geolocation_;
     }
 
     /**
      * Sets the {@link Geolocation} to be used.
      *
      * @param geolocation the new location or null
      */
     public void setGeolocation(final Geolocation geolocation) {
         geolocation_ = geolocation;
     }
 
     /**
      * Support class for Geolocation.
      */
     public static class Geolocation implements Serializable {
         private final double accuracy_;
         private final double latitude_;
         private final double longitude_;
         private final Double altitude_;
         private final Double altitudeAccuracy_;
         private final Double heading_;
         private final Double speed_;
 
         /**
          * Ctor.
          *
          * @param latitude         the latitude coordinate in decimal degrees
          * @param longitude        the longitude coordinate in decimal degrees
          * @param accuracy         the accuracy of the position in meters
          * @param altitude         the altitude in meters above sea level, or null if
          *                         unavailable
          * @param altitudeAccuracy the accuracy of the altitude in meters, or null if
          *                         unavailable
          * @param heading          the direction of travel in degrees (0-359), or null
          *                         if unavailable
          * @param speed            the current speed in meters per second, or null if
          *                         unavailable
          */
         public Geolocation(final double latitude, final double longitude, final double accuracy, final Double altitude,
                 final Double altitudeAccuracy, final Double heading, final Double speed) {
             latitude_ = latitude;
             longitude_ = longitude;
             accuracy_ = accuracy;
             altitude_ = altitude;
             altitudeAccuracy_ = altitudeAccuracy;
             heading_ = heading;
             speed_ = speed;
         }
 
         /**
          * Returns the accuracy.
          *
          * @return the accuracy
          */
         public double getAccuracy() {
             return accuracy_;
         }
 
         /**
          * Returns the latitude.
          *
          * @return the latitude
          */
         public double getLatitude() {
             return latitude_;
         }
 
         /**
          * Returns the longitude.
          *
          * @return the longitude
          */
         public double getLongitude() {
             return longitude_;
         }
 
         /**
          * Returns the longitude.
          *
          * @return the longitude
          */
         public Double getAltitude() {
             return altitude_;
         }
 
         /**
          * Returns the altitudeAccuracy.
          *
          * @return the altitudeAccuracy
          */
         public Double getAltitudeAccuracy() {
             return altitudeAccuracy_;
         }
 
         /**
          * Returns the heading.
          *
          * @return the heading
          */
         public Double getHeading() {
             return heading_;
         }
 
         /**
          * Returns the speed.
          *
          * @return the speed
          */
         public Double getSpeed() {
             return speed_;
         }
     }
 
     /**
      * If set to {@code true}, the client will accept XMLHttpRequests to URL's using
      * the 'file' protocol. Allowing this introduces security problems and is
      * therefore not allowed by current browsers. But some browsers have special
      * settings to open this door; therefore we have this option also.
      *
      * <p>
      * <b>Security Warning:</b> Enabling this feature may expose local files to web
      * content, which can be a serious security risk.
      * </p>
      *
      * @param fileProtocolForXMLHttpRequestsAllowed whether or not allow (local)
      *                                              file access
      */
     public void setFileProtocolForXMLHttpRequestsAllowed(final boolean fileProtocolForXMLHttpRequestsAllowed) {
         fileProtocolForXMLHttpRequestsAllowed_ = fileProtocolForXMLHttpRequestsAllowed;
     }
 
     /**
      * Indicates if the client will accept XMLHttpRequests to URL's using the 'file'
      * protocol.
      *
      * @return {@code true} if access to local files is allowed.
      */
     public boolean isFileProtocolForXMLHttpRequestsAllowed() {
         return fileProtocolForXMLHttpRequestsAllowed_;
     }
 }