Info Call to Socket API

Description

List of all calls to Server Socket API.

Recommendation

This entry is informative, no recommendations applicable.

Technical details

Method com.bumptech.glide.load.model.GlideUrl.getSafeUrl() calling method java.net.URL.<init>()


    private java.net.URL getSafeUrl()
    {
        if (this.safeUrl == null) {
            this.safeUrl = new java.net.URL(this.getSafeStringUrl());
        }
        return this.safeUrl;
    }

Method com.github.nkzawa.socketio.client.Url.extractId() calling method java.net.URL.<init>()


    public static String extractId(String p1)
    {
        return com.github.nkzawa.socketio.client.Url.extractId(new java.net.URL(p1));
    }

Method com.github.nkzawa.socketio.client.Url.parse() calling method java.net.URL.<init>()


    public static java.net.URL parse(java.net.URI p11)
    {
        String v0 = p11.getScheme();
        if ((v0 == null) || (!v0.matches("^https?|wss?$"))) {
            v0 = "https";
        }
        int v1_0 = p11.getPort();
        if (v1_0 == -1) {
            if (!com.github.nkzawa.socketio.client.Url.PATTERN_HTTP.matcher(v0).matches()) {
                if (com.github.nkzawa.socketio.client.Url.PATTERN_HTTPS.matcher(v0).matches()) {
                    v1_0 = 443;
                }
            } else {
                v1_0 = 80;
            }
        }
        String v3_6 = p11.getRawPath();
        if ((v3_6 == null) || (v3_6.length() == 0)) {
            v3_6 = "/";
        }
        String v4_1 = p11.getRawUserInfo();
        String v5 = p11.getRawQuery();
        String v6 = p11.getRawFragment();
        try {
            String v9_1;
            StringBuilder v8_1 = new StringBuilder();
            v8_1.append(v0);
            v8_1.append("://");
        } catch (String v2_10) {
            throw new RuntimeException(v2_10);
        }
        if (v4_1 == null) {
            v9_1 = "";
        } else {
            String v9_3 = new StringBuilder();
            v9_3.append(v4_1);
            v9_3.append("@");
            v9_1 = v9_3.toString();
        }
        String v2_1;
        v8_1.append(v9_1);
        v8_1.append(p11.getHost());
        if (v1_0 == -1) {
            v2_1 = "";
        } else {
            String v2_3 = new StringBuilder();
            v2_3.append(":");
            v2_3.append(v1_0);
            v2_1 = v2_3.toString();
        }
        String v2_4;
        v8_1.append(v2_1);
        v8_1.append(v3_6);
        if (v5 == null) {
            v2_4 = "";
        } else {
            String v2_6 = new StringBuilder();
            v2_6.append("?");
            v2_6.append(v5);
            v2_4 = v2_6.toString();
        }
        String v2_7;
        v8_1.append(v2_4);
        if (v6 == null) {
            v2_7 = "";
        } else {
            String v2_9 = new StringBuilder();
            v2_9.append("#");
            v2_9.append(v6);
            v2_7 = v2_9.toString();
        }
        v8_1.append(v2_7);
        return new java.net.URL(v8_1.toString());
    }

Method com.microsoft.aad.adal.Discovery.buildQueryString() calling method java.net.URL.<init>()


    private java.net.URL buildQueryString(String p5, String p6)
    {
        android.net.Uri$Builder v0_1 = new android.net.Uri$Builder();
        v0_1.scheme("https").authority(p5);
        v0_1.appendEncodedPath("common/discovery/instance").appendQueryParameter("api-version", "1.1").appendQueryParameter("authorization_endpoint", p6);
        return new java.net.URL(v0_1.build().toString());
    }

Method com.microsoft.aad.adal.Discovery.constructAuthorityUrl() calling method java.net.URL.<init>()


    static java.net.URL constructAuthorityUrl(java.net.URL p4, String p5)
    {
        return new java.net.URL(new android.net.Uri$Builder().scheme(p4.getProtocol()).authority(p5).appendPath(p4.getPath().replaceFirst("/", "")).build().toString());
    }

Method com.microsoft.aad.adal.StringExtensions.getUrl() calling method java.net.URL.<init>()


    static java.net.URL getUrl(String p7)
    {
        java.net.URL v1 = 0;
        try {
            v1 = new java.net.URL(p7);
        } catch (java.net.MalformedURLException v2_2) {
            String v3_2 = new StringBuilder();
            v3_2.append(com.microsoft.aad.adal.StringExtensions.TAG);
            v3_2.append(":getUrl");
            com.microsoft.aad.adal.Logger.e(v3_2.toString(), com.microsoft.aad.adal.ADALError.DEVELOPER_AUTHORITY_IS_NOT_VALID_URL.getDescription(), v2_2.getMessage(), com.microsoft.aad.adal.ADALError.DEVELOPER_AUTHORITY_IS_NOT_VALID_URL, v2_2);
        }
        return v1;
    }

