Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/androidx/webkit/internal/ApiFeature.java

@@ -0,0 +1,148 @@
+package androidx.webkit.internal;
+
+import android.os.Build;
+import androidx.annotation.ChecksSdkIntAtLeast;
+import androidx.annotation.NonNull;
+import androidx.annotation.VisibleForTesting;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import org.chromium.support_lib_boundary.util.BoundaryInterfaceReflectionUtil;
+
+/* loaded from: classes.dex */
+public abstract class ApiFeature implements ConditionallySupportedFeature {
+    private static final Set<ApiFeature> sValues = new HashSet();
+    private final String mInternalFeatureValue;
+    private final String mPublicFeatureValue;
+
+    @Override // androidx.webkit.internal.ConditionallySupportedFeature
+    @NonNull
+    public String getPublicFeatureName() {
+        return this.mPublicFeatureValue;
+    }
+
+    public abstract boolean isSupportedByFramework();
+
+    public ApiFeature(@NonNull String str, @NonNull String str2) {
+        this.mPublicFeatureValue = str;
+        this.mInternalFeatureValue = str2;
+        sValues.add(this);
+    }
+
+    @Override // androidx.webkit.internal.ConditionallySupportedFeature
+    public boolean isSupported() {
+        return isSupportedByFramework() || isSupportedByWebView();
+    }
+
+    @ChecksSdkIntAtLeast(api = 21)
+    public boolean isSupportedByWebView() {
+        return BoundaryInterfaceReflectionUtil.containsFeature(LAZY_HOLDER.WEBVIEW_APK_FEATURES, this.mInternalFeatureValue);
+    }
+
+    @NonNull
+    public static Set<ApiFeature> values() {
+        return Collections.unmodifiableSet(sValues);
+    }
+
+    @NonNull
+    @VisibleForTesting
+    public static Set<String> getWebViewApkFeaturesForTesting() {
+        return LAZY_HOLDER.WEBVIEW_APK_FEATURES;
+    }
+
+    public static class LAZY_HOLDER {
+        static final Set<String> WEBVIEW_APK_FEATURES = new HashSet(Arrays.asList(WebViewGlueCommunicator.getFactory().getWebViewFeatures()));
+
+        private LAZY_HOLDER() {
+        }
+    }
+
+    public static class NoFramework extends ApiFeature {
+        @Override // androidx.webkit.internal.ApiFeature
+        public final boolean isSupportedByFramework() {
+            return false;
+        }
+
+        public NoFramework(@NonNull String str, @NonNull String str2) {
+            super(str, str2);
+        }
+    }
+
+    public static class M extends ApiFeature {
+        @Override // androidx.webkit.internal.ApiFeature
+        public final boolean isSupportedByFramework() {
+            return true;
+        }
+
+        public M(@NonNull String str, @NonNull String str2) {
+            super(str, str2);
+        }
+    }
+
+    public static class N extends ApiFeature {
+        @Override // androidx.webkit.internal.ApiFeature
+        public final boolean isSupportedByFramework() {
+            return true;
+        }
+
+        public N(@NonNull String str, @NonNull String str2) {
+            super(str, str2);
+        }
+    }
+
+    public static class O extends ApiFeature {
+        @Override // androidx.webkit.internal.ApiFeature
+        public final boolean isSupportedByFramework() {
+            return true;
+        }
+
+        public O(@NonNull String str, @NonNull String str2) {
+            super(str, str2);
+        }
+    }
+
+    public static class O_MR1 extends ApiFeature {
+        @Override // androidx.webkit.internal.ApiFeature
+        public final boolean isSupportedByFramework() {
+            return Build.VERSION.SDK_INT >= 27;
+        }
+
+        public O_MR1(@NonNull String str, @NonNull String str2) {
+            super(str, str2);
+        }
+    }
+
+    public static class P extends ApiFeature {
+        @Override // androidx.webkit.internal.ApiFeature
+        public final boolean isSupportedByFramework() {
+            return Build.VERSION.SDK_INT >= 28;
+        }
+
+        public P(@NonNull String str, @NonNull String str2) {
+            super(str, str2);
+        }
+    }
+
+    public static class Q extends ApiFeature {
+        @Override // androidx.webkit.internal.ApiFeature
+        public final boolean isSupportedByFramework() {
+            return Build.VERSION.SDK_INT >= 29;
+        }
+
+        public Q(@NonNull String str, @NonNull String str2) {
+            super(str, str2);
+        }
+    }
+
+    public static class T extends ApiFeature {
+        @Override // androidx.webkit.internal.ApiFeature
+        public final boolean isSupportedByFramework() {
+            return Build.VERSION.SDK_INT >= 33;
+        }
+
+        public T(@NonNull String str, @NonNull String str2) {
+            super(str, str2);
+        }
+    }
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForLollipop.java

@@ -0,0 +1,25 @@
+package androidx.webkit.internal;
+
+import android.net.Uri;
+import android.webkit.WebResourceRequest;
+import androidx.annotation.DoNotInline;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+@RequiresApi(21)
+/* loaded from: classes.dex */
+public class ApiHelperForLollipop {
+    private ApiHelperForLollipop() {
+    }
+
+    @DoNotInline
+    public static boolean isForMainFrame(@NonNull WebResourceRequest webResourceRequest) {
+        return webResourceRequest.isForMainFrame();
+    }
+
+    @NonNull
+    @DoNotInline
+    public static Uri getUrl(@NonNull WebResourceRequest webResourceRequest) {
+        return webResourceRequest.getUrl();
+    }
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForM.java

@@ -0,0 +1,107 @@
+package androidx.webkit.internal;
+
+import android.net.Uri;
+import android.os.Handler;
+import android.webkit.WebMessage;
+import android.webkit.WebMessagePort;
+import android.webkit.WebResourceError;
+import android.webkit.WebSettings;
+import android.webkit.WebView;
+import androidx.annotation.DoNotInline;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.webkit.WebMessageCompat;
+import androidx.webkit.WebMessagePortCompat;
+import androidx.webkit.WebViewCompat;
+
+@RequiresApi(23)
+/* loaded from: classes.dex */
+public class ApiHelperForM {
+    private ApiHelperForM() {
+    }
+
+    @DoNotInline
+    public static void postMessage(@NonNull WebMessagePort webMessagePort, @NonNull WebMessage webMessage) {
+        webMessagePort.postMessage(webMessage);
+    }
+
+    @DoNotInline
+    public static void close(@NonNull WebMessagePort webMessagePort) {
+        webMessagePort.close();
+    }
+
+    @DoNotInline
+    public static void setWebMessageCallback(@NonNull WebMessagePort webMessagePort, @NonNull final WebMessagePortCompat.WebMessageCallbackCompat webMessageCallbackCompat) {
+        webMessagePort.setWebMessageCallback(new WebMessagePort.WebMessageCallback() { // from class: androidx.webkit.internal.ApiHelperForM.1
+            @Override // android.webkit.WebMessagePort.WebMessageCallback
+            public void onMessage(WebMessagePort webMessagePort2, WebMessage webMessage) {
+                WebMessagePortCompat.WebMessageCallbackCompat.this.onMessage(new WebMessagePortImpl(webMessagePort2), WebMessagePortImpl.frameworkMessageToCompat(webMessage));
+            }
+        });
+    }
+
+    @DoNotInline
+    public static void setWebMessageCallback(@NonNull WebMessagePort webMessagePort, @NonNull final WebMessagePortCompat.WebMessageCallbackCompat webMessageCallbackCompat, @Nullable Handler handler) {
+        webMessagePort.setWebMessageCallback(new WebMessagePort.WebMessageCallback() { // from class: androidx.webkit.internal.ApiHelperForM.2
+            @Override // android.webkit.WebMessagePort.WebMessageCallback
+            public void onMessage(WebMessagePort webMessagePort2, WebMessage webMessage) {
+                WebMessagePortCompat.WebMessageCallbackCompat.this.onMessage(new WebMessagePortImpl(webMessagePort2), WebMessagePortImpl.frameworkMessageToCompat(webMessage));
+            }
+        }, handler);
+    }
+
+    @NonNull
+    @DoNotInline
+    public static WebMessage createWebMessage(@NonNull WebMessageCompat webMessageCompat) {
+        return new WebMessage(webMessageCompat.getData(), WebMessagePortImpl.compatToPorts(webMessageCompat.getPorts()));
+    }
+
+    @NonNull
+    @DoNotInline
+    public static WebMessageCompat createWebMessageCompat(@NonNull WebMessage webMessage) {
+        return new WebMessageCompat(webMessage.getData(), WebMessagePortImpl.portsToCompat(webMessage.getPorts()));
+    }
+
+    @DoNotInline
+    public static int getErrorCode(@NonNull WebResourceError webResourceError) {
+        return webResourceError.getErrorCode();
+    }
+
+    @NonNull
+    @DoNotInline
+    public static CharSequence getDescription(@NonNull WebResourceError webResourceError) {
+        return webResourceError.getDescription();
+    }
+
+    @DoNotInline
+    public static void setOffscreenPreRaster(@NonNull WebSettings webSettings, boolean z) {
+        webSettings.setOffscreenPreRaster(z);
+    }
+
+    @DoNotInline
+    public static boolean getOffscreenPreRaster(@NonNull WebSettings webSettings) {
+        return webSettings.getOffscreenPreRaster();
+    }
+
+    @DoNotInline
+    public static void postVisualStateCallback(@NonNull WebView webView, long j, @NonNull final WebViewCompat.VisualStateCallback visualStateCallback) {
+        webView.postVisualStateCallback(j, new WebView.VisualStateCallback() { // from class: androidx.webkit.internal.ApiHelperForM.3
+            @Override // android.webkit.WebView.VisualStateCallback
+            public void onComplete(long j2) {
+                WebViewCompat.VisualStateCallback.this.onComplete(j2);
+            }
+        });
+    }
+
+    @DoNotInline
+    public static void postWebMessage(@NonNull WebView webView, @NonNull WebMessage webMessage, @NonNull Uri uri) {
+        webView.postWebMessage(webMessage, uri);
+    }
+
+    @NonNull
+    @DoNotInline
+    public static WebMessagePort[] createWebMessageChannel(@NonNull WebView webView) {
+        return webView.createWebMessageChannel();
+    }
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForN.java

@@ -0,0 +1,110 @@
+package androidx.webkit.internal;
+
+import android.content.Context;
+import android.webkit.ServiceWorkerClient;
+import android.webkit.ServiceWorkerController;
+import android.webkit.ServiceWorkerWebSettings;
+import android.webkit.WebResourceRequest;
+import android.webkit.WebSettings;
+import androidx.annotation.DoNotInline;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.webkit.ServiceWorkerClientCompat;
+import java.io.File;
+
+@RequiresApi(24)
+/* loaded from: classes.dex */
+public class ApiHelperForN {
+    private ApiHelperForN() {
+    }
+
+    @NonNull
+    @DoNotInline
+    public static File getDataDir(@NonNull Context context) {
+        return context.getDataDir();
+    }
+
+    @NonNull
+    @DoNotInline
+    public static ServiceWorkerController getServiceWorkerControllerInstance() {
+        return ServiceWorkerController.getInstance();
+    }
+
+    @NonNull
+    @DoNotInline
+    public static ServiceWorkerWebSettings getServiceWorkerWebSettings(@NonNull ServiceWorkerController serviceWorkerController) {
+        return serviceWorkerController.getServiceWorkerWebSettings();
+    }
+
+    @NonNull
+    @DoNotInline
+    public static ServiceWorkerWebSettingsImpl getServiceWorkerWebSettingsImpl(@NonNull ServiceWorkerController serviceWorkerController) {
+        return new ServiceWorkerWebSettingsImpl(getServiceWorkerWebSettings(serviceWorkerController));
+    }
+
+    @DoNotInline
+    public static void setServiceWorkerClient(@NonNull ServiceWorkerController serviceWorkerController, @Nullable ServiceWorkerClient serviceWorkerClient) {
+        serviceWorkerController.setServiceWorkerClient(serviceWorkerClient);
+    }
+
+    @DoNotInline
+    public static void setServiceWorkerClientCompat(@NonNull ServiceWorkerController serviceWorkerController, @NonNull ServiceWorkerClientCompat serviceWorkerClientCompat) {
+        serviceWorkerController.setServiceWorkerClient(new FrameworkServiceWorkerClient(serviceWorkerClientCompat));
+    }
+
+    @DoNotInline
+    public static void setCacheMode(@NonNull ServiceWorkerWebSettings serviceWorkerWebSettings, int i) {
+        serviceWorkerWebSettings.setCacheMode(i);
+    }
+
+    @DoNotInline
+    public static int getCacheMode(@NonNull ServiceWorkerWebSettings serviceWorkerWebSettings) {
+        return serviceWorkerWebSettings.getCacheMode();
+    }
+
+    @DoNotInline
+    public static void setAllowContentAccess(@NonNull ServiceWorkerWebSettings serviceWorkerWebSettings, boolean z) {
+        serviceWorkerWebSettings.setAllowContentAccess(z);
+    }
+
+    @DoNotInline
+    public static boolean getAllowContentAccess(@NonNull ServiceWorkerWebSettings serviceWorkerWebSettings) {
+        return serviceWorkerWebSettings.getAllowContentAccess();
+    }
+
+    @DoNotInline
+    public static void setAllowFileAccess(@NonNull ServiceWorkerWebSettings serviceWorkerWebSettings, boolean z) {
+        serviceWorkerWebSettings.setAllowFileAccess(z);
+    }
+
+    @DoNotInline
+    public static boolean getAllowFileAccess(@NonNull ServiceWorkerWebSettings serviceWorkerWebSettings) {
+        return serviceWorkerWebSettings.getAllowFileAccess();
+    }
+
+    @DoNotInline
+    public static void setBlockNetworkLoads(@NonNull ServiceWorkerWebSettings serviceWorkerWebSettings, boolean z) {
+        serviceWorkerWebSettings.setBlockNetworkLoads(z);
+    }
+
+    @DoNotInline
+    public static boolean getBlockNetworkLoads(@NonNull ServiceWorkerWebSettings serviceWorkerWebSettings) {
+        return serviceWorkerWebSettings.getBlockNetworkLoads();
+    }
+
+    @DoNotInline
+    public static boolean isRedirect(@NonNull WebResourceRequest webResourceRequest) {
+        return webResourceRequest.isRedirect();
+    }
+
+    @DoNotInline
+    public static void setDisabledActionModeMenuItems(@NonNull WebSettings webSettings, int i) {
+        webSettings.setDisabledActionModeMenuItems(i);
+    }
+
+    @DoNotInline
+    public static int getDisabledActionModeMenuItems(@NonNull WebSettings webSettings) {
+        return webSettings.getDisabledActionModeMenuItems();
+    }
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForO.java

@@ -0,0 +1,46 @@
+package androidx.webkit.internal;
+
+import android.content.pm.PackageInfo;
+import android.webkit.WebChromeClient;
+import android.webkit.WebSettings;
+import android.webkit.WebView;
+import android.webkit.WebViewClient;
+import androidx.annotation.DoNotInline;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+
+@RequiresApi(26)
+/* loaded from: classes.dex */
+public class ApiHelperForO {
+    private ApiHelperForO() {
+    }
+
+    @DoNotInline
+    public static void setSafeBrowsingEnabled(@NonNull WebSettings webSettings, boolean z) {
+        webSettings.setSafeBrowsingEnabled(z);
+    }
+
+    @DoNotInline
+    public static boolean getSafeBrowsingEnabled(@NonNull WebSettings webSettings) {
+        return webSettings.getSafeBrowsingEnabled();
+    }
+
+    @Nullable
+    @DoNotInline
+    public static WebViewClient getWebViewClient(@NonNull WebView webView) {
+        return webView.getWebViewClient();
+    }
+
+    @Nullable
+    @DoNotInline
+    public static WebChromeClient getWebChromeClient(@NonNull WebView webView) {
+        return webView.getWebChromeClient();
+    }
+
+    @NonNull
+    @DoNotInline
+    public static PackageInfo getCurrentWebViewPackage() {
+        return WebView.getCurrentWebViewPackage();
+    }
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForOMR1$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForOMR1$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForOMR1$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForOMR1$$ExternalSyntheticApiModelOutline1 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForOMR1$$ExternalSyntheticApiModelOutline2.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForOMR1$$ExternalSyntheticApiModelOutline2 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForOMR1$$ExternalSyntheticApiModelOutline3.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForOMR1$$ExternalSyntheticApiModelOutline3 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForOMR1$$ExternalSyntheticApiModelOutline4.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForOMR1$$ExternalSyntheticApiModelOutline4 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForOMR1$$ExternalSyntheticApiModelOutline5.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForOMR1$$ExternalSyntheticApiModelOutline5 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForOMR1.java

@@ -0,0 +1,52 @@
+package androidx.webkit.internal;
+
+import android.content.Context;
+import android.net.Uri;
+import android.webkit.SafeBrowsingResponse;
+import android.webkit.ValueCallback;
+import android.webkit.WebView;
+import androidx.annotation.DoNotInline;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import java.util.List;
+
+@RequiresApi(27)
+/* loaded from: classes.dex */
+public class ApiHelperForOMR1 {
+    private ApiHelperForOMR1() {
+    }
+
+    @DoNotInline
+    public static void showInterstitial(@NonNull SafeBrowsingResponse safeBrowsingResponse, boolean z) {
+        safeBrowsingResponse.showInterstitial(z);
+    }
+
+    @DoNotInline
+    public static void proceed(@NonNull SafeBrowsingResponse safeBrowsingResponse, boolean z) {
+        safeBrowsingResponse.proceed(z);
+    }
+
+    @DoNotInline
+    public static void backToSafety(@NonNull SafeBrowsingResponse safeBrowsingResponse, boolean z) {
+        safeBrowsingResponse.backToSafety(z);
+    }
+
+    @DoNotInline
+    public static void startSafeBrowsing(@NonNull Context context, @Nullable ValueCallback<Boolean> valueCallback) {
+        WebView.startSafeBrowsing(context, valueCallback);
+    }
+
+    @DoNotInline
+    public static void setSafeBrowsingWhitelist(@NonNull List<String> list, @Nullable ValueCallback<Boolean> valueCallback) {
+        WebView.setSafeBrowsingWhitelist(list, valueCallback);
+    }
+
+    @NonNull
+    @DoNotInline
+    public static Uri getSafeBrowsingPrivacyPolicyUrl() {
+        Uri safeBrowsingPrivacyPolicyUrl;
+        safeBrowsingPrivacyPolicyUrl = WebView.getSafeBrowsingPrivacyPolicyUrl();
+        return safeBrowsingPrivacyPolicyUrl;
+    }
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForP$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForP$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForP$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForP$$ExternalSyntheticApiModelOutline1 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForP$$ExternalSyntheticApiModelOutline10.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForP$$ExternalSyntheticApiModelOutline10 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForP$$ExternalSyntheticApiModelOutline11.java

@@ -0,0 +1,10 @@
+package androidx.webkit.internal;
+
+import android.webkit.TracingConfig;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForP$$ExternalSyntheticApiModelOutline11 {
+    public static /* synthetic */ TracingConfig.Builder m() {
+        return new TracingConfig.Builder();
+    }
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForP$$ExternalSyntheticApiModelOutline2.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForP$$ExternalSyntheticApiModelOutline2 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForP$$ExternalSyntheticApiModelOutline3.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForP$$ExternalSyntheticApiModelOutline3 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForP$$ExternalSyntheticApiModelOutline4.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForP$$ExternalSyntheticApiModelOutline4 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForP$$ExternalSyntheticApiModelOutline5.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForP$$ExternalSyntheticApiModelOutline5 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForP$$ExternalSyntheticApiModelOutline6.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForP$$ExternalSyntheticApiModelOutline6 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForP$$ExternalSyntheticApiModelOutline7.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForP$$ExternalSyntheticApiModelOutline7 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForP$$ExternalSyntheticApiModelOutline8.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForP$$ExternalSyntheticApiModelOutline8 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForP$$ExternalSyntheticApiModelOutline9.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForP$$ExternalSyntheticApiModelOutline9 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForP.java

@@ -0,0 +1,77 @@
+package androidx.webkit.internal;
+
+import android.os.Looper;
+import android.webkit.TracingConfig;
+import android.webkit.TracingController;
+import android.webkit.WebView;
+import androidx.annotation.DoNotInline;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.webkit.TracingConfig;
+import java.io.OutputStream;
+import java.util.Collection;
+import java.util.concurrent.Executor;
+
+@RequiresApi(28)
+/* loaded from: classes.dex */
+public class ApiHelperForP {
+    private ApiHelperForP() {
+    }
+
+    @NonNull
+    @DoNotInline
+    public static TracingController getTracingControllerInstance() {
+        TracingController tracingController;
+        tracingController = TracingController.getInstance();
+        return tracingController;
+    }
+
+    @DoNotInline
+    public static boolean isTracing(@NonNull TracingController tracingController) {
+        boolean isTracing;
+        isTracing = tracingController.isTracing();
+        return isTracing;
+    }
+
+    @DoNotInline
+    public static void start(@NonNull TracingController tracingController, @NonNull TracingConfig tracingConfig) {
+        TracingConfig.Builder addCategories;
+        TracingConfig.Builder addCategories2;
+        TracingConfig.Builder tracingMode;
+        android.webkit.TracingConfig build;
+        addCategories = ApiHelperForP$$ExternalSyntheticApiModelOutline11.m().addCategories(tracingConfig.getPredefinedCategories());
+        addCategories2 = addCategories.addCategories((Collection<String>) tracingConfig.getCustomIncludedCategories());
+        tracingMode = addCategories2.setTracingMode(tracingConfig.getTracingMode());
+        build = tracingMode.build();
+        tracingController.start(build);
+    }
+
+    @DoNotInline
+    public static boolean stop(@NonNull TracingController tracingController, @Nullable OutputStream outputStream, @NonNull Executor executor) {
+        boolean stop;
+        stop = tracingController.stop(outputStream, executor);
+        return stop;
+    }
+
+    @NonNull
+    @DoNotInline
+    public static ClassLoader getWebViewClassLoader() {
+        ClassLoader webViewClassLoader;
+        webViewClassLoader = WebView.getWebViewClassLoader();
+        return webViewClassLoader;
+    }
+
+    @NonNull
+    @DoNotInline
+    public static Looper getWebViewLooper(@NonNull WebView webView) {
+        Looper webViewLooper;
+        webViewLooper = webView.getWebViewLooper();
+        return webViewLooper;
+    }
+
+    @DoNotInline
+    public static void setDataDirectorySuffix(@NonNull String str) {
+        WebView.setDataDirectorySuffix(str);
+    }
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForQ$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForQ$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForQ$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForQ$$ExternalSyntheticApiModelOutline1 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForQ$$ExternalSyntheticApiModelOutline2.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForQ$$ExternalSyntheticApiModelOutline2 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForQ$$ExternalSyntheticApiModelOutline3.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForQ$$ExternalSyntheticApiModelOutline3 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForQ$$ExternalSyntheticApiModelOutline4.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForQ$$ExternalSyntheticApiModelOutline4 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForQ$$ExternalSyntheticApiModelOutline5.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForQ$$ExternalSyntheticApiModelOutline5 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForQ$$ExternalSyntheticApiModelOutline6.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForQ$$ExternalSyntheticApiModelOutline6 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForQ.java

@@ -0,0 +1,65 @@
+package androidx.webkit.internal;
+
+import android.webkit.WebSettings;
+import android.webkit.WebView;
+import android.webkit.WebViewRenderProcess;
+import androidx.annotation.DoNotInline;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.webkit.WebViewRenderProcessClient;
+import java.util.concurrent.Executor;
+
+@RequiresApi(29)
+/* loaded from: classes.dex */
+public class ApiHelperForQ {
+    private ApiHelperForQ() {
+    }
+
+    @DoNotInline
+    @Deprecated
+    public static void setForceDark(@NonNull WebSettings webSettings, int i) {
+        webSettings.setForceDark(i);
+    }
+
+    @DoNotInline
+    @Deprecated
+    public static int getForceDark(@NonNull WebSettings webSettings) {
+        int forceDark;
+        forceDark = webSettings.getForceDark();
+        return forceDark;
+    }
+
+    @Nullable
+    @DoNotInline
+    public static WebViewRenderProcess getWebViewRenderProcess(@NonNull WebView webView) {
+        WebViewRenderProcess webViewRenderProcess;
+        webViewRenderProcess = webView.getWebViewRenderProcess();
+        return webViewRenderProcess;
+    }
+
+    @DoNotInline
+    public static boolean terminate(@NonNull WebViewRenderProcess webViewRenderProcess) {
+        boolean terminate;
+        terminate = webViewRenderProcess.terminate();
+        return terminate;
+    }
+
+    @DoNotInline
+    public static void setWebViewRenderProcessClient(@NonNull WebView webView, @NonNull Executor executor, @Nullable WebViewRenderProcessClient webViewRenderProcessClient) {
+        webView.setWebViewRenderProcessClient(executor, webViewRenderProcessClient != null ? new WebViewRenderProcessClientFrameworkAdapter(webViewRenderProcessClient) : null);
+    }
+
+    @DoNotInline
+    public static void setWebViewRenderProcessClient(@NonNull WebView webView, @Nullable WebViewRenderProcessClient webViewRenderProcessClient) {
+        webView.setWebViewRenderProcessClient(webViewRenderProcessClient != null ? new WebViewRenderProcessClientFrameworkAdapter(webViewRenderProcessClient) : null);
+    }
+
+    @Nullable
+    @DoNotInline
+    public static android.webkit.WebViewRenderProcessClient getWebViewRenderProcessClient(@NonNull WebView webView) {
+        android.webkit.WebViewRenderProcessClient webViewRenderProcessClient;
+        webViewRenderProcessClient = webView.getWebViewRenderProcessClient();
+        return webViewRenderProcessClient;
+    }
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForTiramisu$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForTiramisu$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForTiramisu$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,5 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ApiHelperForTiramisu$$ExternalSyntheticApiModelOutline1 {
+}

decompiled/sources/androidx/webkit/internal/ApiHelperForTiramisu.java

@@ -0,0 +1,28 @@
+package androidx.webkit.internal;
+
+import android.content.ComponentName;
+import android.content.pm.PackageManager;
+import android.content.pm.ServiceInfo;
+import androidx.annotation.DoNotInline;
+import androidx.annotation.RequiresApi;
+
+@RequiresApi(33)
+/* loaded from: classes.dex */
+public class ApiHelperForTiramisu {
+    private ApiHelperForTiramisu() {
+    }
+
+    @DoNotInline
+    public static PackageManager.ComponentInfoFlags of(long j) {
+        PackageManager.ComponentInfoFlags of;
+        of = PackageManager.ComponentInfoFlags.of(j);
+        return of;
+    }
+
+    @DoNotInline
+    public static ServiceInfo getServiceInfo(PackageManager packageManager, ComponentName componentName, PackageManager.ComponentInfoFlags componentInfoFlags) throws PackageManager.NameNotFoundException {
+        ServiceInfo serviceInfo;
+        serviceInfo = packageManager.getServiceInfo(componentName, componentInfoFlags);
+        return serviceInfo;
+    }
+}

decompiled/sources/androidx/webkit/internal/AssetHelper.java

@@ -0,0 +1,107 @@
+package androidx.webkit.internal;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.util.TypedValue;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.zip.GZIPInputStream;
+
+/* loaded from: classes.dex */
+public class AssetHelper {
+    public static final String DEFAULT_MIME_TYPE = "text/plain";
+
+    @NonNull
+    private Context mContext;
+
+    public AssetHelper(@NonNull Context context) {
+        this.mContext = context;
+    }
+
+    @NonNull
+    private static InputStream handleSvgzStream(@NonNull String str, @NonNull InputStream inputStream) throws IOException {
+        return str.endsWith(".svgz") ? new GZIPInputStream(inputStream) : inputStream;
+    }
+
+    @NonNull
+    private static String removeLeadingSlash(@NonNull String str) {
+        return (str.length() <= 1 || str.charAt(0) != '/') ? str : str.substring(1);
+    }
+
+    private int getFieldId(@NonNull String str, @NonNull String str2) {
+        return this.mContext.getResources().getIdentifier(str2, str, this.mContext.getPackageName());
+    }
+
+    private int getValueType(int i) {
+        TypedValue typedValue = new TypedValue();
+        this.mContext.getResources().getValue(i, typedValue, true);
+        return typedValue.type;
+    }
+
+    @NonNull
+    public InputStream openResource(@NonNull String str) throws Resources.NotFoundException, IOException {
+        String removeLeadingSlash = removeLeadingSlash(str);
+        String[] split = removeLeadingSlash.split("/", -1);
+        if (split.length != 2) {
+            throw new IllegalArgumentException("Incorrect resource path: " + removeLeadingSlash);
+        }
+        String str2 = split[0];
+        String str3 = split[1];
+        int lastIndexOf = str3.lastIndexOf(46);
+        if (lastIndexOf != -1) {
+            str3 = str3.substring(0, lastIndexOf);
+        }
+        int fieldId = getFieldId(str2, str3);
+        int valueType = getValueType(fieldId);
+        if (valueType != 3) {
+            throw new IOException(String.format("Expected %s resource to be of TYPE_STRING but was %d", removeLeadingSlash, Integer.valueOf(valueType)));
+        }
+        return handleSvgzStream(removeLeadingSlash, this.mContext.getResources().openRawResource(fieldId));
+    }
+
+    @NonNull
+    public InputStream openAsset(@NonNull String str) throws IOException {
+        String removeLeadingSlash = removeLeadingSlash(str);
+        return handleSvgzStream(removeLeadingSlash, this.mContext.getAssets().open(removeLeadingSlash, 2));
+    }
+
+    @NonNull
+    public static InputStream openFile(@NonNull File file) throws FileNotFoundException, IOException {
+        return handleSvgzStream(file.getPath(), new FileInputStream(file));
+    }
+
+    @Nullable
+    public static File getCanonicalFileIfChild(@NonNull File file, @NonNull String str) throws IOException {
+        String canonicalDirPath = getCanonicalDirPath(file);
+        String canonicalPath = new File(file, str).getCanonicalPath();
+        if (canonicalPath.startsWith(canonicalDirPath)) {
+            return new File(canonicalPath);
+        }
+        return null;
+    }
+
+    @NonNull
+    public static String getCanonicalDirPath(@NonNull File file) throws IOException {
+        String canonicalPath = file.getCanonicalPath();
+        if (canonicalPath.endsWith("/")) {
+            return canonicalPath;
+        }
+        return canonicalPath + "/";
+    }
+
+    @NonNull
+    public static File getDataDir(@NonNull Context context) {
+        return ApiHelperForN.getDataDir(context);
+    }
+
+    @NonNull
+    public static String guessMimeType(@NonNull String str) {
+        String mimeFromFileName = MimeUtil.getMimeFromFileName(str);
+        return mimeFromFileName == null ? "text/plain" : mimeFromFileName;
+    }
+}

decompiled/sources/androidx/webkit/internal/ConditionallySupportedFeature.java

@@ -0,0 +1,11 @@
+package androidx.webkit.internal;
+
+import androidx.annotation.NonNull;
+
+/* loaded from: classes.dex */
+public interface ConditionallySupportedFeature {
+    @NonNull
+    String getPublicFeatureName();
+
+    boolean isSupported();
+}

decompiled/sources/androidx/webkit/internal/CookieManagerAdapter.java

@@ -0,0 +1,19 @@
+package androidx.webkit.internal;
+
+import androidx.annotation.NonNull;
+import java.util.List;
+import org.chromium.support_lib_boundary.WebViewCookieManagerBoundaryInterface;
+
+/* loaded from: classes.dex */
+public class CookieManagerAdapter {
+    private final WebViewCookieManagerBoundaryInterface mBoundaryInterface;
+
+    public CookieManagerAdapter(@NonNull WebViewCookieManagerBoundaryInterface webViewCookieManagerBoundaryInterface) {
+        this.mBoundaryInterface = webViewCookieManagerBoundaryInterface;
+    }
+
+    @NonNull
+    public List<String> getCookieInfo(@NonNull String str) {
+        return this.mBoundaryInterface.getCookieInfo(str);
+    }
+}

decompiled/sources/androidx/webkit/internal/FrameworkServiceWorkerClient.java

@@ -0,0 +1,25 @@
+package androidx.webkit.internal;
+
+import android.webkit.ServiceWorkerClient;
+import android.webkit.WebResourceRequest;
+import android.webkit.WebResourceResponse;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.webkit.ServiceWorkerClientCompat;
+
+@RequiresApi(24)
+/* loaded from: classes.dex */
+public class FrameworkServiceWorkerClient extends ServiceWorkerClient {
+    private final ServiceWorkerClientCompat mImpl;
+
+    public FrameworkServiceWorkerClient(@NonNull ServiceWorkerClientCompat serviceWorkerClientCompat) {
+        this.mImpl = serviceWorkerClientCompat;
+    }
+
+    @Override // android.webkit.ServiceWorkerClient
+    @Nullable
+    public WebResourceResponse shouldInterceptRequest(@NonNull WebResourceRequest webResourceRequest) {
+        return this.mImpl.shouldInterceptRequest(webResourceRequest);
+    }
+}

decompiled/sources/androidx/webkit/internal/IncompatibleApkWebViewProviderFactory.java

@@ -0,0 +1,72 @@
+package androidx.webkit.internal;
+
+import android.webkit.WebView;
+import androidx.annotation.NonNull;
+import org.chromium.support_lib_boundary.DropDataContentProviderBoundaryInterface;
+import org.chromium.support_lib_boundary.ProfileStoreBoundaryInterface;
+import org.chromium.support_lib_boundary.ProxyControllerBoundaryInterface;
+import org.chromium.support_lib_boundary.ServiceWorkerControllerBoundaryInterface;
+import org.chromium.support_lib_boundary.StaticsBoundaryInterface;
+import org.chromium.support_lib_boundary.TracingControllerBoundaryInterface;
+import org.chromium.support_lib_boundary.WebViewProviderBoundaryInterface;
+import org.chromium.support_lib_boundary.WebkitToCompatConverterBoundaryInterface;
+
+/* loaded from: classes.dex */
+public class IncompatibleApkWebViewProviderFactory implements WebViewProviderFactory {
+    private static final String[] EMPTY_STRING_ARRAY = new String[0];
+    private static final String UNSUPPORTED_EXCEPTION_EXPLANATION = "This should never happen, if this method was called it means we're trying to reach into WebView APK code on an incompatible device. This most likely means the current method is being called too early, or is being called on start-up rather than lazily";
+
+    @Override // androidx.webkit.internal.WebViewProviderFactory
+    @NonNull
+    public String[] getWebViewFeatures() {
+        return EMPTY_STRING_ARRAY;
+    }
+
+    @Override // androidx.webkit.internal.WebViewProviderFactory
+    @NonNull
+    public WebViewProviderBoundaryInterface createWebView(@NonNull WebView webView) {
+        throw new UnsupportedOperationException(UNSUPPORTED_EXCEPTION_EXPLANATION);
+    }
+
+    @Override // androidx.webkit.internal.WebViewProviderFactory
+    @NonNull
+    public WebkitToCompatConverterBoundaryInterface getWebkitToCompatConverter() {
+        throw new UnsupportedOperationException(UNSUPPORTED_EXCEPTION_EXPLANATION);
+    }
+
+    @Override // androidx.webkit.internal.WebViewProviderFactory
+    @NonNull
+    public StaticsBoundaryInterface getStatics() {
+        throw new UnsupportedOperationException(UNSUPPORTED_EXCEPTION_EXPLANATION);
+    }
+
+    @Override // androidx.webkit.internal.WebViewProviderFactory
+    @NonNull
+    public ServiceWorkerControllerBoundaryInterface getServiceWorkerController() {
+        throw new UnsupportedOperationException(UNSUPPORTED_EXCEPTION_EXPLANATION);
+    }
+
+    @Override // androidx.webkit.internal.WebViewProviderFactory
+    @NonNull
+    public TracingControllerBoundaryInterface getTracingController() {
+        throw new UnsupportedOperationException(UNSUPPORTED_EXCEPTION_EXPLANATION);
+    }
+
+    @Override // androidx.webkit.internal.WebViewProviderFactory
+    @NonNull
+    public ProxyControllerBoundaryInterface getProxyController() {
+        throw new UnsupportedOperationException(UNSUPPORTED_EXCEPTION_EXPLANATION);
+    }
+
+    @Override // androidx.webkit.internal.WebViewProviderFactory
+    @NonNull
+    public DropDataContentProviderBoundaryInterface getDropDataProvider() {
+        throw new UnsupportedOperationException(UNSUPPORTED_EXCEPTION_EXPLANATION);
+    }
+
+    @Override // androidx.webkit.internal.WebViewProviderFactory
+    @NonNull
+    public ProfileStoreBoundaryInterface getProfileStore() {
+        throw new UnsupportedOperationException(UNSUPPORTED_EXCEPTION_EXPLANATION);
+    }
+}

decompiled/sources/androidx/webkit/internal/JavaScriptReplyProxyImpl.java

@@ -0,0 +1,48 @@
+package androidx.webkit.internal;
+
+import androidx.annotation.NonNull;
+import androidx.webkit.JavaScriptReplyProxy;
+import java.lang.reflect.InvocationHandler;
+import java.util.Objects;
+import java.util.concurrent.Callable;
+import org.chromium.support_lib_boundary.JsReplyProxyBoundaryInterface;
+import org.chromium.support_lib_boundary.util.BoundaryInterfaceReflectionUtil;
+
+/* loaded from: classes.dex */
+public class JavaScriptReplyProxyImpl extends JavaScriptReplyProxy {
+    private JsReplyProxyBoundaryInterface mBoundaryInterface;
+
+    public JavaScriptReplyProxyImpl(@NonNull JsReplyProxyBoundaryInterface jsReplyProxyBoundaryInterface) {
+        this.mBoundaryInterface = jsReplyProxyBoundaryInterface;
+    }
+
+    @NonNull
+    public static JavaScriptReplyProxyImpl forInvocationHandler(@NonNull InvocationHandler invocationHandler) {
+        final JsReplyProxyBoundaryInterface jsReplyProxyBoundaryInterface = (JsReplyProxyBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(JsReplyProxyBoundaryInterface.class, invocationHandler);
+        return (JavaScriptReplyProxyImpl) jsReplyProxyBoundaryInterface.getOrCreatePeer(new Callable<Object>() { // from class: androidx.webkit.internal.JavaScriptReplyProxyImpl.1
+            @Override // java.util.concurrent.Callable
+            public Object call() {
+                return new JavaScriptReplyProxyImpl(JsReplyProxyBoundaryInterface.this);
+            }
+        });
+    }
+
+    @Override // androidx.webkit.JavaScriptReplyProxy
+    public void postMessage(@NonNull String str) {
+        if (WebViewFeatureInternal.WEB_MESSAGE_LISTENER.isSupportedByWebView()) {
+            this.mBoundaryInterface.postMessage(str);
+            return;
+        }
+        throw WebViewFeatureInternal.getUnsupportedOperationException();
+    }
+
+    @Override // androidx.webkit.JavaScriptReplyProxy
+    public void postMessage(@NonNull byte[] bArr) {
+        Objects.requireNonNull(bArr, "ArrayBuffer must be non-null");
+        if (WebViewFeatureInternal.WEB_MESSAGE_ARRAY_BUFFER.isSupportedByWebView()) {
+            this.mBoundaryInterface.postMessageWithPayload(BoundaryInterfaceReflectionUtil.createInvocationHandlerFor(new WebMessagePayloadAdapter(bArr)));
+            return;
+        }
+        throw WebViewFeatureInternal.getUnsupportedOperationException();
+    }
+}

decompiled/sources/androidx/webkit/internal/MimeUtil.java

@@ -0,0 +1,31 @@
+package androidx.webkit.internal;
+
+import java.net.URLConnection;
+
+/* loaded from: classes.dex */
+class MimeUtil {
+    public static String getMimeFromFileName(String str) {
+        if (str == null) {
+            return null;
+        }
+        String guessContentTypeFromName = URLConnection.guessContentTypeFromName(str);
+        return guessContentTypeFromName != null ? guessContentTypeFromName : guessHardcodedMime(str);
+    }
+
+    /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
+    /* JADX WARN: Code restructure failed: missing block: B:50:0x004f, code lost:
+    
+        if (r5.equals("mhtml") == false) goto L7;
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private static java.lang.String guessHardcodedMime(java.lang.String r5) {
+        /*
+            Method dump skipped, instructions count: 1104
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.webkit.internal.MimeUtil.guessHardcodedMime(java.lang.String):java.lang.String");
+    }
+}

decompiled/sources/androidx/webkit/internal/ProfileImpl.java

@@ -0,0 +1,67 @@
+package androidx.webkit.internal;
+
+import android.webkit.CookieManager;
+import android.webkit.GeolocationPermissions;
+import android.webkit.ServiceWorkerController;
+import android.webkit.WebStorage;
+import androidx.annotation.NonNull;
+import androidx.webkit.Profile;
+import org.chromium.support_lib_boundary.ProfileBoundaryInterface;
+
+/* loaded from: classes.dex */
+public class ProfileImpl implements Profile {
+    private final ProfileBoundaryInterface mProfileImpl;
+
+    public ProfileImpl(ProfileBoundaryInterface profileBoundaryInterface) {
+        this.mProfileImpl = profileBoundaryInterface;
+    }
+
+    private ProfileImpl() {
+        this.mProfileImpl = null;
+    }
+
+    @Override // androidx.webkit.Profile
+    @NonNull
+    public String getName() {
+        if (WebViewFeatureInternal.MULTI_PROFILE.isSupportedByWebView()) {
+            return this.mProfileImpl.getName();
+        }
+        throw WebViewFeatureInternal.getUnsupportedOperationException();
+    }
+
+    @Override // androidx.webkit.Profile
+    @NonNull
+    public CookieManager getCookieManager() throws IllegalStateException {
+        if (WebViewFeatureInternal.MULTI_PROFILE.isSupportedByWebView()) {
+            return this.mProfileImpl.getCookieManager();
+        }
+        throw WebViewFeatureInternal.getUnsupportedOperationException();
+    }
+
+    @Override // androidx.webkit.Profile
+    @NonNull
+    public WebStorage getWebStorage() throws IllegalStateException {
+        if (WebViewFeatureInternal.MULTI_PROFILE.isSupportedByWebView()) {
+            return this.mProfileImpl.getWebStorage();
+        }
+        throw WebViewFeatureInternal.getUnsupportedOperationException();
+    }
+
+    @Override // androidx.webkit.Profile
+    @NonNull
+    public GeolocationPermissions getGeolocationPermissions() throws IllegalStateException {
+        if (WebViewFeatureInternal.MULTI_PROFILE.isSupportedByWebView()) {
+            return this.mProfileImpl.getGeoLocationPermissions();
+        }
+        throw WebViewFeatureInternal.getUnsupportedOperationException();
+    }
+
+    @Override // androidx.webkit.Profile
+    @NonNull
+    public ServiceWorkerController getServiceWorkerController() throws IllegalStateException {
+        if (WebViewFeatureInternal.MULTI_PROFILE.isSupportedByWebView()) {
+            return this.mProfileImpl.getServiceWorkerController();
+        }
+        throw WebViewFeatureInternal.getUnsupportedOperationException();
+    }
+}

decompiled/sources/androidx/webkit/internal/ProfileStoreImpl.java

@@ -0,0 +1,72 @@
+package androidx.webkit.internal;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.webkit.Profile;
+import androidx.webkit.ProfileStore;
+import java.lang.reflect.InvocationHandler;
+import java.util.List;
+import org.chromium.support_lib_boundary.ProfileBoundaryInterface;
+import org.chromium.support_lib_boundary.ProfileStoreBoundaryInterface;
+import org.chromium.support_lib_boundary.util.BoundaryInterfaceReflectionUtil;
+
+/* loaded from: classes.dex */
+public class ProfileStoreImpl implements ProfileStore {
+    private static ProfileStore sInstance;
+    private final ProfileStoreBoundaryInterface mProfileStoreImpl;
+
+    private ProfileStoreImpl(ProfileStoreBoundaryInterface profileStoreBoundaryInterface) {
+        this.mProfileStoreImpl = profileStoreBoundaryInterface;
+    }
+
+    private ProfileStoreImpl() {
+        this.mProfileStoreImpl = null;
+    }
+
+    @NonNull
+    public static ProfileStore getInstance() {
+        if (sInstance == null) {
+            sInstance = new ProfileStoreImpl(WebViewGlueCommunicator.getFactory().getProfileStore());
+        }
+        return sInstance;
+    }
+
+    @Override // androidx.webkit.ProfileStore
+    @NonNull
+    public Profile getOrCreateProfile(@NonNull String str) {
+        if (WebViewFeatureInternal.MULTI_PROFILE.isSupportedByWebView()) {
+            return new ProfileImpl((ProfileBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(ProfileBoundaryInterface.class, this.mProfileStoreImpl.getOrCreateProfile(str)));
+        }
+        throw WebViewFeatureInternal.getUnsupportedOperationException();
+    }
+
+    @Override // androidx.webkit.ProfileStore
+    @Nullable
+    public Profile getProfile(@NonNull String str) {
+        if (WebViewFeatureInternal.MULTI_PROFILE.isSupportedByWebView()) {
+            InvocationHandler profile = this.mProfileStoreImpl.getProfile(str);
+            if (profile != null) {
+                return new ProfileImpl((ProfileBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(ProfileBoundaryInterface.class, profile));
+            }
+            return null;
+        }
+        throw WebViewFeatureInternal.getUnsupportedOperationException();
+    }
+
+    @Override // androidx.webkit.ProfileStore
+    @NonNull
+    public List<String> getAllProfileNames() {
+        if (WebViewFeatureInternal.MULTI_PROFILE.isSupportedByWebView()) {
+            return this.mProfileStoreImpl.getAllProfileNames();
+        }
+        throw WebViewFeatureInternal.getUnsupportedOperationException();
+    }
+
+    @Override // androidx.webkit.ProfileStore
+    public boolean deleteProfile(@NonNull String str) throws IllegalStateException {
+        if (WebViewFeatureInternal.MULTI_PROFILE.isSupportedByWebView()) {
+            return this.mProfileStoreImpl.deleteProfile(str);
+        }
+        throw WebViewFeatureInternal.getUnsupportedOperationException();
+    }
+}

decompiled/sources/androidx/webkit/internal/ProxyControllerImpl.java

@@ -0,0 +1,60 @@
+package androidx.webkit.internal;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.VisibleForTesting;
+import androidx.webkit.ProxyConfig;
+import androidx.webkit.ProxyController;
+import androidx.webkit.internal.ApiFeature;
+import java.lang.reflect.Array;
+import java.util.List;
+import java.util.concurrent.Executor;
+import org.chromium.support_lib_boundary.ProxyControllerBoundaryInterface;
+
+/* loaded from: classes.dex */
+public class ProxyControllerImpl extends ProxyController {
+    private ProxyControllerBoundaryInterface mBoundaryInterface;
+
+    @Override // androidx.webkit.ProxyController
+    public void setProxyOverride(@NonNull ProxyConfig proxyConfig, @NonNull Executor executor, @NonNull Runnable runnable) {
+        ApiFeature.NoFramework noFramework = WebViewFeatureInternal.PROXY_OVERRIDE;
+        ApiFeature.NoFramework noFramework2 = WebViewFeatureInternal.PROXY_OVERRIDE_REVERSE_BYPASS;
+        String[][] proxyRulesToStringArray = proxyRulesToStringArray(proxyConfig.getProxyRules());
+        String[] strArr = (String[]) proxyConfig.getBypassRules().toArray(new String[0]);
+        if (noFramework.isSupportedByWebView() && !proxyConfig.isReverseBypassEnabled()) {
+            getBoundaryInterface().setProxyOverride(proxyRulesToStringArray, strArr, runnable, executor);
+        } else {
+            if (noFramework.isSupportedByWebView() && noFramework2.isSupportedByWebView()) {
+                getBoundaryInterface().setProxyOverride(proxyRulesToStringArray, strArr, runnable, executor, proxyConfig.isReverseBypassEnabled());
+                return;
+            }
+            throw WebViewFeatureInternal.getUnsupportedOperationException();
+        }
+    }
+
+    @Override // androidx.webkit.ProxyController
+    public void clearProxyOverride(@NonNull Executor executor, @NonNull Runnable runnable) {
+        if (WebViewFeatureInternal.PROXY_OVERRIDE.isSupportedByWebView()) {
+            getBoundaryInterface().clearProxyOverride(runnable, executor);
+            return;
+        }
+        throw WebViewFeatureInternal.getUnsupportedOperationException();
+    }
+
+    @NonNull
+    @VisibleForTesting
+    public static String[][] proxyRulesToStringArray(@NonNull List<ProxyConfig.ProxyRule> list) {
+        String[][] strArr = (String[][]) Array.newInstance((Class<?>) String.class, list.size(), 2);
+        for (int i = 0; i < list.size(); i++) {
+            strArr[i][0] = list.get(i).getSchemeFilter();
+            strArr[i][1] = list.get(i).getUrl();
+        }
+        return strArr;
+    }
+
+    private ProxyControllerBoundaryInterface getBoundaryInterface() {
+        if (this.mBoundaryInterface == null) {
+            this.mBoundaryInterface = WebViewGlueCommunicator.getFactory().getProxyController();
+        }
+        return this.mBoundaryInterface;
+    }
+}

decompiled/sources/androidx/webkit/internal/SafeBrowsingResponseImpl.java

@@ -0,0 +1,82 @@
+package androidx.webkit.internal;
+
+import android.webkit.SafeBrowsingResponse;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+import androidx.webkit.SafeBrowsingResponseCompat;
+import androidx.webkit.internal.ApiFeature;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Proxy;
+import org.chromium.support_lib_boundary.SafeBrowsingResponseBoundaryInterface;
+import org.chromium.support_lib_boundary.util.BoundaryInterfaceReflectionUtil;
+
+/* loaded from: classes.dex */
+public class SafeBrowsingResponseImpl extends SafeBrowsingResponseCompat {
+    private SafeBrowsingResponseBoundaryInterface mBoundaryInterface;
+    private SafeBrowsingResponse mFrameworksImpl;
+
+    public SafeBrowsingResponseImpl(@NonNull InvocationHandler invocationHandler) {
+        this.mBoundaryInterface = (SafeBrowsingResponseBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(SafeBrowsingResponseBoundaryInterface.class, invocationHandler);
+    }
+
+    public SafeBrowsingResponseImpl(@NonNull SafeBrowsingResponse safeBrowsingResponse) {
+        this.mFrameworksImpl = safeBrowsingResponse;
+    }
+
+    @RequiresApi(27)
+    private SafeBrowsingResponse getFrameworksImpl() {
+        if (this.mFrameworksImpl == null) {
+            this.mFrameworksImpl = WebViewGlueCommunicator.getCompatConverter().convertSafeBrowsingResponse(Proxy.getInvocationHandler(this.mBoundaryInterface));
+        }
+        return this.mFrameworksImpl;
+    }
+
+    private SafeBrowsingResponseBoundaryInterface getBoundaryInterface() {
+        if (this.mBoundaryInterface == null) {
+            this.mBoundaryInterface = (SafeBrowsingResponseBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(SafeBrowsingResponseBoundaryInterface.class, WebViewGlueCommunicator.getCompatConverter().convertSafeBrowsingResponse(this.mFrameworksImpl));
+        }
+        return this.mBoundaryInterface;
+    }
+
+    @Override // androidx.webkit.SafeBrowsingResponseCompat
+    public void showInterstitial(boolean z) {
+        ApiFeature.O_MR1 o_mr1 = WebViewFeatureInternal.SAFE_BROWSING_RESPONSE_SHOW_INTERSTITIAL;
+        if (o_mr1.isSupportedByFramework()) {
+            ApiHelperForOMR1.showInterstitial(getFrameworksImpl(), z);
+        } else {
+            if (o_mr1.isSupportedByWebView()) {
+                getBoundaryInterface().showInterstitial(z);
+                return;
+            }
+            throw WebViewFeatureInternal.getUnsupportedOperationException();
+        }
+    }
+
+    @Override // androidx.webkit.SafeBrowsingResponseCompat
+    public void proceed(boolean z) {
+        ApiFeature.O_MR1 o_mr1 = WebViewFeatureInternal.SAFE_BROWSING_RESPONSE_PROCEED;
+        if (o_mr1.isSupportedByFramework()) {
+            ApiHelperForOMR1.proceed(getFrameworksImpl(), z);
+        } else {
+            if (o_mr1.isSupportedByWebView()) {
+                getBoundaryInterface().proceed(z);
+                return;
+            }
+            throw WebViewFeatureInternal.getUnsupportedOperationException();
+        }
+    }
+
+    @Override // androidx.webkit.SafeBrowsingResponseCompat
+    public void backToSafety(boolean z) {
+        ApiFeature.O_MR1 o_mr1 = WebViewFeatureInternal.SAFE_BROWSING_RESPONSE_BACK_TO_SAFETY;
+        if (o_mr1.isSupportedByFramework()) {
+            ApiHelperForOMR1.backToSafety(getFrameworksImpl(), z);
+        } else {
+            if (o_mr1.isSupportedByWebView()) {
+                getBoundaryInterface().backToSafety(z);
+                return;
+            }
+            throw WebViewFeatureInternal.getUnsupportedOperationException();
+        }
+    }
+}

decompiled/sources/androidx/webkit/internal/ScriptHandlerImpl.java

@@ -0,0 +1,26 @@
+package androidx.webkit.internal;
+
+import androidx.annotation.NonNull;
+import androidx.webkit.ScriptHandler;
+import java.lang.reflect.InvocationHandler;
+import org.chromium.support_lib_boundary.ScriptHandlerBoundaryInterface;
+import org.chromium.support_lib_boundary.util.BoundaryInterfaceReflectionUtil;
+
+/* loaded from: classes.dex */
+public class ScriptHandlerImpl implements ScriptHandler {
+    private final ScriptHandlerBoundaryInterface mBoundaryInterface;
+
+    private ScriptHandlerImpl(@NonNull ScriptHandlerBoundaryInterface scriptHandlerBoundaryInterface) {
+        this.mBoundaryInterface = scriptHandlerBoundaryInterface;
+    }
+
+    @Override // androidx.webkit.ScriptHandler
+    public void remove() {
+        this.mBoundaryInterface.remove();
+    }
+
+    @NonNull
+    public static ScriptHandlerImpl toScriptHandler(@NonNull InvocationHandler invocationHandler) {
+        return new ScriptHandlerImpl((ScriptHandlerBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(ScriptHandlerBoundaryInterface.class, invocationHandler));
+    }
+}

decompiled/sources/androidx/webkit/internal/ServiceWorkerClientAdapter.java

@@ -0,0 +1,30 @@
+package androidx.webkit.internal;
+
+import android.webkit.WebResourceRequest;
+import android.webkit.WebResourceResponse;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.webkit.ServiceWorkerClientCompat;
+import androidx.webkit.WebViewFeature;
+import org.chromium.support_lib_boundary.ServiceWorkerClientBoundaryInterface;
+
+/* loaded from: classes.dex */
+public class ServiceWorkerClientAdapter implements ServiceWorkerClientBoundaryInterface {
+    private final ServiceWorkerClientCompat mClient;
+
+    @Override // org.chromium.support_lib_boundary.FeatureFlagHolderBoundaryInterface
+    @NonNull
+    public String[] getSupportedFeatures() {
+        return new String[]{WebViewFeature.SERVICE_WORKER_SHOULD_INTERCEPT_REQUEST};
+    }
+
+    public ServiceWorkerClientAdapter(@NonNull ServiceWorkerClientCompat serviceWorkerClientCompat) {
+        this.mClient = serviceWorkerClientCompat;
+    }
+
+    @Override // org.chromium.support_lib_boundary.ServiceWorkerClientBoundaryInterface
+    @Nullable
+    public WebResourceResponse shouldInterceptRequest(@NonNull WebResourceRequest webResourceRequest) {
+        return this.mClient.shouldInterceptRequest(webResourceRequest);
+    }
+}

decompiled/sources/androidx/webkit/internal/ServiceWorkerControllerImpl.java

@@ -0,0 +1,80 @@
+package androidx.webkit.internal;
+
+import android.webkit.ServiceWorkerController;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.webkit.ServiceWorkerClientCompat;
+import androidx.webkit.ServiceWorkerControllerCompat;
+import androidx.webkit.ServiceWorkerWebSettingsCompat;
+import androidx.webkit.internal.ApiFeature;
+import org.chromium.support_lib_boundary.ServiceWorkerControllerBoundaryInterface;
+import org.chromium.support_lib_boundary.util.BoundaryInterfaceReflectionUtil;
+
+/* loaded from: classes.dex */
+public class ServiceWorkerControllerImpl extends ServiceWorkerControllerCompat {
+    private ServiceWorkerControllerBoundaryInterface mBoundaryInterface;
+    private ServiceWorkerController mFrameworksImpl;
+    private final ServiceWorkerWebSettingsCompat mWebSettings;
+
+    @Override // androidx.webkit.ServiceWorkerControllerCompat
+    @NonNull
+    public ServiceWorkerWebSettingsCompat getServiceWorkerWebSettings() {
+        return this.mWebSettings;
+    }
+
+    public ServiceWorkerControllerImpl() {
+        ApiFeature.N n = WebViewFeatureInternal.SERVICE_WORKER_BASIC_USAGE;
+        if (n.isSupportedByFramework()) {
+            this.mFrameworksImpl = ApiHelperForN.getServiceWorkerControllerInstance();
+            this.mBoundaryInterface = null;
+            this.mWebSettings = ApiHelperForN.getServiceWorkerWebSettingsImpl(getFrameworksImpl());
+        } else {
+            if (n.isSupportedByWebView()) {
+                this.mFrameworksImpl = null;
+                ServiceWorkerControllerBoundaryInterface serviceWorkerController = WebViewGlueCommunicator.getFactory().getServiceWorkerController();
+                this.mBoundaryInterface = serviceWorkerController;
+                this.mWebSettings = new ServiceWorkerWebSettingsImpl(serviceWorkerController.getServiceWorkerWebSettings());
+                return;
+            }
+            throw WebViewFeatureInternal.getUnsupportedOperationException();
+        }
+    }
+
+    @RequiresApi(24)
+    private ServiceWorkerController getFrameworksImpl() {
+        if (this.mFrameworksImpl == null) {
+            this.mFrameworksImpl = ApiHelperForN.getServiceWorkerControllerInstance();
+        }
+        return this.mFrameworksImpl;
+    }
+
+    private ServiceWorkerControllerBoundaryInterface getBoundaryInterface() {
+        if (this.mBoundaryInterface == null) {
+            this.mBoundaryInterface = WebViewGlueCommunicator.getFactory().getServiceWorkerController();
+        }
+        return this.mBoundaryInterface;
+    }
+
+    @Override // androidx.webkit.ServiceWorkerControllerCompat
+    public void setServiceWorkerClient(@Nullable ServiceWorkerClientCompat serviceWorkerClientCompat) {
+        ApiFeature.N n = WebViewFeatureInternal.SERVICE_WORKER_BASIC_USAGE;
+        if (n.isSupportedByFramework()) {
+            if (serviceWorkerClientCompat == null) {
+                ApiHelperForN.setServiceWorkerClient(getFrameworksImpl(), null);
+                return;
+            } else {
+                ApiHelperForN.setServiceWorkerClientCompat(getFrameworksImpl(), serviceWorkerClientCompat);
+                return;
+            }
+        }
+        if (!n.isSupportedByWebView()) {
+            throw WebViewFeatureInternal.getUnsupportedOperationException();
+        }
+        if (serviceWorkerClientCompat == null) {
+            getBoundaryInterface().setServiceWorkerClient(null);
+        } else {
+            getBoundaryInterface().setServiceWorkerClient(BoundaryInterfaceReflectionUtil.createInvocationHandlerFor(new ServiceWorkerClientAdapter(serviceWorkerClientCompat)));
+        }
+    }
+}

decompiled/sources/androidx/webkit/internal/ServiceWorkerWebSettingsImpl.java

@@ -0,0 +1,163 @@
+package androidx.webkit.internal;
+
+import android.webkit.ServiceWorkerWebSettings;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+import androidx.webkit.ServiceWorkerWebSettingsCompat;
+import androidx.webkit.internal.ApiFeature;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Proxy;
+import java.util.Set;
+import org.chromium.support_lib_boundary.ServiceWorkerWebSettingsBoundaryInterface;
+import org.chromium.support_lib_boundary.util.BoundaryInterfaceReflectionUtil;
+
+/* loaded from: classes.dex */
+public class ServiceWorkerWebSettingsImpl extends ServiceWorkerWebSettingsCompat {
+    private ServiceWorkerWebSettingsBoundaryInterface mBoundaryInterface;
+    private ServiceWorkerWebSettings mFrameworksImpl;
+
+    public ServiceWorkerWebSettingsImpl(@NonNull ServiceWorkerWebSettings serviceWorkerWebSettings) {
+        this.mFrameworksImpl = serviceWorkerWebSettings;
+    }
+
+    public ServiceWorkerWebSettingsImpl(@NonNull InvocationHandler invocationHandler) {
+        this.mBoundaryInterface = (ServiceWorkerWebSettingsBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(ServiceWorkerWebSettingsBoundaryInterface.class, invocationHandler);
+    }
+
+    @RequiresApi(24)
+    private ServiceWorkerWebSettings getFrameworksImpl() {
+        if (this.mFrameworksImpl == null) {
+            this.mFrameworksImpl = WebViewGlueCommunicator.getCompatConverter().convertServiceWorkerSettings(Proxy.getInvocationHandler(this.mBoundaryInterface));
+        }
+        return this.mFrameworksImpl;
+    }
+
+    private ServiceWorkerWebSettingsBoundaryInterface getBoundaryInterface() {
+        if (this.mBoundaryInterface == null) {
+            this.mBoundaryInterface = (ServiceWorkerWebSettingsBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(ServiceWorkerWebSettingsBoundaryInterface.class, WebViewGlueCommunicator.getCompatConverter().convertServiceWorkerSettings(this.mFrameworksImpl));
+        }
+        return this.mBoundaryInterface;
+    }
+
+    @Override // androidx.webkit.ServiceWorkerWebSettingsCompat
+    public void setCacheMode(int i) {
+        ApiFeature.N n = WebViewFeatureInternal.SERVICE_WORKER_CACHE_MODE;
+        if (n.isSupportedByFramework()) {
+            ApiHelperForN.setCacheMode(getFrameworksImpl(), i);
+        } else {
+            if (n.isSupportedByWebView()) {
+                getBoundaryInterface().setCacheMode(i);
+                return;
+            }
+            throw WebViewFeatureInternal.getUnsupportedOperationException();
+        }
+    }
+
+    @Override // androidx.webkit.ServiceWorkerWebSettingsCompat
+    public int getCacheMode() {
+        ApiFeature.N n = WebViewFeatureInternal.SERVICE_WORKER_CACHE_MODE;
+        if (n.isSupportedByFramework()) {
+            return ApiHelperForN.getCacheMode(getFrameworksImpl());
+        }
+        if (n.isSupportedByWebView()) {
+            return getBoundaryInterface().getCacheMode();
+        }
+        throw WebViewFeatureInternal.getUnsupportedOperationException();
+    }
+
+    @Override // androidx.webkit.ServiceWorkerWebSettingsCompat
+    public void setAllowContentAccess(boolean z) {
+        ApiFeature.N n = WebViewFeatureInternal.SERVICE_WORKER_CONTENT_ACCESS;
+        if (n.isSupportedByFramework()) {
+            ApiHelperForN.setAllowContentAccess(getFrameworksImpl(), z);
+        } else {
+            if (n.isSupportedByWebView()) {
+                getBoundaryInterface().setAllowContentAccess(z);
+                return;
+            }
+            throw WebViewFeatureInternal.getUnsupportedOperationException();
+        }
+    }
+
+    @Override // androidx.webkit.ServiceWorkerWebSettingsCompat
+    public boolean getAllowContentAccess() {
+        ApiFeature.N n = WebViewFeatureInternal.SERVICE_WORKER_CONTENT_ACCESS;
+        if (n.isSupportedByFramework()) {
+            return ApiHelperForN.getAllowContentAccess(getFrameworksImpl());
+        }
+        if (n.isSupportedByWebView()) {
+            return getBoundaryInterface().getAllowContentAccess();
+        }
+        throw WebViewFeatureInternal.getUnsupportedOperationException();
+    }
+
+    @Override // androidx.webkit.ServiceWorkerWebSettingsCompat
+    public void setAllowFileAccess(boolean z) {
+        ApiFeature.N n = WebViewFeatureInternal.SERVICE_WORKER_FILE_ACCESS;
+        if (n.isSupportedByFramework()) {
+            ApiHelperForN.setAllowFileAccess(getFrameworksImpl(), z);
+        } else {
+            if (n.isSupportedByWebView()) {
+                getBoundaryInterface().setAllowFileAccess(z);
+                return;
+            }
+            throw WebViewFeatureInternal.getUnsupportedOperationException();
+        }
+    }
+
+    @Override // androidx.webkit.ServiceWorkerWebSettingsCompat
+    public boolean getAllowFileAccess() {
+        ApiFeature.N n = WebViewFeatureInternal.SERVICE_WORKER_FILE_ACCESS;
+        if (n.isSupportedByFramework()) {
+            return ApiHelperForN.getAllowFileAccess(getFrameworksImpl());
+        }
+        if (n.isSupportedByWebView()) {
+            return getBoundaryInterface().getAllowFileAccess();
+        }
+        throw WebViewFeatureInternal.getUnsupportedOperationException();
+    }
+
+    @Override // androidx.webkit.ServiceWorkerWebSettingsCompat
+    public void setBlockNetworkLoads(boolean z) {
+        ApiFeature.N n = WebViewFeatureInternal.SERVICE_WORKER_BLOCK_NETWORK_LOADS;
+        if (n.isSupportedByFramework()) {
+            ApiHelperForN.setBlockNetworkLoads(getFrameworksImpl(), z);
+        } else {
+            if (n.isSupportedByWebView()) {
+                getBoundaryInterface().setBlockNetworkLoads(z);
+                return;
+            }
+            throw WebViewFeatureInternal.getUnsupportedOperationException();
+        }
+    }
+
+    @Override // androidx.webkit.ServiceWorkerWebSettingsCompat
+    public boolean getBlockNetworkLoads() {
+        ApiFeature.N n = WebViewFeatureInternal.SERVICE_WORKER_BLOCK_NETWORK_LOADS;
+        if (n.isSupportedByFramework()) {
+            return ApiHelperForN.getBlockNetworkLoads(getFrameworksImpl());
+        }
+        if (n.isSupportedByWebView()) {
+            return getBoundaryInterface().getBlockNetworkLoads();
+        }
+        throw WebViewFeatureInternal.getUnsupportedOperationException();
+    }
+
+    @Override // androidx.webkit.ServiceWorkerWebSettingsCompat
+    @NonNull
+    public Set<String> getRequestedWithHeaderOriginAllowList() {
+        if (WebViewFeatureInternal.REQUESTED_WITH_HEADER_ALLOW_LIST.isSupportedByWebView()) {
+            return getBoundaryInterface().getRequestedWithHeaderOriginAllowList();
+        }
+        throw WebViewFeatureInternal.getUnsupportedOperationException();
+    }
+
+    @Override // androidx.webkit.ServiceWorkerWebSettingsCompat
+    public void setRequestedWithHeaderOriginAllowList(@NonNull Set<String> set) {
+        if (WebViewFeatureInternal.REQUESTED_WITH_HEADER_ALLOW_LIST.isSupportedByWebView()) {
+            getBoundaryInterface().setRequestedWithHeaderOriginAllowList(set);
+            return;
+        }
+        throw WebViewFeatureInternal.getUnsupportedOperationException();
+    }
+}

decompiled/sources/androidx/webkit/internal/StartupApiFeature.java

@@ -0,0 +1,106 @@
+package androidx.webkit.internal;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.ServiceInfo;
+import android.os.Build;
+import android.os.Bundle;
+import androidx.annotation.ChecksSdkIntAtLeast;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+import androidx.webkit.WebViewCompat;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+/* loaded from: classes.dex */
+public abstract class StartupApiFeature {
+    static final /* synthetic */ boolean $assertionsDisabled = false;
+
+    @VisibleForTesting
+    public static final String METADATA_HOLDER_SERVICE_NAME = "org.chromium.android_webview.services.StartupFeatureMetadataHolder";
+    private static final Set<StartupApiFeature> sValues = new HashSet();
+    private final String mInternalFeatureValue;
+    private final String mPublicFeatureValue;
+
+    @NonNull
+    public String getPublicFeatureName() {
+        return this.mPublicFeatureValue;
+    }
+
+    public abstract boolean isSupportedByFramework();
+
+    public StartupApiFeature(@NonNull String str, @NonNull String str2) {
+        this.mPublicFeatureValue = str;
+        this.mInternalFeatureValue = str2;
+        sValues.add(this);
+    }
+
+    public boolean isSupported(@NonNull Context context) {
+        return isSupportedByFramework() || isSupportedByWebView(context);
+    }
+
+    @ChecksSdkIntAtLeast(api = 21)
+    public boolean isSupportedByWebView(@NonNull Context context) {
+        Bundle metaDataFromWebViewManifestOrNull = getMetaDataFromWebViewManifestOrNull(context);
+        if (metaDataFromWebViewManifestOrNull == null) {
+            return false;
+        }
+        return metaDataFromWebViewManifestOrNull.containsKey(this.mInternalFeatureValue);
+    }
+
+    @NonNull
+    public static Set<StartupApiFeature> values() {
+        return Collections.unmodifiableSet(sValues);
+    }
+
+    @Nullable
+    private static Bundle getMetaDataFromWebViewManifestOrNull(@NonNull Context context) {
+        PackageInfo currentWebViewPackage = WebViewCompat.getCurrentWebViewPackage(context);
+        if (currentWebViewPackage == null) {
+            return null;
+        }
+        ComponentName componentName = new ComponentName(currentWebViewPackage.packageName, METADATA_HOLDER_SERVICE_NAME);
+        if (Build.VERSION.SDK_INT >= 33) {
+            try {
+                return ApiHelperForTiramisu.getServiceInfo(context.getPackageManager(), componentName, ApiHelperForTiramisu.of(640L)).metaData;
+            } catch (PackageManager.NameNotFoundException unused) {
+                return null;
+            }
+        }
+        try {
+            return getServiceInfo(context, componentName, 640).metaData;
+        } catch (PackageManager.NameNotFoundException unused2) {
+            return null;
+        }
+    }
+
+    private static ServiceInfo getServiceInfo(@NonNull Context context, ComponentName componentName, int i) throws PackageManager.NameNotFoundException {
+        return context.getPackageManager().getServiceInfo(componentName, i);
+    }
+
+    public static class P extends StartupApiFeature {
+        @Override // androidx.webkit.internal.StartupApiFeature
+        public final boolean isSupportedByFramework() {
+            return Build.VERSION.SDK_INT >= 28;
+        }
+
+        public P(@NonNull String str, @NonNull String str2) {
+            super(str, str2);
+        }
+    }
+
+    public static class NoFramework extends StartupApiFeature {
+        @Override // androidx.webkit.internal.StartupApiFeature
+        public final boolean isSupportedByFramework() {
+            return false;
+        }
+
+        public NoFramework(@NonNull String str, @NonNull String str2) {
+            super(str, str2);
+        }
+    }
+}

decompiled/sources/androidx/webkit/internal/StartupFeatures.java

@@ -0,0 +1,10 @@
+package androidx.webkit.internal;
+
+/* loaded from: classes.dex */
+public class StartupFeatures {
+    public static final String STARTUP_FEATURE_SET_DATA_DIRECTORY_SUFFIX = "STARTUP_FEATURE_SET_DATA_DIRECTORY_SUFFIX";
+    public static final String STARTUP_FEATURE_SET_DIRECTORY_BASE_PATH = "STARTUP_FEATURE_SET_DIRECTORY_BASE_PATH";
+
+    private StartupFeatures() {
+    }
+}

decompiled/sources/androidx/webkit/internal/TracingControllerImpl.java

@@ -0,0 +1,88 @@
+package androidx.webkit.internal;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.webkit.TracingConfig;
+import androidx.webkit.TracingController;
+import androidx.webkit.internal.ApiFeature;
+import java.io.OutputStream;
+import java.util.concurrent.Executor;
+import org.chromium.support_lib_boundary.TracingControllerBoundaryInterface;
+
+/* loaded from: classes.dex */
+public class TracingControllerImpl extends TracingController {
+    private TracingControllerBoundaryInterface mBoundaryInterface;
+    private android.webkit.TracingController mFrameworksImpl;
+
+    public TracingControllerImpl() {
+        ApiFeature.P p = WebViewFeatureInternal.TRACING_CONTROLLER_BASIC_USAGE;
+        if (p.isSupportedByFramework()) {
+            this.mFrameworksImpl = ApiHelperForP.getTracingControllerInstance();
+            this.mBoundaryInterface = null;
+        } else {
+            if (p.isSupportedByWebView()) {
+                this.mFrameworksImpl = null;
+                this.mBoundaryInterface = WebViewGlueCommunicator.getFactory().getTracingController();
+                return;
+            }
+            throw WebViewFeatureInternal.getUnsupportedOperationException();
+        }
+    }
+
+    @RequiresApi(28)
+    private android.webkit.TracingController getFrameworksImpl() {
+        if (this.mFrameworksImpl == null) {
+            this.mFrameworksImpl = ApiHelperForP.getTracingControllerInstance();
+        }
+        return this.mFrameworksImpl;
+    }
+
+    private TracingControllerBoundaryInterface getBoundaryInterface() {
+        if (this.mBoundaryInterface == null) {
+            this.mBoundaryInterface = WebViewGlueCommunicator.getFactory().getTracingController();
+        }
+        return this.mBoundaryInterface;
+    }
+
+    @Override // androidx.webkit.TracingController
+    public boolean isTracing() {
+        ApiFeature.P p = WebViewFeatureInternal.TRACING_CONTROLLER_BASIC_USAGE;
+        if (p.isSupportedByFramework()) {
+            return ApiHelperForP.isTracing(getFrameworksImpl());
+        }
+        if (p.isSupportedByWebView()) {
+            return getBoundaryInterface().isTracing();
+        }
+        throw WebViewFeatureInternal.getUnsupportedOperationException();
+    }
+
+    @Override // androidx.webkit.TracingController
+    public void start(@NonNull TracingConfig tracingConfig) {
+        if (tracingConfig == null) {
+            throw new IllegalArgumentException("Tracing config must be non null");
+        }
+        ApiFeature.P p = WebViewFeatureInternal.TRACING_CONTROLLER_BASIC_USAGE;
+        if (p.isSupportedByFramework()) {
+            ApiHelperForP.start(getFrameworksImpl(), tracingConfig);
+        } else {
+            if (p.isSupportedByWebView()) {
+                getBoundaryInterface().start(tracingConfig.getPredefinedCategories(), tracingConfig.getCustomIncludedCategories(), tracingConfig.getTracingMode());
+                return;
+            }
+            throw WebViewFeatureInternal.getUnsupportedOperationException();
+        }
+    }
+
+    @Override // androidx.webkit.TracingController
+    public boolean stop(@Nullable OutputStream outputStream, @NonNull Executor executor) {
+        ApiFeature.P p = WebViewFeatureInternal.TRACING_CONTROLLER_BASIC_USAGE;
+        if (p.isSupportedByFramework()) {
+            return ApiHelperForP.stop(getFrameworksImpl(), outputStream, executor);
+        }
+        if (p.isSupportedByWebView()) {
+            return getBoundaryInterface().stop(outputStream, executor);
+        }
+        throw WebViewFeatureInternal.getUnsupportedOperationException();
+    }
+}

decompiled/sources/androidx/webkit/internal/UserAgentMetadataInternal.java

@@ -0,0 +1,97 @@
+package androidx.webkit.internal;
+
+import androidx.annotation.NonNull;
+import androidx.webkit.UserAgentMetadata;
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public class UserAgentMetadataInternal {
+    private static final String ARCHITECTURE = "ARCHITECTURE";
+    private static final String BITNESS = "BITNESS";
+    private static final int BRAND_VERSION_LENGTH = 3;
+    private static final String BRAND_VERSION_LIST = "BRAND_VERSION_LIST";
+    private static final String FULL_VERSION = "FULL_VERSION";
+    private static final String MOBILE = "MOBILE";
+    private static final String MODEL = "MODEL";
+    private static final String PLATFORM = "PLATFORM";
+    private static final String PLATFORM_VERSION = "PLATFORM_VERSION";
+    private static final String WOW64 = "WOW64";
+
+    @NonNull
+    public static Map<String, Object> convertUserAgentMetadataToMap(@NonNull UserAgentMetadata userAgentMetadata) {
+        HashMap hashMap = new HashMap();
+        hashMap.put(BRAND_VERSION_LIST, getBrandVersionArray(userAgentMetadata.getBrandVersionList()));
+        hashMap.put(FULL_VERSION, userAgentMetadata.getFullVersion());
+        hashMap.put(PLATFORM, userAgentMetadata.getPlatform());
+        hashMap.put(PLATFORM_VERSION, userAgentMetadata.getPlatformVersion());
+        hashMap.put(ARCHITECTURE, userAgentMetadata.getArchitecture());
+        hashMap.put(MODEL, userAgentMetadata.getModel());
+        hashMap.put(MOBILE, Boolean.valueOf(userAgentMetadata.isMobile()));
+        hashMap.put(BITNESS, Integer.valueOf(userAgentMetadata.getBitness()));
+        hashMap.put(WOW64, Boolean.valueOf(userAgentMetadata.isWow64()));
+        return hashMap;
+    }
+
+    private static String[][] getBrandVersionArray(List<UserAgentMetadata.BrandVersion> list) {
+        if (list == null || list.isEmpty()) {
+            return null;
+        }
+        String[][] strArr = (String[][]) Array.newInstance((Class<?>) String.class, list.size(), 3);
+        for (int i = 0; i < list.size(); i++) {
+            strArr[i][0] = list.get(i).getBrand();
+            strArr[i][1] = list.get(i).getMajorVersion();
+            strArr[i][2] = list.get(i).getFullVersion();
+        }
+        return strArr;
+    }
+
+    @NonNull
+    public static UserAgentMetadata getUserAgentMetadataFromMap(@NonNull Map<String, Object> map) {
+        UserAgentMetadata.Builder builder = new UserAgentMetadata.Builder();
+        Object obj = map.get(BRAND_VERSION_LIST);
+        if (obj != null) {
+            ArrayList arrayList = new ArrayList();
+            for (String[] strArr : (String[][]) obj) {
+                arrayList.add(new UserAgentMetadata.BrandVersion.Builder().setBrand(strArr[0]).setMajorVersion(strArr[1]).setFullVersion(strArr[2]).build());
+            }
+            builder.setBrandVersionList(arrayList);
+        }
+        String str = (String) map.get(FULL_VERSION);
+        if (str != null) {
+            builder.setFullVersion(str);
+        }
+        String str2 = (String) map.get(PLATFORM);
+        if (str2 != null) {
+            builder.setPlatform(str2);
+        }
+        String str3 = (String) map.get(PLATFORM_VERSION);
+        if (str3 != null) {
+            builder.setPlatformVersion(str3);
+        }
+        String str4 = (String) map.get(ARCHITECTURE);
+        if (str4 != null) {
+            builder.setArchitecture(str4);
+        }
+        String str5 = (String) map.get(MODEL);
+        if (str5 != null) {
+            builder.setModel(str5);
+        }
+        Boolean bool = (Boolean) map.get(MOBILE);
+        if (bool != null) {
+            builder.setMobile(bool.booleanValue());
+        }
+        Integer num = (Integer) map.get(BITNESS);
+        if (num != null) {
+            builder.setBitness(num.intValue());
+        }
+        Boolean bool2 = (Boolean) map.get(WOW64);
+        if (bool2 != null) {
+            builder.setWow64(bool2.booleanValue());
+        }
+        return builder.build();
+    }
+}

decompiled/sources/androidx/webkit/internal/VisualStateCallbackAdapter.java

@@ -0,0 +1,19 @@
+package androidx.webkit.internal;
+
+import androidx.annotation.NonNull;
+import androidx.webkit.WebViewCompat;
+import org.chromium.support_lib_boundary.VisualStateCallbackBoundaryInterface;
+
+/* loaded from: classes.dex */
+public class VisualStateCallbackAdapter implements VisualStateCallbackBoundaryInterface {
+    private final WebViewCompat.VisualStateCallback mVisualStateCallback;
+
+    public VisualStateCallbackAdapter(@NonNull WebViewCompat.VisualStateCallback visualStateCallback) {
+        this.mVisualStateCallback = visualStateCallback;
+    }
+
+    @Override // org.chromium.support_lib_boundary.VisualStateCallbackBoundaryInterface
+    public void onComplete(long j) {
+        this.mVisualStateCallback.onComplete(j);
+    }
+}

decompiled/sources/androidx/webkit/internal/WebMessageAdapter.java

@@ -0,0 +1,99 @@
+package androidx.webkit.internal;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.webkit.WebMessageCompat;
+import androidx.webkit.WebMessagePortCompat;
+import androidx.webkit.WebViewFeature;
+import java.lang.reflect.InvocationHandler;
+import java.util.Objects;
+import org.chromium.support_lib_boundary.WebMessageBoundaryInterface;
+import org.chromium.support_lib_boundary.WebMessagePayloadBoundaryInterface;
+import org.chromium.support_lib_boundary.util.BoundaryInterfaceReflectionUtil;
+
+/* loaded from: classes.dex */
+public class WebMessageAdapter implements WebMessageBoundaryInterface {
+    private static final String[] sFeatures = {WebViewFeature.WEB_MESSAGE_ARRAY_BUFFER};
+    private WebMessageCompat mWebMessageCompat;
+
+    @Override // org.chromium.support_lib_boundary.FeatureFlagHolderBoundaryInterface
+    @NonNull
+    public String[] getSupportedFeatures() {
+        return sFeatures;
+    }
+
+    public WebMessageAdapter(@NonNull WebMessageCompat webMessageCompat) {
+        this.mWebMessageCompat = webMessageCompat;
+    }
+
+    @Override // org.chromium.support_lib_boundary.WebMessageBoundaryInterface
+    @Nullable
+    @Deprecated
+    public String getData() {
+        return this.mWebMessageCompat.getData();
+    }
+
+    @Override // org.chromium.support_lib_boundary.WebMessageBoundaryInterface
+    @Nullable
+    public InvocationHandler getMessagePayload() {
+        WebMessagePayloadAdapter webMessagePayloadAdapter;
+        int type = this.mWebMessageCompat.getType();
+        if (type == 0) {
+            webMessagePayloadAdapter = new WebMessagePayloadAdapter(this.mWebMessageCompat.getData());
+        } else if (type == 1) {
+            byte[] arrayBuffer = this.mWebMessageCompat.getArrayBuffer();
+            Objects.requireNonNull(arrayBuffer);
+            webMessagePayloadAdapter = new WebMessagePayloadAdapter(arrayBuffer);
+        } else {
+            throw new IllegalStateException("Unknown web message payload type: " + this.mWebMessageCompat.getType());
+        }
+        return BoundaryInterfaceReflectionUtil.createInvocationHandlerFor(webMessagePayloadAdapter);
+    }
+
+    @Override // org.chromium.support_lib_boundary.WebMessageBoundaryInterface
+    @Nullable
+    public InvocationHandler[] getPorts() {
+        WebMessagePortCompat[] ports = this.mWebMessageCompat.getPorts();
+        if (ports == null) {
+            return null;
+        }
+        InvocationHandler[] invocationHandlerArr = new InvocationHandler[ports.length];
+        for (int i = 0; i < ports.length; i++) {
+            invocationHandlerArr[i] = ports[i].getInvocationHandler();
+        }
+        return invocationHandlerArr;
+    }
+
+    public static boolean isMessagePayloadTypeSupportedByWebView(int i) {
+        if (i != 0) {
+            return i == 1 && WebViewFeatureInternal.WEB_MESSAGE_ARRAY_BUFFER.isSupportedByWebView();
+        }
+        return true;
+    }
+
+    @Nullable
+    public static WebMessageCompat webMessageCompatFromBoundaryInterface(@NonNull WebMessageBoundaryInterface webMessageBoundaryInterface) {
+        WebMessagePortCompat[] webMessagePortCompats = toWebMessagePortCompats(webMessageBoundaryInterface.getPorts());
+        if (WebViewFeatureInternal.WEB_MESSAGE_ARRAY_BUFFER.isSupportedByWebView()) {
+            WebMessagePayloadBoundaryInterface webMessagePayloadBoundaryInterface = (WebMessagePayloadBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(WebMessagePayloadBoundaryInterface.class, webMessageBoundaryInterface.getMessagePayload());
+            int type = webMessagePayloadBoundaryInterface.getType();
+            if (type == 0) {
+                return new WebMessageCompat(webMessagePayloadBoundaryInterface.getAsString(), webMessagePortCompats);
+            }
+            if (type != 1) {
+                return null;
+            }
+            return new WebMessageCompat(webMessagePayloadBoundaryInterface.getAsArrayBuffer(), webMessagePortCompats);
+        }
+        return new WebMessageCompat(webMessageBoundaryInterface.getData(), webMessagePortCompats);
+    }
+
+    @NonNull
+    private static WebMessagePortCompat[] toWebMessagePortCompats(InvocationHandler[] invocationHandlerArr) {
+        WebMessagePortCompat[] webMessagePortCompatArr = new WebMessagePortCompat[invocationHandlerArr.length];
+        for (int i = 0; i < invocationHandlerArr.length; i++) {
+            webMessagePortCompatArr[i] = new WebMessagePortImpl(invocationHandlerArr[i]);
+        }
+        return webMessagePortCompatArr;
+    }
+}

decompiled/sources/androidx/webkit/internal/WebMessageCallbackAdapter.java

@@ -0,0 +1,33 @@
+package androidx.webkit.internal;
+
+import androidx.annotation.NonNull;
+import androidx.webkit.WebMessageCompat;
+import androidx.webkit.WebMessagePortCompat;
+import androidx.webkit.WebViewFeature;
+import java.lang.reflect.InvocationHandler;
+import org.chromium.support_lib_boundary.WebMessageBoundaryInterface;
+import org.chromium.support_lib_boundary.WebMessageCallbackBoundaryInterface;
+import org.chromium.support_lib_boundary.util.BoundaryInterfaceReflectionUtil;
+
+/* loaded from: classes.dex */
+public class WebMessageCallbackAdapter implements WebMessageCallbackBoundaryInterface {
+    private final WebMessagePortCompat.WebMessageCallbackCompat mImpl;
+
+    @Override // org.chromium.support_lib_boundary.FeatureFlagHolderBoundaryInterface
+    @NonNull
+    public String[] getSupportedFeatures() {
+        return new String[]{WebViewFeature.WEB_MESSAGE_CALLBACK_ON_MESSAGE};
+    }
+
+    public WebMessageCallbackAdapter(@NonNull WebMessagePortCompat.WebMessageCallbackCompat webMessageCallbackCompat) {
+        this.mImpl = webMessageCallbackCompat;
+    }
+
+    @Override // org.chromium.support_lib_boundary.WebMessageCallbackBoundaryInterface
+    public void onMessage(@NonNull InvocationHandler invocationHandler, @NonNull InvocationHandler invocationHandler2) {
+        WebMessageCompat webMessageCompatFromBoundaryInterface = WebMessageAdapter.webMessageCompatFromBoundaryInterface((WebMessageBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(WebMessageBoundaryInterface.class, invocationHandler2));
+        if (webMessageCompatFromBoundaryInterface != null) {
+            this.mImpl.onMessage(new WebMessagePortImpl(invocationHandler), webMessageCompatFromBoundaryInterface);
+        }
+    }
+}

decompiled/sources/androidx/webkit/internal/WebMessageListenerAdapter.java

@@ -0,0 +1,35 @@
+package androidx.webkit.internal;
+
+import android.net.Uri;
+import android.webkit.WebView;
+import androidx.annotation.NonNull;
+import androidx.webkit.WebMessageCompat;
+import androidx.webkit.WebViewCompat;
+import androidx.webkit.WebViewFeature;
+import java.lang.reflect.InvocationHandler;
+import org.chromium.support_lib_boundary.WebMessageBoundaryInterface;
+import org.chromium.support_lib_boundary.WebMessageListenerBoundaryInterface;
+import org.chromium.support_lib_boundary.util.BoundaryInterfaceReflectionUtil;
+
+/* loaded from: classes.dex */
+public class WebMessageListenerAdapter implements WebMessageListenerBoundaryInterface {
+    private WebViewCompat.WebMessageListener mWebMessageListener;
+
+    @Override // org.chromium.support_lib_boundary.FeatureFlagHolderBoundaryInterface
+    @NonNull
+    public String[] getSupportedFeatures() {
+        return new String[]{WebViewFeature.WEB_MESSAGE_LISTENER, WebViewFeature.WEB_MESSAGE_ARRAY_BUFFER};
+    }
+
+    public WebMessageListenerAdapter(@NonNull WebViewCompat.WebMessageListener webMessageListener) {
+        this.mWebMessageListener = webMessageListener;
+    }
+
+    @Override // org.chromium.support_lib_boundary.WebMessageListenerBoundaryInterface
+    public void onPostMessage(@NonNull WebView webView, @NonNull InvocationHandler invocationHandler, @NonNull Uri uri, boolean z, @NonNull InvocationHandler invocationHandler2) {
+        WebMessageCompat webMessageCompatFromBoundaryInterface = WebMessageAdapter.webMessageCompatFromBoundaryInterface((WebMessageBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(WebMessageBoundaryInterface.class, invocationHandler));
+        if (webMessageCompatFromBoundaryInterface != null) {
+            this.mWebMessageListener.onPostMessage(webView, webMessageCompatFromBoundaryInterface, uri, z, JavaScriptReplyProxyImpl.forInvocationHandler(invocationHandler2));
+        }
+    }
+}

decompiled/sources/androidx/webkit/internal/WebMessagePayloadAdapter.java

@@ -0,0 +1,63 @@
+package androidx.webkit.internal;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import java.util.Objects;
+import org.chromium.support_lib_boundary.WebMessagePayloadBoundaryInterface;
+
+/* loaded from: classes.dex */
+public class WebMessagePayloadAdapter implements WebMessagePayloadBoundaryInterface {
+
+    @Nullable
+    private final byte[] mArrayBuffer;
+
+    @Nullable
+    private final String mString;
+    private final int mType;
+
+    @Override // org.chromium.support_lib_boundary.FeatureFlagHolderBoundaryInterface
+    @NonNull
+    public String[] getSupportedFeatures() {
+        return new String[0];
+    }
+
+    @Override // org.chromium.support_lib_boundary.WebMessagePayloadBoundaryInterface
+    public int getType() {
+        return this.mType;
+    }
+
+    public WebMessagePayloadAdapter(@Nullable String str) {
+        this.mType = 0;
+        this.mString = str;
+        this.mArrayBuffer = null;
+    }
+
+    public WebMessagePayloadAdapter(@NonNull byte[] bArr) {
+        this.mType = 1;
+        this.mString = null;
+        this.mArrayBuffer = bArr;
+    }
+
+    @Override // org.chromium.support_lib_boundary.WebMessagePayloadBoundaryInterface
+    @Nullable
+    public String getAsString() {
+        checkType(0);
+        return this.mString;
+    }
+
+    @Override // org.chromium.support_lib_boundary.WebMessagePayloadBoundaryInterface
+    @NonNull
+    public byte[] getAsArrayBuffer() {
+        checkType(1);
+        byte[] bArr = this.mArrayBuffer;
+        Objects.requireNonNull(bArr);
+        return bArr;
+    }
+
+    private void checkType(int i) {
+        if (this.mType == i) {
+            return;
+        }
+        throw new IllegalStateException("Expected " + i + ", but type is " + this.mType);
+    }
+}

decompiled/sources/androidx/webkit/internal/WebMessagePortImpl.java

@@ -0,0 +1,151 @@
+package androidx.webkit.internal;
+
+import android.os.Handler;
+import android.webkit.WebMessage;
+import android.webkit.WebMessagePort;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.webkit.WebMessageCompat;
+import androidx.webkit.WebMessagePortCompat;
+import androidx.webkit.internal.ApiFeature;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Proxy;
+import org.chromium.support_lib_boundary.WebMessagePortBoundaryInterface;
+import org.chromium.support_lib_boundary.util.BoundaryInterfaceReflectionUtil;
+
+/* loaded from: classes.dex */
+public class WebMessagePortImpl extends WebMessagePortCompat {
+    private WebMessagePortBoundaryInterface mBoundaryInterface;
+    private WebMessagePort mFrameworksImpl;
+
+    public WebMessagePortImpl(@NonNull WebMessagePort webMessagePort) {
+        this.mFrameworksImpl = webMessagePort;
+    }
+
+    public WebMessagePortImpl(@NonNull InvocationHandler invocationHandler) {
+        this.mBoundaryInterface = (WebMessagePortBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(WebMessagePortBoundaryInterface.class, invocationHandler);
+    }
+
+    @RequiresApi(23)
+    private WebMessagePort getFrameworksImpl() {
+        if (this.mFrameworksImpl == null) {
+            this.mFrameworksImpl = WebViewGlueCommunicator.getCompatConverter().convertWebMessagePort(Proxy.getInvocationHandler(this.mBoundaryInterface));
+        }
+        return this.mFrameworksImpl;
+    }
+
+    private WebMessagePortBoundaryInterface getBoundaryInterface() {
+        if (this.mBoundaryInterface == null) {
+            this.mBoundaryInterface = (WebMessagePortBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(WebMessagePortBoundaryInterface.class, WebViewGlueCommunicator.getCompatConverter().convertWebMessagePort(this.mFrameworksImpl));
+        }
+        return this.mBoundaryInterface;
+    }
+
+    @Override // androidx.webkit.WebMessagePortCompat
+    public void postMessage(@NonNull WebMessageCompat webMessageCompat) {
+        ApiFeature.M m = WebViewFeatureInternal.WEB_MESSAGE_PORT_POST_MESSAGE;
+        if (m.isSupportedByFramework() && webMessageCompat.getType() == 0) {
+            ApiHelperForM.postMessage(getFrameworksImpl(), compatToFrameworkMessage(webMessageCompat));
+        } else {
+            if (m.isSupportedByWebView() && WebMessageAdapter.isMessagePayloadTypeSupportedByWebView(webMessageCompat.getType())) {
+                getBoundaryInterface().postMessage(BoundaryInterfaceReflectionUtil.createInvocationHandlerFor(new WebMessageAdapter(webMessageCompat)));
+                return;
+            }
+            throw WebViewFeatureInternal.getUnsupportedOperationException();
+        }
+    }
+
+    @Override // androidx.webkit.WebMessagePortCompat
+    public void close() {
+        ApiFeature.M m = WebViewFeatureInternal.WEB_MESSAGE_PORT_CLOSE;
+        if (m.isSupportedByFramework()) {
+            ApiHelperForM.close(getFrameworksImpl());
+        } else {
+            if (m.isSupportedByWebView()) {
+                getBoundaryInterface().close();
+                return;
+            }
+            throw WebViewFeatureInternal.getUnsupportedOperationException();
+        }
+    }
+
+    @Override // androidx.webkit.WebMessagePortCompat
+    public void setWebMessageCallback(@NonNull WebMessagePortCompat.WebMessageCallbackCompat webMessageCallbackCompat) {
+        ApiFeature.M m = WebViewFeatureInternal.WEB_MESSAGE_PORT_SET_MESSAGE_CALLBACK;
+        if (m.isSupportedByWebView()) {
+            getBoundaryInterface().setWebMessageCallback(BoundaryInterfaceReflectionUtil.createInvocationHandlerFor(new WebMessageCallbackAdapter(webMessageCallbackCompat)));
+        } else {
+            if (m.isSupportedByFramework()) {
+                ApiHelperForM.setWebMessageCallback(getFrameworksImpl(), webMessageCallbackCompat);
+                return;
+            }
+            throw WebViewFeatureInternal.getUnsupportedOperationException();
+        }
+    }
+
+    @Override // androidx.webkit.WebMessagePortCompat
+    public void setWebMessageCallback(@Nullable Handler handler, @NonNull WebMessagePortCompat.WebMessageCallbackCompat webMessageCallbackCompat) {
+        ApiFeature.M m = WebViewFeatureInternal.CREATE_WEB_MESSAGE_CHANNEL;
+        if (m.isSupportedByWebView()) {
+            getBoundaryInterface().setWebMessageCallback(BoundaryInterfaceReflectionUtil.createInvocationHandlerFor(new WebMessageCallbackAdapter(webMessageCallbackCompat)), handler);
+        } else {
+            if (m.isSupportedByFramework()) {
+                ApiHelperForM.setWebMessageCallback(getFrameworksImpl(), webMessageCallbackCompat, handler);
+                return;
+            }
+            throw WebViewFeatureInternal.getUnsupportedOperationException();
+        }
+    }
+
+    @Override // androidx.webkit.WebMessagePortCompat
+    @NonNull
+    @RequiresApi(23)
+    public WebMessagePort getFrameworkPort() {
+        return getFrameworksImpl();
+    }
+
+    @Override // androidx.webkit.WebMessagePortCompat
+    @NonNull
+    public InvocationHandler getInvocationHandler() {
+        return Proxy.getInvocationHandler(getBoundaryInterface());
+    }
+
+    @Nullable
+    public static WebMessagePortCompat[] portsToCompat(@Nullable WebMessagePort[] webMessagePortArr) {
+        if (webMessagePortArr == null) {
+            return null;
+        }
+        WebMessagePortCompat[] webMessagePortCompatArr = new WebMessagePortCompat[webMessagePortArr.length];
+        for (int i = 0; i < webMessagePortArr.length; i++) {
+            webMessagePortCompatArr[i] = new WebMessagePortImpl(webMessagePortArr[i]);
+        }
+        return webMessagePortCompatArr;
+    }
+
+    @Nullable
+    @RequiresApi(23)
+    public static WebMessagePort[] compatToPorts(@Nullable WebMessagePortCompat[] webMessagePortCompatArr) {
+        if (webMessagePortCompatArr == null) {
+            return null;
+        }
+        int length = webMessagePortCompatArr.length;
+        WebMessagePort[] webMessagePortArr = new WebMessagePort[length];
+        for (int i = 0; i < length; i++) {
+            webMessagePortArr[i] = webMessagePortCompatArr[i].getFrameworkPort();
+        }
+        return webMessagePortArr;
+    }
+
+    @NonNull
+    @RequiresApi(23)
+    public static WebMessage compatToFrameworkMessage(@NonNull WebMessageCompat webMessageCompat) {
+        return ApiHelperForM.createWebMessage(webMessageCompat);
+    }
+
+    @NonNull
+    @RequiresApi(23)
+    public static WebMessageCompat frameworkMessageToCompat(@NonNull WebMessage webMessage) {
+        return ApiHelperForM.createWebMessageCompat(webMessage);
+    }
+}

decompiled/sources/androidx/webkit/internal/WebResourceErrorImpl.java

@@ -0,0 +1,65 @@
+package androidx.webkit.internal;
+
+import android.webkit.WebResourceError;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+import androidx.webkit.WebResourceErrorCompat;
+import androidx.webkit.internal.ApiFeature;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Proxy;
+import org.chromium.support_lib_boundary.WebResourceErrorBoundaryInterface;
+import org.chromium.support_lib_boundary.util.BoundaryInterfaceReflectionUtil;
+
+/* loaded from: classes.dex */
+public class WebResourceErrorImpl extends WebResourceErrorCompat {
+    private WebResourceErrorBoundaryInterface mBoundaryInterface;
+    private WebResourceError mFrameworksImpl;
+
+    public WebResourceErrorImpl(@NonNull InvocationHandler invocationHandler) {
+        this.mBoundaryInterface = (WebResourceErrorBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(WebResourceErrorBoundaryInterface.class, invocationHandler);
+    }
+
+    public WebResourceErrorImpl(@NonNull WebResourceError webResourceError) {
+        this.mFrameworksImpl = webResourceError;
+    }
+
+    @RequiresApi(23)
+    private WebResourceError getFrameworksImpl() {
+        if (this.mFrameworksImpl == null) {
+            this.mFrameworksImpl = WebViewGlueCommunicator.getCompatConverter().convertWebResourceError(Proxy.getInvocationHandler(this.mBoundaryInterface));
+        }
+        return this.mFrameworksImpl;
+    }
+
+    private WebResourceErrorBoundaryInterface getBoundaryInterface() {
+        if (this.mBoundaryInterface == null) {
+            this.mBoundaryInterface = (WebResourceErrorBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(WebResourceErrorBoundaryInterface.class, WebViewGlueCommunicator.getCompatConverter().convertWebResourceError(this.mFrameworksImpl));
+        }
+        return this.mBoundaryInterface;
+    }
+
+    @Override // androidx.webkit.WebResourceErrorCompat
+    public int getErrorCode() {
+        ApiFeature.M m = WebViewFeatureInternal.WEB_RESOURCE_ERROR_GET_CODE;
+        if (m.isSupportedByFramework()) {
+            return ApiHelperForM.getErrorCode(getFrameworksImpl());
+        }
+        if (m.isSupportedByWebView()) {
+            return getBoundaryInterface().getErrorCode();
+        }
+        throw WebViewFeatureInternal.getUnsupportedOperationException();
+    }
+
+    @Override // androidx.webkit.WebResourceErrorCompat
+    @NonNull
+    public CharSequence getDescription() {
+        ApiFeature.M m = WebViewFeatureInternal.WEB_RESOURCE_ERROR_GET_DESCRIPTION;
+        if (m.isSupportedByFramework()) {
+            return ApiHelperForM.getDescription(getFrameworksImpl());
+        }
+        if (m.isSupportedByWebView()) {
+            return getBoundaryInterface().getDescription();
+        }
+        throw WebViewFeatureInternal.getUnsupportedOperationException();
+    }
+}

decompiled/sources/androidx/webkit/internal/WebResourceRequestAdapter.java

@@ -0,0 +1,17 @@
+package androidx.webkit.internal;
+
+import androidx.annotation.NonNull;
+import org.chromium.support_lib_boundary.WebResourceRequestBoundaryInterface;
+
+/* loaded from: classes.dex */
+public class WebResourceRequestAdapter {
+    private final WebResourceRequestBoundaryInterface mBoundaryInterface;
+
+    public WebResourceRequestAdapter(@NonNull WebResourceRequestBoundaryInterface webResourceRequestBoundaryInterface) {
+        this.mBoundaryInterface = webResourceRequestBoundaryInterface;
+    }
+
+    public boolean isRedirect() {
+        return this.mBoundaryInterface.isRedirect();
+    }
+}

decompiled/sources/androidx/webkit/internal/WebSettingsAdapter.java

@@ -0,0 +1,107 @@
+package androidx.webkit.internal;
+
+import androidx.annotation.NonNull;
+import androidx.webkit.UserAgentMetadata;
+import androidx.webkit.WebViewMediaIntegrityApiStatusConfig;
+import java.util.Set;
+import org.chromium.support_lib_boundary.WebSettingsBoundaryInterface;
+
+/* loaded from: classes.dex */
+public class WebSettingsAdapter {
+    private final WebSettingsBoundaryInterface mBoundaryInterface;
+
+    public WebSettingsAdapter(@NonNull WebSettingsBoundaryInterface webSettingsBoundaryInterface) {
+        this.mBoundaryInterface = webSettingsBoundaryInterface;
+    }
+
+    public void setOffscreenPreRaster(boolean z) {
+        this.mBoundaryInterface.setOffscreenPreRaster(z);
+    }
+
+    public boolean getOffscreenPreRaster() {
+        return this.mBoundaryInterface.getOffscreenPreRaster();
+    }
+
+    public void setSafeBrowsingEnabled(boolean z) {
+        this.mBoundaryInterface.setSafeBrowsingEnabled(z);
+    }
+
+    public boolean getSafeBrowsingEnabled() {
+        return this.mBoundaryInterface.getSafeBrowsingEnabled();
+    }
+
+    public void setDisabledActionModeMenuItems(int i) {
+        this.mBoundaryInterface.setDisabledActionModeMenuItems(i);
+    }
+
+    public int getDisabledActionModeMenuItems() {
+        return this.mBoundaryInterface.getDisabledActionModeMenuItems();
+    }
+
+    public void setForceDark(int i) {
+        this.mBoundaryInterface.setForceDark(i);
+    }
+
+    public int getForceDark() {
+        return this.mBoundaryInterface.getForceDark();
+    }
+
+    public void setForceDarkStrategy(int i) {
+        this.mBoundaryInterface.setForceDarkBehavior(i);
+    }
+
+    public int getForceDarkStrategy() {
+        return this.mBoundaryInterface.getForceDarkBehavior();
+    }
+
+    public void setAlgorithmicDarkeningAllowed(boolean z) {
+        this.mBoundaryInterface.setAlgorithmicDarkeningAllowed(z);
+    }
+
+    public boolean isAlgorithmicDarkeningAllowed() {
+        return this.mBoundaryInterface.isAlgorithmicDarkeningAllowed();
+    }
+
+    public void setEnterpriseAuthenticationAppLinkPolicyEnabled(boolean z) {
+        this.mBoundaryInterface.setEnterpriseAuthenticationAppLinkPolicyEnabled(z);
+    }
+
+    public boolean getEnterpriseAuthenticationAppLinkPolicyEnabled() {
+        return this.mBoundaryInterface.getEnterpriseAuthenticationAppLinkPolicyEnabled();
+    }
+
+    @NonNull
+    public Set<String> getRequestedWithHeaderOriginAllowList() {
+        return this.mBoundaryInterface.getRequestedWithHeaderOriginAllowList();
+    }
+
+    public void setRequestedWithHeaderOriginAllowList(@NonNull Set<String> set) {
+        this.mBoundaryInterface.setRequestedWithHeaderOriginAllowList(set);
+    }
+
+    @NonNull
+    public UserAgentMetadata getUserAgentMetadata() {
+        return UserAgentMetadataInternal.getUserAgentMetadataFromMap(this.mBoundaryInterface.getUserAgentMetadataMap());
+    }
+
+    public void setUserAgentMetadata(@NonNull UserAgentMetadata userAgentMetadata) {
+        this.mBoundaryInterface.setUserAgentMetadataFromMap(UserAgentMetadataInternal.convertUserAgentMetadataToMap(userAgentMetadata));
+    }
+
+    public int getAttributionRegistrationBehavior() {
+        return this.mBoundaryInterface.getAttributionBehavior();
+    }
+
+    public void setAttributionRegistrationBehavior(int i) {
+        this.mBoundaryInterface.setAttributionBehavior(i);
+    }
+
+    public void setWebViewMediaIntegrityApiStatus(@NonNull WebViewMediaIntegrityApiStatusConfig webViewMediaIntegrityApiStatusConfig) {
+        this.mBoundaryInterface.setWebViewMediaIntegrityApiStatus(webViewMediaIntegrityApiStatusConfig.getDefaultStatus(), webViewMediaIntegrityApiStatusConfig.getOverrideRules());
+    }
+
+    @NonNull
+    public WebViewMediaIntegrityApiStatusConfig getWebViewMediaIntegrityApiStatus() {
+        return new WebViewMediaIntegrityApiStatusConfig.Builder(this.mBoundaryInterface.getWebViewMediaIntegrityApiDefaultStatus()).setOverrideRules(this.mBoundaryInterface.getWebViewMediaIntegrityApiOverrideRules()).build();
+    }
+}

decompiled/sources/androidx/webkit/internal/WebViewFeatureInternal.java

@@ -0,0 +1,167 @@
+package androidx.webkit.internal;
+
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.os.Build;
+import androidx.annotation.NonNull;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
+import androidx.webkit.WebViewCompat;
+import androidx.webkit.WebViewFeature;
+import androidx.webkit.internal.ApiFeature;
+import androidx.webkit.internal.StartupApiFeature;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/* loaded from: classes.dex */
+public class WebViewFeatureInternal {
+    public static final ApiFeature.M VISUAL_STATE_CALLBACK = new ApiFeature.M(WebViewFeature.VISUAL_STATE_CALLBACK, WebViewFeature.VISUAL_STATE_CALLBACK);
+    public static final ApiFeature.M OFF_SCREEN_PRERASTER = new ApiFeature.M(WebViewFeature.OFF_SCREEN_PRERASTER, WebViewFeature.OFF_SCREEN_PRERASTER);
+    public static final ApiFeature.O SAFE_BROWSING_ENABLE = new ApiFeature.O(WebViewFeature.SAFE_BROWSING_ENABLE, WebViewFeature.SAFE_BROWSING_ENABLE);
+    public static final ApiFeature.N DISABLED_ACTION_MODE_MENU_ITEMS = new ApiFeature.N(WebViewFeature.DISABLED_ACTION_MODE_MENU_ITEMS, WebViewFeature.DISABLED_ACTION_MODE_MENU_ITEMS);
+    public static final ApiFeature.O_MR1 START_SAFE_BROWSING = new ApiFeature.O_MR1(WebViewFeature.START_SAFE_BROWSING, WebViewFeature.START_SAFE_BROWSING);
+
+    @Deprecated
+    public static final ApiFeature.O_MR1 SAFE_BROWSING_ALLOWLIST_DEPRECATED_TO_DEPRECATED = new ApiFeature.O_MR1(WebViewFeature.SAFE_BROWSING_WHITELIST, WebViewFeature.SAFE_BROWSING_WHITELIST);
+
+    @Deprecated
+    public static final ApiFeature.O_MR1 SAFE_BROWSING_ALLOWLIST_DEPRECATED_TO_PREFERRED = new ApiFeature.O_MR1(WebViewFeature.SAFE_BROWSING_WHITELIST, WebViewFeature.SAFE_BROWSING_ALLOWLIST);
+    public static final ApiFeature.O_MR1 SAFE_BROWSING_ALLOWLIST_PREFERRED_TO_DEPRECATED = new ApiFeature.O_MR1(WebViewFeature.SAFE_BROWSING_ALLOWLIST, WebViewFeature.SAFE_BROWSING_WHITELIST);
+    public static final ApiFeature.O_MR1 SAFE_BROWSING_ALLOWLIST_PREFERRED_TO_PREFERRED = new ApiFeature.O_MR1(WebViewFeature.SAFE_BROWSING_ALLOWLIST, WebViewFeature.SAFE_BROWSING_ALLOWLIST);
+    public static final ApiFeature.O_MR1 SAFE_BROWSING_PRIVACY_POLICY_URL = new ApiFeature.O_MR1(WebViewFeature.SAFE_BROWSING_PRIVACY_POLICY_URL, WebViewFeature.SAFE_BROWSING_PRIVACY_POLICY_URL);
+    public static final ApiFeature.N SERVICE_WORKER_BASIC_USAGE = new ApiFeature.N(WebViewFeature.SERVICE_WORKER_BASIC_USAGE, WebViewFeature.SERVICE_WORKER_BASIC_USAGE);
+    public static final ApiFeature.N SERVICE_WORKER_CACHE_MODE = new ApiFeature.N(WebViewFeature.SERVICE_WORKER_CACHE_MODE, WebViewFeature.SERVICE_WORKER_CACHE_MODE);
+    public static final ApiFeature.N SERVICE_WORKER_CONTENT_ACCESS = new ApiFeature.N(WebViewFeature.SERVICE_WORKER_CONTENT_ACCESS, WebViewFeature.SERVICE_WORKER_CONTENT_ACCESS);
+    public static final ApiFeature.N SERVICE_WORKER_FILE_ACCESS = new ApiFeature.N(WebViewFeature.SERVICE_WORKER_FILE_ACCESS, WebViewFeature.SERVICE_WORKER_FILE_ACCESS);
+    public static final ApiFeature.N SERVICE_WORKER_BLOCK_NETWORK_LOADS = new ApiFeature.N(WebViewFeature.SERVICE_WORKER_BLOCK_NETWORK_LOADS, WebViewFeature.SERVICE_WORKER_BLOCK_NETWORK_LOADS);
+    public static final ApiFeature.N SERVICE_WORKER_SHOULD_INTERCEPT_REQUEST = new ApiFeature.N(WebViewFeature.SERVICE_WORKER_SHOULD_INTERCEPT_REQUEST, WebViewFeature.SERVICE_WORKER_SHOULD_INTERCEPT_REQUEST);
+    public static final ApiFeature.M RECEIVE_WEB_RESOURCE_ERROR = new ApiFeature.M(WebViewFeature.RECEIVE_WEB_RESOURCE_ERROR, WebViewFeature.RECEIVE_WEB_RESOURCE_ERROR);
+    public static final ApiFeature.M RECEIVE_HTTP_ERROR = new ApiFeature.M(WebViewFeature.RECEIVE_HTTP_ERROR, WebViewFeature.RECEIVE_HTTP_ERROR);
+    public static final ApiFeature.N SHOULD_OVERRIDE_WITH_REDIRECTS = new ApiFeature.N(WebViewFeature.SHOULD_OVERRIDE_WITH_REDIRECTS, WebViewFeature.SHOULD_OVERRIDE_WITH_REDIRECTS);
+    public static final ApiFeature.O_MR1 SAFE_BROWSING_HIT = new ApiFeature.O_MR1(WebViewFeature.SAFE_BROWSING_HIT, WebViewFeature.SAFE_BROWSING_HIT);
+    public static final ApiFeature.N WEB_RESOURCE_REQUEST_IS_REDIRECT = new ApiFeature.N(WebViewFeature.WEB_RESOURCE_REQUEST_IS_REDIRECT, WebViewFeature.WEB_RESOURCE_REQUEST_IS_REDIRECT);
+    public static final ApiFeature.M WEB_RESOURCE_ERROR_GET_DESCRIPTION = new ApiFeature.M(WebViewFeature.WEB_RESOURCE_ERROR_GET_DESCRIPTION, WebViewFeature.WEB_RESOURCE_ERROR_GET_DESCRIPTION);
+    public static final ApiFeature.M WEB_RESOURCE_ERROR_GET_CODE = new ApiFeature.M(WebViewFeature.WEB_RESOURCE_ERROR_GET_CODE, WebViewFeature.WEB_RESOURCE_ERROR_GET_CODE);
+    public static final ApiFeature.O_MR1 SAFE_BROWSING_RESPONSE_BACK_TO_SAFETY = new ApiFeature.O_MR1(WebViewFeature.SAFE_BROWSING_RESPONSE_BACK_TO_SAFETY, WebViewFeature.SAFE_BROWSING_RESPONSE_BACK_TO_SAFETY);
+    public static final ApiFeature.O_MR1 SAFE_BROWSING_RESPONSE_PROCEED = new ApiFeature.O_MR1(WebViewFeature.SAFE_BROWSING_RESPONSE_PROCEED, WebViewFeature.SAFE_BROWSING_RESPONSE_PROCEED);
+    public static final ApiFeature.O_MR1 SAFE_BROWSING_RESPONSE_SHOW_INTERSTITIAL = new ApiFeature.O_MR1(WebViewFeature.SAFE_BROWSING_RESPONSE_SHOW_INTERSTITIAL, WebViewFeature.SAFE_BROWSING_RESPONSE_SHOW_INTERSTITIAL);
+    public static final ApiFeature.M WEB_MESSAGE_PORT_POST_MESSAGE = new ApiFeature.M(WebViewFeature.WEB_MESSAGE_PORT_POST_MESSAGE, WebViewFeature.WEB_MESSAGE_PORT_POST_MESSAGE);
+    public static final ApiFeature.M WEB_MESSAGE_PORT_CLOSE = new ApiFeature.M(WebViewFeature.WEB_MESSAGE_PORT_CLOSE, WebViewFeature.WEB_MESSAGE_PORT_CLOSE);
+    public static final ApiFeature.NoFramework WEB_MESSAGE_ARRAY_BUFFER = new ApiFeature.NoFramework(WebViewFeature.WEB_MESSAGE_ARRAY_BUFFER, WebViewFeature.WEB_MESSAGE_ARRAY_BUFFER);
+    public static final ApiFeature.M WEB_MESSAGE_PORT_SET_MESSAGE_CALLBACK = new ApiFeature.M(WebViewFeature.WEB_MESSAGE_PORT_SET_MESSAGE_CALLBACK, WebViewFeature.WEB_MESSAGE_PORT_SET_MESSAGE_CALLBACK);
+    public static final ApiFeature.M CREATE_WEB_MESSAGE_CHANNEL = new ApiFeature.M(WebViewFeature.CREATE_WEB_MESSAGE_CHANNEL, WebViewFeature.CREATE_WEB_MESSAGE_CHANNEL);
+    public static final ApiFeature.M POST_WEB_MESSAGE = new ApiFeature.M(WebViewFeature.POST_WEB_MESSAGE, WebViewFeature.POST_WEB_MESSAGE);
+    public static final ApiFeature.M WEB_MESSAGE_CALLBACK_ON_MESSAGE = new ApiFeature.M(WebViewFeature.WEB_MESSAGE_CALLBACK_ON_MESSAGE, WebViewFeature.WEB_MESSAGE_CALLBACK_ON_MESSAGE);
+    public static final ApiFeature.O GET_WEB_VIEW_CLIENT = new ApiFeature.O(WebViewFeature.GET_WEB_VIEW_CLIENT, WebViewFeature.GET_WEB_VIEW_CLIENT);
+    public static final ApiFeature.O GET_WEB_CHROME_CLIENT = new ApiFeature.O(WebViewFeature.GET_WEB_CHROME_CLIENT, WebViewFeature.GET_WEB_CHROME_CLIENT);
+    public static final ApiFeature.Q GET_WEB_VIEW_RENDERER = new ApiFeature.Q(WebViewFeature.GET_WEB_VIEW_RENDERER, WebViewFeature.GET_WEB_VIEW_RENDERER);
+    public static final ApiFeature.Q WEB_VIEW_RENDERER_TERMINATE = new ApiFeature.Q(WebViewFeature.WEB_VIEW_RENDERER_TERMINATE, WebViewFeature.WEB_VIEW_RENDERER_TERMINATE);
+    public static final ApiFeature.P TRACING_CONTROLLER_BASIC_USAGE = new ApiFeature.P(WebViewFeature.TRACING_CONTROLLER_BASIC_USAGE, WebViewFeature.TRACING_CONTROLLER_BASIC_USAGE);
+    public static final StartupApiFeature.P STARTUP_FEATURE_SET_DATA_DIRECTORY_SUFFIX = new StartupApiFeature.P("STARTUP_FEATURE_SET_DATA_DIRECTORY_SUFFIX", "STARTUP_FEATURE_SET_DATA_DIRECTORY_SUFFIX");
+    public static final StartupApiFeature.NoFramework STARTUP_FEATURE_SET_DIRECTORY_BASE_PATH = new StartupApiFeature.NoFramework(WebViewFeature.STARTUP_FEATURE_SET_DIRECTORY_BASE_PATHS, StartupFeatures.STARTUP_FEATURE_SET_DIRECTORY_BASE_PATH);
+    public static final ApiFeature.Q WEB_VIEW_RENDERER_CLIENT_BASIC_USAGE = new ApiFeature.Q(WebViewFeature.WEB_VIEW_RENDERER_CLIENT_BASIC_USAGE, WebViewFeature.WEB_VIEW_RENDERER_CLIENT_BASIC_USAGE);
+    public static final ApiFeature.T ALGORITHMIC_DARKENING = new ApiFeature.T(WebViewFeature.ALGORITHMIC_DARKENING, WebViewFeature.ALGORITHMIC_DARKENING) { // from class: androidx.webkit.internal.WebViewFeatureInternal.1
+        private final Pattern mVersionPattern = Pattern.compile("\\A\\d+");
+
+        @Override // androidx.webkit.internal.ApiFeature
+        public boolean isSupportedByWebView() {
+            boolean isSupportedByWebView = super.isSupportedByWebView();
+            if (!isSupportedByWebView || Build.VERSION.SDK_INT >= 29) {
+                return isSupportedByWebView;
+            }
+            PackageInfo currentLoadedWebViewPackage = WebViewCompat.getCurrentLoadedWebViewPackage();
+            if (currentLoadedWebViewPackage == null) {
+                return false;
+            }
+            Matcher matcher = this.mVersionPattern.matcher(currentLoadedWebViewPackage.versionName);
+            return matcher.find() && Integer.parseInt(currentLoadedWebViewPackage.versionName.substring(matcher.start(), matcher.end())) >= 105;
+        }
+    };
+    public static final ApiFeature.NoFramework PROXY_OVERRIDE = new ApiFeature.NoFramework(WebViewFeature.PROXY_OVERRIDE, "PROXY_OVERRIDE:3");
+    public static final ApiFeature.NoFramework MULTI_PROCESS = new ApiFeature.NoFramework(WebViewFeature.MULTI_PROCESS, "MULTI_PROCESS_QUERY");
+    public static final ApiFeature.Q FORCE_DARK = new ApiFeature.Q(WebViewFeature.FORCE_DARK, WebViewFeature.FORCE_DARK);
+    public static final ApiFeature.NoFramework FORCE_DARK_STRATEGY = new ApiFeature.NoFramework(WebViewFeature.FORCE_DARK_STRATEGY, "FORCE_DARK_BEHAVIOR");
+    public static final ApiFeature.NoFramework WEB_MESSAGE_LISTENER = new ApiFeature.NoFramework(WebViewFeature.WEB_MESSAGE_LISTENER, WebViewFeature.WEB_MESSAGE_LISTENER);
+    public static final ApiFeature.NoFramework DOCUMENT_START_SCRIPT = new ApiFeature.NoFramework(WebViewFeature.DOCUMENT_START_SCRIPT, "DOCUMENT_START_SCRIPT:1");
+    public static final ApiFeature.NoFramework PROXY_OVERRIDE_REVERSE_BYPASS = new ApiFeature.NoFramework(WebViewFeature.PROXY_OVERRIDE_REVERSE_BYPASS, WebViewFeature.PROXY_OVERRIDE_REVERSE_BYPASS);
+    public static final ApiFeature.NoFramework GET_VARIATIONS_HEADER = new ApiFeature.NoFramework(WebViewFeature.GET_VARIATIONS_HEADER, WebViewFeature.GET_VARIATIONS_HEADER);
+    public static final ApiFeature.NoFramework ENTERPRISE_AUTHENTICATION_APP_LINK_POLICY = new ApiFeature.NoFramework(WebViewFeature.ENTERPRISE_AUTHENTICATION_APP_LINK_POLICY, WebViewFeature.ENTERPRISE_AUTHENTICATION_APP_LINK_POLICY);
+    public static final ApiFeature.NoFramework GET_COOKIE_INFO = new ApiFeature.NoFramework(WebViewFeature.GET_COOKIE_INFO, WebViewFeature.GET_COOKIE_INFO);
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+    public static final ApiFeature.NoFramework REQUESTED_WITH_HEADER_ALLOW_LIST = new ApiFeature.NoFramework(WebViewFeature.REQUESTED_WITH_HEADER_ALLOW_LIST, WebViewFeature.REQUESTED_WITH_HEADER_ALLOW_LIST);
+    public static final ApiFeature.NoFramework USER_AGENT_METADATA = new ApiFeature.NoFramework(WebViewFeature.USER_AGENT_METADATA, WebViewFeature.USER_AGENT_METADATA);
+    public static final ApiFeature.NoFramework MULTI_PROFILE = new ApiFeature.NoFramework(WebViewFeature.MULTI_PROFILE, WebViewFeature.MULTI_PROFILE) { // from class: androidx.webkit.internal.WebViewFeatureInternal.2
+        @Override // androidx.webkit.internal.ApiFeature
+        public boolean isSupportedByWebView() {
+            if (super.isSupportedByWebView() && WebViewFeature.isFeatureSupported(WebViewFeature.MULTI_PROCESS)) {
+                return WebViewCompat.isMultiProcessEnabled();
+            }
+            return false;
+        }
+    };
+    public static final ApiFeature.NoFramework ATTRIBUTION_REGISTRATION_BEHAVIOR = new ApiFeature.NoFramework(WebViewFeature.ATTRIBUTION_REGISTRATION_BEHAVIOR, "ATTRIBUTION_BEHAVIOR");
+    public static final ApiFeature.NoFramework WEBVIEW_MEDIA_INTEGRITY_API_STATUS = new ApiFeature.NoFramework(WebViewFeature.WEBVIEW_MEDIA_INTEGRITY_API_STATUS, "WEBVIEW_INTEGRITY_API_STATUS");
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+    public static final ApiFeature.NoFramework MUTE_AUDIO = new ApiFeature.NoFramework(WebViewFeature.MUTE_AUDIO, WebViewFeature.MUTE_AUDIO);
+
+    private WebViewFeatureInternal() {
+    }
+
+    public static boolean isSupported(@NonNull String str) {
+        return isSupported(str, ApiFeature.values());
+    }
+
+    public static boolean isStartupFeatureSupported(@NonNull String str, @NonNull Context context) {
+        return isStartupFeatureSupported(str, StartupApiFeature.values(), context);
+    }
+
+    @VisibleForTesting
+    public static <T extends ConditionallySupportedFeature> boolean isSupported(@NonNull String str, @NonNull Collection<T> collection) {
+        HashSet hashSet = new HashSet();
+        for (T t : collection) {
+            if (t.getPublicFeatureName().equals(str)) {
+                hashSet.add(t);
+            }
+        }
+        if (hashSet.isEmpty()) {
+            throw new RuntimeException("Unknown feature " + str);
+        }
+        Iterator it = hashSet.iterator();
+        while (it.hasNext()) {
+            if (((ConditionallySupportedFeature) it.next()).isSupported()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @VisibleForTesting
+    public static boolean isStartupFeatureSupported(@NonNull String str, @NonNull Collection<StartupApiFeature> collection, @NonNull Context context) {
+        HashSet hashSet = new HashSet();
+        for (StartupApiFeature startupApiFeature : collection) {
+            if (startupApiFeature.getPublicFeatureName().equals(str)) {
+                hashSet.add(startupApiFeature);
+            }
+        }
+        if (hashSet.isEmpty()) {
+            throw new RuntimeException("Unknown feature " + str);
+        }
+        Iterator it = hashSet.iterator();
+        while (it.hasNext()) {
+            if (((StartupApiFeature) it.next()).isSupported(context)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @NonNull
+    public static UnsupportedOperationException getUnsupportedOperationException() {
+        return new UnsupportedOperationException("This method is not supported by the current version of the framework and the current WebView APK");
+    }
+}

decompiled/sources/androidx/webkit/internal/WebViewGlueCommunicator.java

@@ -0,0 +1,84 @@
+package androidx.webkit.internal;
+
+import android.os.Build;
+import android.webkit.WebView;
+import androidx.annotation.NonNull;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import org.chromium.support_lib_boundary.WebViewProviderFactoryBoundaryInterface;
+import org.chromium.support_lib_boundary.util.BoundaryInterfaceReflectionUtil;
+
+/* loaded from: classes.dex */
+public class WebViewGlueCommunicator {
+    private static final String GLUE_FACTORY_PROVIDER_FETCHER_CLASS = "org.chromium.support_lib_glue.SupportLibReflectionUtil";
+    private static final String GLUE_FACTORY_PROVIDER_FETCHER_METHOD = "createWebViewProviderFactory";
+
+    @NonNull
+    public static WebViewProviderFactory getFactory() {
+        return LAZY_FACTORY_HOLDER.INSTANCE;
+    }
+
+    @NonNull
+    public static WebkitToCompatConverter getCompatConverter() {
+        return LAZY_COMPAT_CONVERTER_HOLDER.INSTANCE;
+    }
+
+    public static class LAZY_FACTORY_HOLDER {
+        static final WebViewProviderFactory INSTANCE = WebViewGlueCommunicator.createGlueProviderFactory();
+
+        private LAZY_FACTORY_HOLDER() {
+        }
+    }
+
+    public static class LAZY_COMPAT_CONVERTER_HOLDER {
+        static final WebkitToCompatConverter INSTANCE = new WebkitToCompatConverter(WebViewGlueCommunicator.getFactory().getWebkitToCompatConverter());
+
+        private LAZY_COMPAT_CONVERTER_HOLDER() {
+        }
+    }
+
+    private static InvocationHandler fetchGlueProviderFactoryImpl() throws IllegalAccessException, InvocationTargetException, ClassNotFoundException, NoSuchMethodException {
+        return (InvocationHandler) Class.forName(GLUE_FACTORY_PROVIDER_FETCHER_CLASS, false, getWebViewClassLoader()).getDeclaredMethod(GLUE_FACTORY_PROVIDER_FETCHER_METHOD, new Class[0]).invoke(null, new Object[0]);
+    }
+
+    @NonNull
+    public static WebViewProviderFactory createGlueProviderFactory() {
+        try {
+            return new WebViewProviderFactoryAdapter((WebViewProviderFactoryBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(WebViewProviderFactoryBoundaryInterface.class, fetchGlueProviderFactoryImpl()));
+        } catch (ClassNotFoundException unused) {
+            return new IncompatibleApkWebViewProviderFactory();
+        } catch (IllegalAccessException e) {
+            throw new RuntimeException(e);
+        } catch (NoSuchMethodException e2) {
+            throw new RuntimeException(e2);
+        } catch (InvocationTargetException e3) {
+            throw new RuntimeException(e3);
+        }
+    }
+
+    @NonNull
+    public static ClassLoader getWebViewClassLoader() {
+        if (Build.VERSION.SDK_INT >= 28) {
+            return ApiHelperForP.getWebViewClassLoader();
+        }
+        return getWebViewProviderFactory().getClass().getClassLoader();
+    }
+
+    private static Object getWebViewProviderFactory() {
+        try {
+            Method declaredMethod = WebView.class.getDeclaredMethod("getFactory", new Class[0]);
+            declaredMethod.setAccessible(true);
+            return declaredMethod.invoke(null, new Object[0]);
+        } catch (IllegalAccessException e) {
+            throw new RuntimeException(e);
+        } catch (NoSuchMethodException e2) {
+            throw new RuntimeException(e2);
+        } catch (InvocationTargetException e3) {
+            throw new RuntimeException(e3);
+        }
+    }
+
+    private WebViewGlueCommunicator() {
+    }
+}

decompiled/sources/androidx/webkit/internal/WebViewProviderAdapter.java

@@ -0,0 +1,105 @@
+package androidx.webkit.internal;
+
+import android.annotation.SuppressLint;
+import android.net.Uri;
+import android.webkit.WebChromeClient;
+import android.webkit.WebViewClient;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.webkit.Profile;
+import androidx.webkit.WebMessageCompat;
+import androidx.webkit.WebMessagePortCompat;
+import androidx.webkit.WebViewCompat;
+import androidx.webkit.WebViewRenderProcess;
+import androidx.webkit.WebViewRenderProcessClient;
+import java.lang.reflect.InvocationHandler;
+import java.util.concurrent.Executor;
+import org.chromium.support_lib_boundary.ProfileBoundaryInterface;
+import org.chromium.support_lib_boundary.WebViewProviderBoundaryInterface;
+import org.chromium.support_lib_boundary.util.BoundaryInterfaceReflectionUtil;
+
+/* loaded from: classes.dex */
+public class WebViewProviderAdapter {
+    WebViewProviderBoundaryInterface mImpl;
+
+    public WebViewProviderAdapter(@NonNull WebViewProviderBoundaryInterface webViewProviderBoundaryInterface) {
+        this.mImpl = webViewProviderBoundaryInterface;
+    }
+
+    public void insertVisualStateCallback(long j, @NonNull WebViewCompat.VisualStateCallback visualStateCallback) {
+        this.mImpl.insertVisualStateCallback(j, BoundaryInterfaceReflectionUtil.createInvocationHandlerFor(new VisualStateCallbackAdapter(visualStateCallback)));
+    }
+
+    @NonNull
+    public WebMessagePortCompat[] createWebMessageChannel() {
+        InvocationHandler[] createWebMessageChannel = this.mImpl.createWebMessageChannel();
+        WebMessagePortCompat[] webMessagePortCompatArr = new WebMessagePortCompat[createWebMessageChannel.length];
+        for (int i = 0; i < createWebMessageChannel.length; i++) {
+            webMessagePortCompatArr[i] = new WebMessagePortImpl(createWebMessageChannel[i]);
+        }
+        return webMessagePortCompatArr;
+    }
+
+    public void postWebMessage(@NonNull WebMessageCompat webMessageCompat, @NonNull Uri uri) {
+        this.mImpl.postMessageToMainFrame(BoundaryInterfaceReflectionUtil.createInvocationHandlerFor(new WebMessageAdapter(webMessageCompat)), uri);
+    }
+
+    public void addWebMessageListener(@NonNull String str, @NonNull String[] strArr, @NonNull WebViewCompat.WebMessageListener webMessageListener) {
+        this.mImpl.addWebMessageListener(str, strArr, BoundaryInterfaceReflectionUtil.createInvocationHandlerFor(new WebMessageListenerAdapter(webMessageListener)));
+    }
+
+    @NonNull
+    public ScriptHandlerImpl addDocumentStartJavaScript(@NonNull String str, @NonNull String[] strArr) {
+        return ScriptHandlerImpl.toScriptHandler(this.mImpl.addDocumentStartJavaScript(str, strArr));
+    }
+
+    public void removeWebMessageListener(@NonNull String str) {
+        this.mImpl.removeWebMessageListener(str);
+    }
+
+    @NonNull
+    public WebViewClient getWebViewClient() {
+        return this.mImpl.getWebViewClient();
+    }
+
+    @Nullable
+    public WebChromeClient getWebChromeClient() {
+        return this.mImpl.getWebChromeClient();
+    }
+
+    @Nullable
+    public WebViewRenderProcess getWebViewRenderProcess() {
+        return WebViewRenderProcessImpl.forInvocationHandler(this.mImpl.getWebViewRenderer());
+    }
+
+    @Nullable
+    public WebViewRenderProcessClient getWebViewRenderProcessClient() {
+        InvocationHandler webViewRendererClient = this.mImpl.getWebViewRendererClient();
+        if (webViewRendererClient == null) {
+            return null;
+        }
+        return ((WebViewRenderProcessClientAdapter) BoundaryInterfaceReflectionUtil.getDelegateFromInvocationHandler(webViewRendererClient)).getWebViewRenderProcessClient();
+    }
+
+    @SuppressLint({"LambdaLast"})
+    public void setWebViewRenderProcessClient(@Nullable Executor executor, @Nullable WebViewRenderProcessClient webViewRenderProcessClient) {
+        this.mImpl.setWebViewRendererClient(webViewRenderProcessClient != null ? BoundaryInterfaceReflectionUtil.createInvocationHandlerFor(new WebViewRenderProcessClientAdapter(executor, webViewRenderProcessClient)) : null);
+    }
+
+    public void setProfileWithName(@NonNull String str) {
+        this.mImpl.setProfile(str);
+    }
+
+    @NonNull
+    public Profile getProfile() {
+        return new ProfileImpl((ProfileBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(ProfileBoundaryInterface.class, this.mImpl.getProfile()));
+    }
+
+    public boolean isAudioMuted() {
+        return this.mImpl.isAudioMuted();
+    }
+
+    public void setAudioMuted(boolean z) {
+        this.mImpl.setAudioMuted(z);
+    }
+}

decompiled/sources/androidx/webkit/internal/WebViewProviderFactory.java

@@ -0,0 +1,42 @@
+package androidx.webkit.internal;
+
+import android.webkit.WebView;
+import androidx.annotation.NonNull;
+import org.chromium.support_lib_boundary.DropDataContentProviderBoundaryInterface;
+import org.chromium.support_lib_boundary.ProfileStoreBoundaryInterface;
+import org.chromium.support_lib_boundary.ProxyControllerBoundaryInterface;
+import org.chromium.support_lib_boundary.ServiceWorkerControllerBoundaryInterface;
+import org.chromium.support_lib_boundary.StaticsBoundaryInterface;
+import org.chromium.support_lib_boundary.TracingControllerBoundaryInterface;
+import org.chromium.support_lib_boundary.WebViewProviderBoundaryInterface;
+import org.chromium.support_lib_boundary.WebkitToCompatConverterBoundaryInterface;
+
+/* loaded from: classes.dex */
+public interface WebViewProviderFactory {
+    @NonNull
+    WebViewProviderBoundaryInterface createWebView(@NonNull WebView webView);
+
+    @NonNull
+    DropDataContentProviderBoundaryInterface getDropDataProvider();
+
+    @NonNull
+    ProfileStoreBoundaryInterface getProfileStore();
+
+    @NonNull
+    ProxyControllerBoundaryInterface getProxyController();
+
+    @NonNull
+    ServiceWorkerControllerBoundaryInterface getServiceWorkerController();
+
+    @NonNull
+    StaticsBoundaryInterface getStatics();
+
+    @NonNull
+    TracingControllerBoundaryInterface getTracingController();
+
+    @NonNull
+    String[] getWebViewFeatures();
+
+    @NonNull
+    WebkitToCompatConverterBoundaryInterface getWebkitToCompatConverter();
+}

decompiled/sources/androidx/webkit/internal/WebViewProviderFactoryAdapter.java

@@ -0,0 +1,77 @@
+package androidx.webkit.internal;
+
+import android.webkit.WebView;
+import androidx.annotation.NonNull;
+import org.chromium.support_lib_boundary.DropDataContentProviderBoundaryInterface;
+import org.chromium.support_lib_boundary.ProfileStoreBoundaryInterface;
+import org.chromium.support_lib_boundary.ProxyControllerBoundaryInterface;
+import org.chromium.support_lib_boundary.ServiceWorkerControllerBoundaryInterface;
+import org.chromium.support_lib_boundary.StaticsBoundaryInterface;
+import org.chromium.support_lib_boundary.TracingControllerBoundaryInterface;
+import org.chromium.support_lib_boundary.WebViewProviderBoundaryInterface;
+import org.chromium.support_lib_boundary.WebViewProviderFactoryBoundaryInterface;
+import org.chromium.support_lib_boundary.WebkitToCompatConverterBoundaryInterface;
+import org.chromium.support_lib_boundary.util.BoundaryInterfaceReflectionUtil;
+
+/* loaded from: classes.dex */
+public class WebViewProviderFactoryAdapter implements WebViewProviderFactory {
+    final WebViewProviderFactoryBoundaryInterface mImpl;
+
+    public WebViewProviderFactoryAdapter(@NonNull WebViewProviderFactoryBoundaryInterface webViewProviderFactoryBoundaryInterface) {
+        this.mImpl = webViewProviderFactoryBoundaryInterface;
+    }
+
+    @Override // androidx.webkit.internal.WebViewProviderFactory
+    @NonNull
+    public WebViewProviderBoundaryInterface createWebView(@NonNull WebView webView) {
+        return (WebViewProviderBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(WebViewProviderBoundaryInterface.class, this.mImpl.createWebView(webView));
+    }
+
+    @Override // androidx.webkit.internal.WebViewProviderFactory
+    @NonNull
+    public WebkitToCompatConverterBoundaryInterface getWebkitToCompatConverter() {
+        return (WebkitToCompatConverterBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(WebkitToCompatConverterBoundaryInterface.class, this.mImpl.getWebkitToCompatConverter());
+    }
+
+    @Override // androidx.webkit.internal.WebViewProviderFactory
+    @NonNull
+    public StaticsBoundaryInterface getStatics() {
+        return (StaticsBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(StaticsBoundaryInterface.class, this.mImpl.getStatics());
+    }
+
+    @Override // androidx.webkit.internal.WebViewProviderFactory
+    @NonNull
+    public String[] getWebViewFeatures() {
+        return this.mImpl.getSupportedFeatures();
+    }
+
+    @Override // androidx.webkit.internal.WebViewProviderFactory
+    @NonNull
+    public ServiceWorkerControllerBoundaryInterface getServiceWorkerController() {
+        return (ServiceWorkerControllerBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(ServiceWorkerControllerBoundaryInterface.class, this.mImpl.getServiceWorkerController());
+    }
+
+    @Override // androidx.webkit.internal.WebViewProviderFactory
+    @NonNull
+    public TracingControllerBoundaryInterface getTracingController() {
+        return (TracingControllerBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(TracingControllerBoundaryInterface.class, this.mImpl.getTracingController());
+    }
+
+    @Override // androidx.webkit.internal.WebViewProviderFactory
+    @NonNull
+    public ProxyControllerBoundaryInterface getProxyController() {
+        return (ProxyControllerBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(ProxyControllerBoundaryInterface.class, this.mImpl.getProxyController());
+    }
+
+    @Override // androidx.webkit.internal.WebViewProviderFactory
+    @NonNull
+    public DropDataContentProviderBoundaryInterface getDropDataProvider() {
+        return (DropDataContentProviderBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(DropDataContentProviderBoundaryInterface.class, this.mImpl.getDropDataProvider());
+    }
+
+    @Override // androidx.webkit.internal.WebViewProviderFactory
+    @NonNull
+    public ProfileStoreBoundaryInterface getProfileStore() {
+        return (ProfileStoreBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(ProfileStoreBoundaryInterface.class, this.mImpl.getProfileStore());
+    }
+}

decompiled/sources/androidx/webkit/internal/WebViewRenderProcessClientAdapter.java

@@ -0,0 +1,69 @@
+package androidx.webkit.internal;
+
+import android.annotation.SuppressLint;
+import android.webkit.WebView;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.webkit.WebViewFeature;
+import androidx.webkit.WebViewRenderProcessClient;
+import java.lang.reflect.InvocationHandler;
+import java.util.concurrent.Executor;
+import org.chromium.support_lib_boundary.WebViewRendererClientBoundaryInterface;
+
+/* loaded from: classes.dex */
+public class WebViewRenderProcessClientAdapter implements WebViewRendererClientBoundaryInterface {
+    private static final String[] sSupportedFeatures = {WebViewFeature.WEB_VIEW_RENDERER_CLIENT_BASIC_USAGE};
+    private final Executor mExecutor;
+    private final WebViewRenderProcessClient mWebViewRenderProcessClient;
+
+    @Override // org.chromium.support_lib_boundary.FeatureFlagHolderBoundaryInterface
+    @NonNull
+    public final String[] getSupportedFeatures() {
+        return sSupportedFeatures;
+    }
+
+    @Nullable
+    public WebViewRenderProcessClient getWebViewRenderProcessClient() {
+        return this.mWebViewRenderProcessClient;
+    }
+
+    @SuppressLint({"LambdaLast"})
+    public WebViewRenderProcessClientAdapter(@Nullable Executor executor, @Nullable WebViewRenderProcessClient webViewRenderProcessClient) {
+        this.mExecutor = executor;
+        this.mWebViewRenderProcessClient = webViewRenderProcessClient;
+    }
+
+    @Override // org.chromium.support_lib_boundary.WebViewRendererClientBoundaryInterface
+    public final void onRendererUnresponsive(@NonNull final WebView webView, @NonNull InvocationHandler invocationHandler) {
+        final WebViewRenderProcessImpl forInvocationHandler = WebViewRenderProcessImpl.forInvocationHandler(invocationHandler);
+        final WebViewRenderProcessClient webViewRenderProcessClient = this.mWebViewRenderProcessClient;
+        Executor executor = this.mExecutor;
+        if (executor == null) {
+            webViewRenderProcessClient.onRenderProcessUnresponsive(webView, forInvocationHandler);
+        } else {
+            executor.execute(new Runnable() { // from class: androidx.webkit.internal.WebViewRenderProcessClientAdapter.1
+                @Override // java.lang.Runnable
+                public void run() {
+                    webViewRenderProcessClient.onRenderProcessUnresponsive(webView, forInvocationHandler);
+                }
+            });
+        }
+    }
+
+    @Override // org.chromium.support_lib_boundary.WebViewRendererClientBoundaryInterface
+    public final void onRendererResponsive(@NonNull final WebView webView, @NonNull InvocationHandler invocationHandler) {
+        final WebViewRenderProcessImpl forInvocationHandler = WebViewRenderProcessImpl.forInvocationHandler(invocationHandler);
+        final WebViewRenderProcessClient webViewRenderProcessClient = this.mWebViewRenderProcessClient;
+        Executor executor = this.mExecutor;
+        if (executor == null) {
+            webViewRenderProcessClient.onRenderProcessResponsive(webView, forInvocationHandler);
+        } else {
+            executor.execute(new Runnable() { // from class: androidx.webkit.internal.WebViewRenderProcessClientAdapter.2
+                @Override // java.lang.Runnable
+                public void run() {
+                    webViewRenderProcessClient.onRenderProcessResponsive(webView, forInvocationHandler);
+                }
+            });
+        }
+    }
+}

decompiled/sources/androidx/webkit/internal/WebViewRenderProcessClientFrameworkAdapter.java

@@ -0,0 +1,31 @@
+package androidx.webkit.internal;
+
+import android.webkit.WebView;
+import android.webkit.WebViewRenderProcess;
+import android.webkit.WebViewRenderProcessClient;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+
+@RequiresApi(29)
+/* loaded from: classes.dex */
+public class WebViewRenderProcessClientFrameworkAdapter extends WebViewRenderProcessClient {
+    private androidx.webkit.WebViewRenderProcessClient mWebViewRenderProcessClient;
+
+    @Nullable
+    public androidx.webkit.WebViewRenderProcessClient getFrameworkRenderProcessClient() {
+        return this.mWebViewRenderProcessClient;
+    }
+
+    public WebViewRenderProcessClientFrameworkAdapter(@NonNull androidx.webkit.WebViewRenderProcessClient webViewRenderProcessClient) {
+        this.mWebViewRenderProcessClient = webViewRenderProcessClient;
+    }
+
+    public void onRenderProcessUnresponsive(@NonNull WebView webView, @Nullable WebViewRenderProcess webViewRenderProcess) {
+        this.mWebViewRenderProcessClient.onRenderProcessUnresponsive(webView, WebViewRenderProcessImpl.forFrameworkObject(webViewRenderProcess));
+    }
+
+    public void onRenderProcessResponsive(@NonNull WebView webView, @Nullable WebViewRenderProcess webViewRenderProcess) {
+        this.mWebViewRenderProcessClient.onRenderProcessResponsive(webView, WebViewRenderProcessImpl.forFrameworkObject(webViewRenderProcess));
+    }
+}

decompiled/sources/androidx/webkit/internal/WebViewRenderProcessImpl$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,10 @@
+package androidx.webkit.internal;
+
+import android.webkit.WebViewRenderProcess;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class WebViewRenderProcessImpl$$ExternalSyntheticApiModelOutline0 {
+    public static /* bridge */ /* synthetic */ WebViewRenderProcess m(Object obj) {
+        return (WebViewRenderProcess) obj;
+    }
+}

decompiled/sources/androidx/webkit/internal/WebViewRenderProcessImpl.java

@@ -0,0 +1,62 @@
+package androidx.webkit.internal;
+
+import androidx.annotation.NonNull;
+import androidx.webkit.WebViewRenderProcess;
+import androidx.webkit.internal.ApiFeature;
+import java.lang.ref.WeakReference;
+import java.lang.reflect.InvocationHandler;
+import java.util.WeakHashMap;
+import java.util.concurrent.Callable;
+import org.chromium.support_lib_boundary.WebViewRendererBoundaryInterface;
+import org.chromium.support_lib_boundary.util.BoundaryInterfaceReflectionUtil;
+
+/* loaded from: classes.dex */
+public class WebViewRenderProcessImpl extends WebViewRenderProcess {
+    private static final WeakHashMap<android.webkit.WebViewRenderProcess, WebViewRenderProcessImpl> sFrameworkMap = new WeakHashMap<>();
+    private WebViewRendererBoundaryInterface mBoundaryInterface;
+    private WeakReference<android.webkit.WebViewRenderProcess> mFrameworkObject;
+
+    public WebViewRenderProcessImpl(@NonNull WebViewRendererBoundaryInterface webViewRendererBoundaryInterface) {
+        this.mBoundaryInterface = webViewRendererBoundaryInterface;
+    }
+
+    public WebViewRenderProcessImpl(@NonNull android.webkit.WebViewRenderProcess webViewRenderProcess) {
+        this.mFrameworkObject = new WeakReference<>(webViewRenderProcess);
+    }
+
+    @NonNull
+    public static WebViewRenderProcessImpl forInvocationHandler(@NonNull InvocationHandler invocationHandler) {
+        final WebViewRendererBoundaryInterface webViewRendererBoundaryInterface = (WebViewRendererBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(WebViewRendererBoundaryInterface.class, invocationHandler);
+        return (WebViewRenderProcessImpl) webViewRendererBoundaryInterface.getOrCreatePeer(new Callable<Object>() { // from class: androidx.webkit.internal.WebViewRenderProcessImpl.1
+            @Override // java.util.concurrent.Callable
+            public Object call() {
+                return new WebViewRenderProcessImpl(WebViewRendererBoundaryInterface.this);
+            }
+        });
+    }
+
+    @NonNull
+    public static WebViewRenderProcessImpl forFrameworkObject(@NonNull android.webkit.WebViewRenderProcess webViewRenderProcess) {
+        WeakHashMap<android.webkit.WebViewRenderProcess, WebViewRenderProcessImpl> weakHashMap = sFrameworkMap;
+        WebViewRenderProcessImpl webViewRenderProcessImpl = weakHashMap.get(webViewRenderProcess);
+        if (webViewRenderProcessImpl != null) {
+            return webViewRenderProcessImpl;
+        }
+        WebViewRenderProcessImpl webViewRenderProcessImpl2 = new WebViewRenderProcessImpl(webViewRenderProcess);
+        weakHashMap.put(webViewRenderProcess, webViewRenderProcessImpl2);
+        return webViewRenderProcessImpl2;
+    }
+
+    @Override // androidx.webkit.WebViewRenderProcess
+    public boolean terminate() {
+        ApiFeature.Q q = WebViewFeatureInternal.WEB_VIEW_RENDERER_TERMINATE;
+        if (q.isSupportedByFramework()) {
+            android.webkit.WebViewRenderProcess m = WebViewRenderProcessImpl$$ExternalSyntheticApiModelOutline0.m(this.mFrameworkObject.get());
+            return m != null && ApiHelperForQ.terminate(m);
+        }
+        if (q.isSupportedByWebView()) {
+            return this.mBoundaryInterface.terminate();
+        }
+        throw WebViewFeatureInternal.getUnsupportedOperationException();
+    }
+}

decompiled/sources/androidx/webkit/internal/WebkitToCompatConverter$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,10 @@
+package androidx.webkit.internal;
+
+import android.webkit.SafeBrowsingResponse;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class WebkitToCompatConverter$$ExternalSyntheticApiModelOutline0 {
+    public static /* bridge */ /* synthetic */ SafeBrowsingResponse m(Object obj) {
+        return (SafeBrowsingResponse) obj;
+    }
+}

decompiled/sources/androidx/webkit/internal/WebkitToCompatConverter.java

@@ -0,0 +1,85 @@
+package androidx.webkit.internal;
+
+import android.webkit.CookieManager;
+import android.webkit.SafeBrowsingResponse;
+import android.webkit.ServiceWorkerWebSettings;
+import android.webkit.WebMessagePort;
+import android.webkit.WebResourceError;
+import android.webkit.WebResourceRequest;
+import android.webkit.WebSettings;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+import java.lang.reflect.InvocationHandler;
+import org.chromium.support_lib_boundary.WebResourceRequestBoundaryInterface;
+import org.chromium.support_lib_boundary.WebSettingsBoundaryInterface;
+import org.chromium.support_lib_boundary.WebViewCookieManagerBoundaryInterface;
+import org.chromium.support_lib_boundary.WebkitToCompatConverterBoundaryInterface;
+import org.chromium.support_lib_boundary.util.BoundaryInterfaceReflectionUtil;
+
+/* loaded from: classes.dex */
+public class WebkitToCompatConverter {
+    private final WebkitToCompatConverterBoundaryInterface mImpl;
+
+    public WebkitToCompatConverter(@NonNull WebkitToCompatConverterBoundaryInterface webkitToCompatConverterBoundaryInterface) {
+        this.mImpl = webkitToCompatConverterBoundaryInterface;
+    }
+
+    @NonNull
+    public WebSettingsAdapter convertSettings(@NonNull WebSettings webSettings) {
+        return new WebSettingsAdapter((WebSettingsBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(WebSettingsBoundaryInterface.class, this.mImpl.convertSettings(webSettings)));
+    }
+
+    @NonNull
+    public WebResourceRequestAdapter convertWebResourceRequest(@NonNull WebResourceRequest webResourceRequest) {
+        return new WebResourceRequestAdapter((WebResourceRequestBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(WebResourceRequestBoundaryInterface.class, this.mImpl.convertWebResourceRequest(webResourceRequest)));
+    }
+
+    @NonNull
+    public InvocationHandler convertServiceWorkerSettings(@NonNull ServiceWorkerWebSettings serviceWorkerWebSettings) {
+        return this.mImpl.convertServiceWorkerSettings(serviceWorkerWebSettings);
+    }
+
+    @NonNull
+    @RequiresApi(24)
+    public ServiceWorkerWebSettings convertServiceWorkerSettings(@NonNull InvocationHandler invocationHandler) {
+        return (ServiceWorkerWebSettings) this.mImpl.convertServiceWorkerSettings(invocationHandler);
+    }
+
+    @NonNull
+    public InvocationHandler convertWebResourceError(@NonNull WebResourceError webResourceError) {
+        return this.mImpl.convertWebResourceError(webResourceError);
+    }
+
+    @NonNull
+    @RequiresApi(23)
+    public WebResourceError convertWebResourceError(@NonNull InvocationHandler invocationHandler) {
+        return (WebResourceError) this.mImpl.convertWebResourceError(invocationHandler);
+    }
+
+    @NonNull
+    public InvocationHandler convertSafeBrowsingResponse(@NonNull SafeBrowsingResponse safeBrowsingResponse) {
+        return this.mImpl.convertSafeBrowsingResponse(safeBrowsingResponse);
+    }
+
+    @NonNull
+    @RequiresApi(27)
+    public SafeBrowsingResponse convertSafeBrowsingResponse(@NonNull InvocationHandler invocationHandler) {
+        return WebkitToCompatConverter$$ExternalSyntheticApiModelOutline0.m(this.mImpl.convertSafeBrowsingResponse(invocationHandler));
+    }
+
+    @NonNull
+    public InvocationHandler convertWebMessagePort(@NonNull WebMessagePort webMessagePort) {
+        return this.mImpl.convertWebMessagePort(webMessagePort);
+    }
+
+    @NonNull
+    @RequiresApi(23)
+    public WebMessagePort convertWebMessagePort(@NonNull InvocationHandler invocationHandler) {
+        return (WebMessagePort) this.mImpl.convertWebMessagePort(invocationHandler);
+    }
+
+    @NonNull
+    public CookieManagerAdapter convertCookieManager(@NonNull CookieManager cookieManager) {
+        return new CookieManagerAdapter((WebViewCookieManagerBoundaryInterface) BoundaryInterfaceReflectionUtil.castToSuppLibClass(WebViewCookieManagerBoundaryInterface.class, this.mImpl.convertCookieManager(cookieManager)));
+    }
+}

decompiled/sources/androidx/webkit/internal/package-info.java

@@ -0,0 +1,5 @@
+@RestrictTo({RestrictTo.Scope.LIBRARY})
+package androidx.webkit.internal;
+
+import androidx.annotation.RestrictTo;
+