Method com.microsoft.aad.adal.TokenCacheAccessor.constructAuthorityUrl() calling method java.net.URL.<init>()


    private String constructAuthorityUrl(String p3)
    {
        java.net.URL v0_1 = new java.net.URL(this.mAuthority);
        if (!v0_1.getHost().equalsIgnoreCase(p3)) {
            return com.microsoft.aad.adal.Discovery.constructAuthorityUrl(v0_1, p3).toString();
        } else {
            return this.mAuthority;
        }
    }

Method com.microsoft.aad.adal.TokenCacheAccessor.getInstanceDiscoveryMetadata() calling method java.net.URL.<init>()


    private com.microsoft.aad.adal.InstanceDiscoveryMetadata getInstanceDiscoveryMetadata()
    {
        return com.microsoft.aad.adal.AuthorityValidationMetadataCache.getCachedInstanceDiscoveryMetadata(new java.net.URL(this.mAuthority));
    }

Method com.microsoft.aad.adal.TokenCacheAccessor.updateCachedItemWithResult() calling method java.net.URL.<init>()


    void updateCachedItemWithResult(String p6, String p7, com.microsoft.aad.adal.AuthenticationResult p8, com.microsoft.aad.adal.TokenCacheItem p9)
    {
        if (p8 == null) {
            String v1_8 = new StringBuilder();
            v1_8.append(com.microsoft.aad.adal.TokenCacheAccessor.TAG);
            v1_8.append(":updateCachedItemWithResult");
            com.microsoft.aad.adal.Logger.v(v1_8.toString(), "AuthenticationResult is null, cannot update cache.");
            throw new IllegalArgumentException("result");
        } else {
            if (!com.microsoft.identity.common.adal.internal.util.StringExtensions.isNullOrBlank(p8.getAuthority())) {
                this.mAuthority = p8.getAuthority();
            }
            if (p8.getStatus() != com.microsoft.aad.adal.AuthenticationResult$AuthenticationStatus.Succeeded) {
                if ("invalid_grant".equalsIgnoreCase(p8.getErrorCode())) {
                    String v1_11 = new StringBuilder();
                    v1_11.append(com.microsoft.aad.adal.TokenCacheAccessor.TAG);
                    v1_11.append(":updateCachedItemWithResult");
                    com.microsoft.aad.adal.Logger.v(v1_11.toString(), "Received INVALID_GRANT error code, remove existing cache entry.");
                    this.removeTokenCacheItem(p9, p6);
                }
            } else {
                String v1_14 = new StringBuilder();
                v1_14.append(com.microsoft.aad.adal.TokenCacheAccessor.TAG);
                v1_14.append(":updateCachedItemWithResult");
                com.microsoft.aad.adal.Logger.v(v1_14.toString(), "Save returned AuthenticationResult into cache.");
                if ((p9 != null) && ((p9.getUserInfo() != null) && (p8.getUserInfo() == null))) {
                    p8.setUserInfo(p9.getUserInfo());
                    p8.setIdToken(p9.getRawIdToken());
                    p8.setTenantId(p9.getTenantId());
                }
                try {
                    if ((!this.mUseCommonCache) || (com.microsoft.aad.adal.UrlExtensions.isADFSAuthority(new java.net.URL(this.mAuthority)))) {
                        this.updateTokenCache(p6, p7, p8);
                    } else {
                        this.updateTokenCacheUsingCommonCache(p6, p7, p8);
                    }
                } catch (String v1_25) {
                    throw new com.microsoft.aad.adal.AuthenticationException(com.microsoft.aad.adal.ADALError.DEVELOPER_AUTHORITY_IS_NOT_VALID_URL, v1_25.getMessage(), v1_25);
                }
            }
            return;
        }
    }

Method com.microsoft.aad.adal.TokenCacheAccessor.updateTokenCache() calling method java.net.URL.<init>()


    void updateTokenCache(String p3, String p4, com.microsoft.aad.adal.AuthenticationResult p5)
    {
        if ((p5 != null) && (!com.microsoft.identity.common.adal.internal.util.StringExtensions.isNullOrBlank(p5.getAccessToken()))) {
            if ((!this.mUseCommonCache) || (com.microsoft.aad.adal.UrlExtensions.isADFSAuthority(new java.net.URL(this.mAuthority)))) {
                if (p5.getUserInfo() != null) {
                    if (!com.microsoft.identity.common.adal.internal.util.StringExtensions.isNullOrBlank(p5.getUserInfo().getDisplayableId())) {
                        this.setItemToCacheForUser(p3, p4, p5, p5.getUserInfo().getDisplayableId());
                    }
                    if (!com.microsoft.identity.common.adal.internal.util.StringExtensions.isNullOrBlank(p5.getUserInfo().getUserId())) {
                        this.setItemToCacheForUser(p3, p4, p5, p5.getUserInfo().getUserId());
                    }
                }
                this.setItemToCacheForUser(p3, p4, p5, 0);
                return;
            } else {
                this.updateTokenCacheUsingCommonCache(p3, p4, p5);
                return;
            }
        } else {
            return;
        }
    }

Method com.microsoft.aad.adal.TokenCacheAccessor.updateTokenCacheUsingCommonCache() calling method java.net.URL.<init>()


    void updateTokenCacheUsingCommonCache(String p8, String p9, com.microsoft.aad.adal.AuthenticationResult p10)
    {
        com.microsoft.identity.common.internal.providers.microsoft.azureactivedirectory.AzureActiveDirectory v0_1 = new com.microsoft.identity.common.internal.providers.microsoft.azureactivedirectory.AzureActiveDirectory();
        com.microsoft.identity.common.internal.providers.microsoft.azureactivedirectory.AzureActiveDirectoryTokenResponse v1 = com.microsoft.aad.adal.CoreAdapter.asAadTokenResponse(p10);
        com.microsoft.identity.common.internal.providers.microsoft.azureactivedirectory.AzureActiveDirectoryOAuth2Configuration v2_1 = new com.microsoft.identity.common.internal.providers.microsoft.azureactivedirectory.AzureActiveDirectoryOAuth2Configuration();
        v2_1.setAuthorityHostValidationEnabled(this.isValidateAuthorityHost());
        if (this.mAuthority != null) {
            v2_1.setAuthorityUrl(new java.net.URL(this.mAuthority));
        }
        com.microsoft.identity.common.internal.providers.microsoft.azureactivedirectory.AzureActiveDirectoryOAuth2Strategy v3_2 = v0_1.createOAuth2Strategy(v2_1);
        com.microsoft.identity.common.internal.providers.microsoft.azureactivedirectory.AzureActiveDirectoryAuthorizationRequest v4_2 = new com.microsoft.identity.common.internal.providers.microsoft.azureactivedirectory.AzureActiveDirectoryAuthorizationRequest();
        v4_2.setClientId(p9);
        v4_2.setScope(p8);
        if (this.mAuthority != null) {
            v4_2.setAuthority(new java.net.URL(this.mAuthority));
        }
        this.mCommonCache.saveTokens(v3_2, v4_2, v1);
        return;
    }

Method com.microsoft.identity.common.adal.internal.util.StringExtensions.getUrl() calling method java.net.URL.<init>()


    public static java.net.URL getUrl(String p4)
    {
        try {
            java.net.URL v0 = new java.net.URL(p4);
        } catch (java.net.MalformedURLException v1) {
            android.util.Log.e(com.microsoft.identity.common.adal.internal.util.StringExtensions.TAG, "authority_url_not_valid");
        }
        return v0;
    }

Method com.microsoft.identity.common.internal.cache.SchemaUtil.getEnvironment() calling method java.net.URL.<init>()


    public static String getEnvironment(com.microsoft.identity.common.internal.providers.oauth2.IDToken p7)
    {
        try {
            int v2_4 = new java.net.URL(com.microsoft.identity.common.internal.cache.SchemaUtil.getAuthority(p7)).getHost();
        } catch (java.net.MalformedURLException v4_0) {
            String v5_1 = new StringBuilder();
            v5_1.append(com.microsoft.identity.common.internal.cache.SchemaUtil.TAG);
            v5_1.append(":");
            v5_1.append("getEnvironment");
            com.microsoft.identity.common.internal.logging.Logger.error(v5_1.toString(), "Failed to construct URL from issuer claim", v2_4);
            int v2_1 = new StringBuilder();
            v2_1.append(com.microsoft.identity.common.internal.cache.SchemaUtil.TAG);
            v2_1.append(":");
            v2_1.append("getEnvironment");
            com.microsoft.identity.common.internal.logging.Logger.errorPII(v2_1.toString(), "Failed with Exception", v4_0);
            v2_4 = 0;
        }
        return v2_4;
    }

Method com.microsoft.identity.common.internal.providers.oauth2.OAuth2Strategy.performTokenRequest() calling method java.net.URL.<init>()


    protected com.microsoft.identity.common.internal.net.HttpResponse performTokenRequest(com.microsoft.identity.common.internal.providers.oauth2.TokenRequest p7)
    {
        String v0 = com.microsoft.identity.common.internal.net.ObjectMapper.serializeObjectToFormUrlEncoded(p7);
        java.util.TreeMap v1_1 = new java.util.TreeMap();
        v1_1.put("client-request-id", java.util.UUID.randomUUID().toString());
        return com.microsoft.identity.common.internal.net.HttpRequest.sendPost(new java.net.URL(this.mTokenEndpoint), v1_1, v0.getBytes("UTF-8"), "application/x-www-form-urlencoded");
    }

Method com.squareup.okhttp.Call.toLoggableString() calling method java.net.URL.<init>()


    private String toLoggableString()
    {
        String v0_1;
        if (!this.canceled) {
            v0_1 = "call";
        } else {
            v0_1 = "canceled call";
        }
        try {
            java.net.MalformedURLException v1_0 = new java.net.URL(this.originalRequest.url(), "/...").toString();
            String v2_1 = new StringBuilder();
            v2_1.append(v0_1);
            v2_1.append(" to ");
            v2_1.append(v1_0);
            return v2_1.toString();
        } catch (java.net.MalformedURLException v1) {
            return v0_1;
        }
    }

Method com.squareup.okhttp.HttpUrl.url() calling method java.net.URL.<init>()


    public java.net.URL url()
    {
        try {
            return new java.net.URL(this.url);
        } catch (java.net.MalformedURLException v0_2) {
            throw new RuntimeException(v0_2);
        }
    }

Method com.squareup.okhttp.internal.http.HttpEngine.followUpRequest() calling method java.net.URL.<init>()


    public com.squareup.okhttp.Request followUpRequest()
    {
        if (this.userResponse == null) {
            throw new IllegalStateException();
        } else {
            java.net.Proxy v0_1;
            if (this.getRoute() == null) {
                v0_1 = this.client.getProxy();
            } else {
                v0_1 = this.getRoute().getProxy();
            }
            int v1_1 = this.userResponse.code();
            if (v1_1 != 401) {
                if (v1_1 == 407) {
                    if (v0_1.type() != java.net.Proxy$Type.HTTP) {
                        throw new java.net.ProtocolException("Received HTTP_PROXY_AUTH (407) code while not using proxy");
                    }
                } else {
                    switch (v1_1) {
                        case 300:
                        case 301:
                        case 302:
                        case 303:
                            break;
                        case 300:
                        case 301:
                        case 302:
                        case 303:
                            break;
                        case 300:
                        case 301:
                        case 302:
                        case 303:
                            break;
                        case 300:
                        case 301:
                        case 302:
                        case 303:
                            break;
                        default:
                            switch (v1_1) {
                                case 307:
                                case 308:
                                    if ((this.userRequest.method().equals("GET")) || (this.userRequest.method().equals("HEAD"))) {
                                    } else {
                                        return 0;
                                    }
                                default:
                                    return 0;
                            }
                    }
                    if (this.client.getFollowRedirects()) {
                        boolean v3_12 = this.userResponse.header("Location");
                        if (v3_12) {
                            java.net.URL v4_4 = new java.net.URL(this.userRequest.url(), v3_12);
                            if ((v4_4.getProtocol().equals("https")) || (v4_4.getProtocol().equals("http"))) {
                                if ((v4_4.getProtocol().equals(this.userRequest.url().getProtocol())) || (this.client.getFollowSslRedirects())) {
                                    com.squareup.okhttp.Request$Builder v6_8 = this.userRequest.newBuilder();
                                    if (com.squareup.okhttp.internal.http.HttpMethod.permitsRequestBody(this.userRequest.method())) {
                                        v6_8.method("GET", 0);
                                        v6_8.removeHeader("Transfer-Encoding");
                                        v6_8.removeHeader("Content-Length");
                                        v6_8.removeHeader("Content-Type");
                                    }
                                    if (!this.sameConnection(v4_4)) {
                                        v6_8.removeHeader("Authorization");
                                    }
                                    return v6_8.url(v4_4).build();
                                } else {
                                    return 0;
                                }
                            } else {
                                return 0;
                            }
                        } else {
                            return 0;
                        }
                    } else {
                        return 0;
                    }
                }
            }
            return com.squareup.okhttp.internal.http.OkHeaders.processAuthHeader(this.client.getAuthenticator(), this.userResponse, v0_1);
        }
    }

Method com.squareup.okhttp.internal.http.SocketConnector.createTunnelRequest() calling method java.net.URL.<init>()


    private com.squareup.okhttp.Request createTunnelRequest(com.squareup.okhttp.Request p8)
    {
        String v2_3;
        String v0_1 = p8.url().getHost();
        int v1_1 = com.squareup.okhttp.internal.Util.getEffectivePort(p8.url());
        if (v1_1 != com.squareup.okhttp.internal.Util.getDefaultPort("https")) {
            String v2_2 = new StringBuilder();
            v2_2.append(v0_1);
            v2_2.append(":");
            v2_2.append(v1_1);
            v2_3 = v2_2.toString();
        } else {
            v2_3 = v0_1;
        }
        com.squareup.okhttp.Request$Builder v3_5 = new com.squareup.okhttp.Request$Builder().url(new java.net.URL("https", v0_1, v1_1, "/")).header("Host", v2_3).header("Proxy-Connection", "Keep-Alive");
        String v4_5 = p8.header("User-Agent");
        if (v4_5 != null) {
            v3_5.header("User-Agent", v4_5);
        }
        String v5_4 = p8.header("Proxy-Authorization");
        if (v5_4 != null) {
            v3_5.header("Proxy-Authorization", v5_4);
        }
        return v3_5.build();
    }

Method io.fabric.sdk.android.services.network.HttpRequest.<init>() calling method java.net.URL.<init>()


    public HttpRequest(CharSequence p3, String p4)
    {
        this.connection = 0;
        this.ignoreCloseExceptions = 1;
        this.uncompress = 0;
        this.bufferSize = 8192;
        try {
            this.url = new java.net.URL(p3.toString());
            this.requestMethod = p4;
            return;
        } catch (java.net.MalformedURLException v0_2) {
            throw new io.fabric.sdk.android.services.network.HttpRequest$HttpRequestException(v0_2);
        }
    }

Method io.fabric.sdk.android.services.network.HttpRequest.encode() calling method java.net.URL.<init>()


    public static String encode(CharSequence p10)
    {
        try {
            java.io.IOException v0_2 = new java.net.URL(p10.toString());
            String v1_3 = v0_2.getHost();
            int v2 = v0_2.getPort();
        } catch (java.io.IOException v0_1) {
            throw new io.fabric.sdk.android.services.network.HttpRequest$HttpRequestException(v0_1);
        }
        if (v2 != -1) {
            String v3_2 = new StringBuilder();
            v3_2.append(v1_3);
            v3_2.append(58);
            v3_2.append(Integer.toString(v2));
            v1_3 = v3_2.toString();
        }
        try {
            java.net.URI v9 = new java.net.URI;
            v9(v0_2.getProtocol(), v1_3, v0_2.getPath(), v0_2.getQuery(), 0);
            String v3_4 = v9.toASCIIString();
            java.io.IOException v4_4 = v3_4.indexOf(63);
        } catch (String v3_5) {
            java.io.IOException v4_6 = new java.io.IOException("Parsing URI failed");
            v4_6.initCause(v3_5);
            throw new io.fabric.sdk.android.services.network.HttpRequest$HttpRequestException(v4_6);
        }
        if ((v4_4 > null) && ((v4_4 + 1) < v3_4.length())) {
            String v5_6 = new StringBuilder();
            v5_6.append(v3_4.substring(0, (v4_4 + 1)));
            v5_6.append(v3_4.substring((v4_4 + 1)).replace("+", "%2B"));
            v3_4 = v5_6.toString();
        }
        return v3_4;
    }

Method com.bumptech.glide.load.data.HttpUrlFetcher.loadDataWithRedirects() calling method java.net.URL.<init>()


    private java.io.InputStream loadDataWithRedirects(java.net.URL p6, int p7, java.net.URL p8, java.util.Map p9)
    {
        if (p7 >= 5) {
            throw new java.io.IOException("Too many (> 5) redirects!");
        } else {
            if (p8 == null) {
            } else {
                try {
                    if (p6.toURI().equals(p8.toURI())) {
                        throw new java.io.IOException("In re-direct loop");
                    } else {
                    }
                } catch (int v0) {
                }
            }
            this.urlConnection = this.connectionFactory.build(p6);
            int v0_8 = p9.entrySet().iterator();
            while (v0_8.hasNext()) {
                java.io.IOException v1_2 = ((java.util.Map$Entry) v0_8.next());
                this.urlConnection.addRequestProperty(((String) v1_2.getKey()), ((String) v1_2.getValue()));
            }
            this.urlConnection.setConnectTimeout(2500);
            this.urlConnection.setReadTimeout(2500);
            this.urlConnection.setUseCaches(0);
            this.urlConnection.setDoInput(1);
            this.urlConnection.connect();
            if (!this.isCancelled) {
                int v0_17 = this.urlConnection.getResponseCode();
                if ((v0_17 / 100) != 2) {
                    if ((v0_17 / 100) != 3) {
                        if (v0_17 != -1) {
                            String v2_4 = new StringBuilder();
                            v2_4.append("Request failed ");
                            v2_4.append(v0_17);
                            v2_4.append(": ");
                            v2_4.append(this.urlConnection.getResponseMessage());
                            throw new java.io.IOException(v2_4.toString());
                        } else {
                            throw new java.io.IOException("Unable to retrieve response code from HttpUrlConnection.");
                        }
                    } else {
                        java.io.IOException v1_17 = this.urlConnection.getHeaderField("Location");
                        if (android.text.TextUtils.isEmpty(v1_17)) {
                            throw new java.io.IOException("Received empty or null redirect url");
                        } else {
                            return this.loadDataWithRedirects(new java.net.URL(p6, v1_17), (p7 + 1), p6, p9);
                        }
                    }
                } else {
                    return this.getStreamForSuccessfulRequest(this.urlConnection);
                }
            } else {
                return 0;
            }
        }
    }

Method com.github.nkzawa.engineio.client.transports.PollingXHR$Request.create() calling method java.net.URL.<init>()


    public void create()
    {
        try {
            javax.net.ssl.HttpsURLConnection v1_2 = com.github.nkzawa.engineio.client.transports.PollingXHR.access$200();
            String v4_1 = new Object[2];
            v4_1[0] = this.method;
            v4_1[1] = this.uri;
            v1_2.fine(String.format("xhr open %s: %s", v4_1));
            this.xhr = ((java.net.HttpURLConnection) new java.net.URL(this.uri).openConnection());
            this.xhr.setRequestMethod(this.method);
            this.xhr.setConnectTimeout(10000);
        } catch (javax.net.ssl.HttpsURLConnection v1_6) {
            this.onError(v1_6);
            return;
        }
        if ((this.xhr instanceof javax.net.ssl.HttpsURLConnection)) {
            if (this.sslContext != null) {
                ((javax.net.ssl.HttpsURLConnection) this.xhr).setSSLSocketFactory(this.sslContext.getSocketFactory());
            }
            if (this.hostnameVerifier != null) {
                ((javax.net.ssl.HttpsURLConnection) this.xhr).setHostnameVerifier(this.hostnameVerifier);
            }
        }
        javax.net.ssl.HttpsURLConnection v1_14 = new java.util.TreeMap(String.CASE_INSENSITIVE_ORDER);
        if ("POST".equals(this.method)) {
            this.xhr.setDoOutput(1);
            v1_14.put("Content-type", "application/octet-stream");
        }
        void v0_1 = this.onRequestHeaders(v1_14);
        Thread v2_16 = v1_14.entrySet().iterator();
        while (v2_16.hasNext()) {
            String v4_7 = ((java.util.Map$Entry) v2_16.next());
            this.xhr.setRequestProperty(((String) v4_7.getKey()), ((String) v4_7.getValue()));
        }
        Thread v2_17 = com.github.nkzawa.engineio.client.transports.PollingXHR.access$200();
        com.github.nkzawa.engineio.client.transports.PollingXHR$Request$1 v3_1 = new Object[2];
        v3_1[0] = this.uri;
        v3_1[1] = this.data;
        v2_17.fine(String.format("sending xhr with url %s | data %s", v3_1));
        new Thread(new com.github.nkzawa.engineio.client.transports.PollingXHR$Request$1(this, v0_1)).start();
        return;
    }

Method com.google.gson.internal.bind.TypeAdapters$21.read() calling method java.net.URL.<init>()


    public java.net.URL read(com.google.gson.stream.JsonReader p4)
    {
        java.net.URL v2_1 = 0;
        if (p4.peek() != com.google.gson.stream.JsonToken.NULL) {
            String v0_1 = p4.nextString();
            if (!"null".equals(v0_1)) {
                v2_1 = new java.net.URL(v0_1);
            }
            return v2_1;
        } else {
            p4.nextNull();
            return 0;
        }
    }

Method com.microsoft.aad.adal.BrokerProxy.canSwitchToBroker() calling method java.net.URL.<init>()


    public com.microsoft.aad.adal.BrokerProxy$SwitchToBroker canSwitchToBroker(String p10)
    {
        try {
            String v3_11;
            java.net.MalformedURLException v1_1 = new java.net.URL(p10);
            IllegalArgumentException v2_3 = this.mContext.getPackageName();
            com.microsoft.aad.adal.UsageAuthenticationException v4_0 = 1;
        } catch (java.net.MalformedURLException v1) {
            throw new IllegalArgumentException(com.microsoft.aad.adal.ADALError.DEVELOPER_AUTHORITY_IS_NOT_VALID_URL.name());
        }
        if ((!com.microsoft.aad.adal.AuthenticationSettings.INSTANCE.getUseBroker()) || ((v2_3.equalsIgnoreCase(com.microsoft.aad.adal.AuthenticationSettings.INSTANCE.getBrokerPackageName())) || ((v2_3.equalsIgnoreCase("com.azure.authenticator")) || ((!this.verifyAuthenticator(this.mAcctManager)) || (com.microsoft.aad.adal.UrlExtensions.isADFSAuthority(v1_1)))))) {
            v3_11 = 0;
        } else {
            v3_11 = 1;
        }
        if (v3_11 != null) {
            if (!this.isBrokerAccountServiceSupported()) {
                if ((v3_11 == null) || (!this.checkAccount(this.mAcctManager, "", ""))) {
                    v4_0 = 0;
                }
                if (v4_0 != null) {
                    try {
                        this.verifyBrokerPermissionsAPI23AndHigher();
                    } catch (com.microsoft.aad.adal.UsageAuthenticationException v4) {
                        com.microsoft.aad.adal.Logger.v("BrokerProxy:canSwitchToBroker", "Missing GET_ACCOUNTS permission, cannot switch to broker.");
                        return com.microsoft.aad.adal.BrokerProxy$SwitchToBroker.NEED_PERMISSIONS_TO_SWITCH_TO_BROKER;
                    }
                } else {
                    com.microsoft.aad.adal.Logger.v("BrokerProxy:canSwitchToBroker", "No valid account existed in broker, cannot switch to broker for auth.");
                    return com.microsoft.aad.adal.BrokerProxy$SwitchToBroker.CANNOT_SWITCH_TO_BROKER;
                }
            }
            return com.microsoft.aad.adal.BrokerProxy$SwitchToBroker.CAN_SWITCH_TO_BROKER;
        } else {
            com.microsoft.aad.adal.Logger.v("BrokerProxy:canSwitchToBroker", "Broker auth is turned off or no valid broker is available on the device, cannot switch to broker.");
            return com.microsoft.aad.adal.BrokerProxy$SwitchToBroker.CANNOT_SWITCH_TO_BROKER;
        }
    }

Method com.microsoft.aad.adal.DRSMetadataRequestor.requestDrsDiscoveryInternal() calling method java.net.URL.<init>()


    private com.microsoft.aad.adal.DRSMetadata requestDrsDiscoveryInternal(com.microsoft.aad.adal.DRSMetadataRequestor$Type p9, String p10)
    {
        try {
            java.net.MalformedURLException v0_1 = new java.net.URL(this.buildRequestUrlByType(p9, p10));
            com.microsoft.aad.adal.AuthenticationException v1_4 = new java.util.HashMap();
            v1_4.put("Accept", "application/json");
        } catch (java.net.MalformedURLException v0) {
            throw new com.microsoft.aad.adal.AuthenticationException(com.microsoft.aad.adal.ADALError.DRS_METADATA_URL_INVALID);
        }
        if (this.getCorrelationId() != null) {
            v1_4.put("client-request-id", this.getCorrelationId().toString());
        }
        try {
            java.io.IOException v2_4 = this.getWebrequestHandler().sendGet(v0_1, v1_4);
            com.microsoft.aad.adal.AuthenticationException v3_2 = v2_4.getStatusCode();
        } catch (java.io.IOException v2_5) {
            throw v2_5;
        } catch (java.io.IOException v2) {
            throw new com.microsoft.aad.adal.AuthenticationException(com.microsoft.aad.adal.ADALError.IO_EXCEPTION);
        }
        if (200 != v3_2) {
            String v6_1 = new StringBuilder();
            v6_1.append("Unexpected error code: [");
            v6_1.append(v3_2);
            v6_1.append("]");
            throw new com.microsoft.aad.adal.AuthenticationException(com.microsoft.aad.adal.ADALError.DRS_FAILED_SERVER_ERROR, v6_1.toString());
        } else {
            com.microsoft.aad.adal.AuthenticationException v4_3 = this.parseMetadata(v2_4);
            return v4_3;
        }
    }

Method com.microsoft.aad.adal.WebFingerMetadataRequestor.buildWebFingerUrl() calling method java.net.URL.<init>()


    static java.net.URL buildWebFingerUrl(java.net.URL p7, com.microsoft.aad.adal.DRSMetadata p8)
    {
        java.net.URL v0_1 = new java.net.URL(p8.getIdentityProviderService().getPassiveAuthEndpoint());
        StringBuilder v1_4 = new StringBuilder("https://");
        v1_4.append(v0_1.getHost());
        v1_4.append("/.well-known/webfinger?resource=");
        String v2_3 = v1_4.append(p7.toString()).toString();
        String v5_1 = new StringBuilder();
        v5_1.append("WebFinger URL: ");
        v5_1.append(v2_3);
        com.microsoft.aad.adal.Logger.i(com.microsoft.aad.adal.WebFingerMetadataRequestor.TAG, "Validator will use WebFinger URL. ", v5_1.toString());
        return new java.net.URL(v2_3);
    }

Method com.google.android.exoplayer2.upstream.DefaultHttpDataSource.handleRedirect() calling method java.net.URL.<init>()


    private static java.net.URL handleRedirect(java.net.URL p5, String p6)
    {
        if (p6 == null) {
            throw new java.net.ProtocolException("Null location redirect");
        } else {
            java.net.ProtocolException v0_3 = new java.net.URL(p5, p6);
            String v1_1 = v0_3.getProtocol();
            if ((!"https".equals(v1_1)) && (!"http".equals(v1_1))) {
                String v3_1 = new StringBuilder();
                v3_1.append("Unsupported protocol redirect: ");
                v3_1.append(v1_1);
                throw new java.net.ProtocolException(v3_1.toString());
            } else {
                return v0_3;
            }
        }
    }

Method com.google.android.exoplayer2.upstream.DefaultHttpDataSource.makeConnection() calling method java.net.URL.<init>()


    private java.net.HttpURLConnection makeConnection(com.google.android.exoplayer2.upstream.DataSpec p22)
    {
        java.net.URL v2_1 = new java.net.URL(p22.uri.toString());
        int v10 = p22.postBody;
        long v14 = p22.position;
        java.net.URL v12_1 = p22.length;
        boolean v20 = p22.isFlagSet(1);
        if (this.allowCrossProtocolRedirects) {
            int v1_1 = 0;
            while(true) {
                int v3_0 = (v1_1 + 1);
                if (v1_1 > 20) {
                    long v6 = v14;
                    String v8_1 = new StringBuilder();
                    v8_1.append("Too many redirects: ");
                    v8_1.append(v3_0);
                    throw new java.net.NoRouteToHostException(v8_1.toString());
                } else {
                    java.net.URL v4_1 = v12_1;
                    long v6_0 = v14;
                    int v1_6 = this.makeConnection(v2_1, v10, v14, v4_1, v20, 0);
                    String v8_3 = v1_6.getResponseCode();
                    if ((v8_3 != 300) && ((v8_3 != 301) && ((v8_3 != 302) && ((v8_3 != 303) && ((v10 != 0) || ((v8_3 != 307) && (v8_3 != 308))))))) {
                        break;
                    }
                    v10 = 0;
                    int v9_8 = v1_6.getHeaderField("Location");
                    v1_6.disconnect();
                    v2_1 = com.google.android.exoplayer2.upstream.DefaultHttpDataSource.handleRedirect(v2_1, v9_8);
                    v1_1 = v3_0;
                    v12_1 = v4_1;
                    v14 = v6_0;
                }
            }
            return v1_6;
        } else {
            return this.makeConnection(v2_1, v10, v14, v12_1, v20, 1);
        }
    }

Method okhttp3.HttpUrl.url() calling method java.net.URL.<init>()


    public java.net.URL url()
    {
        try {
            return new java.net.URL(this.url);
        } catch (java.net.MalformedURLException v0_2) {
            throw new RuntimeException(v0_2);
        }
    }

Method org.apache.commons.math3.random.ValueServer.setValuesFileURL() calling method java.net.URL.<init>()


    public void setValuesFileURL(String p2)
    {
        this.valuesFileURL = new java.net.URL(p2);
        return;
    }