Add debug logging for calls into AwContents

android_webview/java/src/org/chromium/android_webview/AwContents.java

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.android_webview;
 
 import android.annotation.SuppressLint;
 import android.app.Activity;
 import android.content.ComponentCallbacks2;
 import android.content.Context;
@@ skipping 71 matching lines @@
  * and Browser components that are required to implement Android WebView API. This is the
  * primary entry point for the WebViewProvider implementation; it holds a 1:1 object
  * relationship with application WebView instances.
  * (We define this class independent of the hidden WebViewProvider interfaces, to allow
  * continuous build & test in the open source SDK-based tree).
  */
 @JNINamespace("android_webview")
 public class AwContents implements SmartClipProvider,
         PostMessageSender.PostMessageSenderDelegate {
     private static final String TAG = "AwContents";
+    private static final boolean TRACE = false;
 
     private static final String WEB_ARCHIVE_EXTENSION = ".mht";
 
     // Used to avoid enabling zooming in / out if resulting zooming will
     // produce little visible difference.
     private static final float ZOOM_CONTROLS_EPSILON = 0.007f;
 
     /**
      * WebKit hit test related data structure. These are used to implement
      * getHitTestResult, requestFocusNodeHref, requestImageRef methods in WebView.
@@ skipping 860 matching lines @@
                     entry.getValue().first,
                     entry.getKey(),
                     requiredAnnotation);
         }
     }
 
     /**
      * Destroys this object and deletes its native counterpart.
      */
     public void destroy() {
+        if (TRACE) Log.d(TAG, "destroy");
         if (isDestroyed()) return;
 
         if  (mPostMessageSender != null) {
             mBrowserContext.getMessagePortService().removeObserver(mPostMessageSender);
             mPostMessageSender = null;
         }
 
         // If we are attached, we have to call native detach to clean up
         // hardware resources.
         if (mIsAttachedToWindow) {
@@ skipping 147 matching lines @@
 
     public int getContentHeightCss() {
         return (int) Math.ceil(mContentHeightDip);
     }
 
     public int getContentWidthCss() {
         return (int) Math.ceil(mContentWidthDip);
     }
 
     public Picture capturePicture() {
+        if (TRACE) Log.d(TAG, "capturePicture");
         if (isDestroyed()) return null;
         return new AwPicture(nativeCapturePicture(mNativeAwContents,
                 mScrollOffsetManager.computeHorizontalScrollRange(),
                 mScrollOffsetManager.computeVerticalScrollRange()));
     }
 
     public void clearView() {
+        if (TRACE) Log.d(TAG, "clearView");
         if (!isDestroyed()) nativeClearView(mNativeAwContents);
     }
 
     /**
      * Enable the onNewPicture callback.
      * @param enabled Flag to enable the callback.
      * @param invalidationOnly Flag to call back only on invalidation without providing a picture.
      */
     public void enableOnNewPicture(boolean enabled, boolean invalidationOnly) {
+        if (TRACE) Log.d(TAG, "enableOnNewPicture=" + enabled);
         if (isDestroyed()) return;
         if (invalidationOnly) {
             mPictureListenerContentProvider = null;
         } else if (enabled && mPictureListenerContentProvider == null) {
             mPictureListenerContentProvider = new Callable<Picture>() {
                 @Override
                 public Picture call() {
                     return capturePicture();
                 }
             };
         }
         nativeEnableOnNewPicture(mNativeAwContents, enabled);
     }
 
     public void findAllAsync(String searchString) {
+        if (TRACE) Log.d(TAG, "findAllAsync");
         if (!isDestroyed()) nativeFindAllAsync(mNativeAwContents, searchString);
     }
 
     public void findNext(boolean forward) {
+        if (TRACE) Log.d(TAG, "findNext");
         if (!isDestroyed()) nativeFindNext(mNativeAwContents, forward);
     }
 
     public void clearMatches() {
+        if (TRACE) Log.d(TAG, "clearMatches");
         if (!isDestroyed()) nativeClearMatches(mNativeAwContents);
     }
 
     /**
      * @return load progress of the WebContents.
      */
     public int getMostRecentProgress() {
         // WebContentsDelegateAndroid conveniently caches the most recent notified value for us.
         return mWebContentsDelegate.getMostRecentProgress();
     }
@@ skipping 14 matching lines @@
                 });
             }
         };
         mContentsClient.getVisitedHistory(callback);
     }
 
     /**
      * WebView.loadUrl.
      */
     public void loadUrl(String url, Map<String, String> additionalHttpHeaders) {
+        if (TRACE) Log.d(TAG, "loadUrl(extra headers)=" + url);
         // TODO: We may actually want to do some sanity checks here (like filter about://chrome).
 
         // For backwards compatibility, apps targeting less than K will have JS URLs evaluated
         // directly and any result of the evaluation will not replace the current page content.
         // Matching Chrome behavior more closely; apps targetting >= K that load a JS URL will
         // have the result of that URL replace the content of the current page.
         final String javaScriptScheme = "javascript:";
         if (mAppTargetSdkVersion < Build.VERSION_CODES.KITKAT && url != null
                 && url.startsWith(javaScriptScheme)) {
             evaluateJavaScript(url.substring(javaScriptScheme.length()), null);
             return;
         }
 
         LoadUrlParams params = new LoadUrlParams(url);
         if (additionalHttpHeaders != null) params.setExtraHeaders(additionalHttpHeaders);
         loadUrl(params);
     }
 
     /**
      * WebView.loadUrl.
      */
     public void loadUrl(String url) {
+        if (TRACE) Log.d(TAG, "loadUrl=" + url);
         // Early out to match old WebView implementation
         if (url == null) {
             return;
         }
-        loadUrl(url, null);
+        LoadUrlParams params = new LoadUrlParams(url);
+        loadUrl(params);
     }
 
     /**
      * WebView.postUrl.
      */
     public void postUrl(String url, byte[] postData) {
+        if (TRACE) Log.d(TAG, "postUrl=" + url);
         LoadUrlParams params = LoadUrlParams.createLoadHttpPostParams(url, postData);
         Map<String, String> headers = new HashMap<String, String>();
         headers.put("Content-Type", "application/x-www-form-urlencoded");
         params.setExtraHeaders(headers);
         loadUrl(params);
     }
 
     private static String fixupMimeType(String mimeType) {
         return TextUtils.isEmpty(mimeType) ? "text/html" : mimeType;
     }
@@ skipping 11 matching lines @@
     }
 
     private static boolean isBase64Encoded(String encoding) {
         return "base64".equals(encoding);
     }
 
     /**
      * WebView.loadData.
      */
     public void loadData(String data, String mimeType, String encoding) {
+        if (TRACE) Log.d(TAG, "loadData");
         loadUrl(LoadUrlParams.createLoadDataParams(
                 fixupData(data), fixupMimeType(mimeType), isBase64Encoded(encoding)));
     }
 
     /**
      * WebView.loadDataWithBaseURL.
      */
     public void loadDataWithBaseURL(
             String baseUrl, String data, String mimeType, String encoding, String historyUrl) {
+        if (TRACE) Log.d(TAG, "loadDataWithBaseURL=" + baseUrl);
         data = fixupData(data);
         mimeType = fixupMimeType(mimeType);
         LoadUrlParams loadUrlParams;
         baseUrl = fixupBase(baseUrl);
         historyUrl = fixupHistory(historyUrl);
 
         if (baseUrl.startsWith("data:")) {
             // For backwards compatibility with WebViewClassic, we use the value of |encoding|
             // as the charset, as long as it's not "base64".
             boolean isBase64 = isBase64Encoded(encoding);
@@ skipping 171 matching lines @@
             mOverlayHorizontalScrollbar = mOverlayVerticalScrollbar = true;
         } else {
             mOverlayHorizontalScrollbar = mOverlayVerticalScrollbar = false;
         }
     }
 
     /**
      * @see View#setHorizontalScrollbarOverlay(boolean)
      */
     public void setHorizontalScrollbarOverlay(boolean overlay) {
+        if (TRACE) Log.d(TAG, "setHorizontalScrollbarOverlay=" + overlay);
         mOverlayHorizontalScrollbar = overlay;
     }
 
     /**
      * @see View#setVerticalScrollbarOverlay(boolean)
      */
     public void setVerticalScrollbarOverlay(boolean overlay) {
+        if (TRACE) Log.d(TAG, "setVerticalScrollbarOverlay=" + overlay);
         mOverlayVerticalScrollbar = overlay;
     }
 
     /**
      * @see View#overlayHorizontalScrollbar()
      */
     public boolean overlayHorizontalScrollbar() {
         return mOverlayHorizontalScrollbar;
     }
 
@@ skipping 69 matching lines @@
      * @see View.computeScroll()
      */
     public void computeScroll() {
         mAwViewMethods.computeScroll();
     }
 
     /**
      * @see android.webkit.WebView#stopLoading()
      */
     public void stopLoading() {
+        if (TRACE) Log.d(TAG, "stopLoading");
         if (!isDestroyed()) mWebContents.stop();
     }
 
     /**
      * @see android.webkit.WebView#reload()
      */
     public void reload() {
+        if (TRACE) Log.d(TAG, "reload");
         if (!isDestroyed()) mNavigationController.reload(true);
     }
 
     /**
      * @see android.webkit.WebView#canGoBack()
      */
     public boolean canGoBack() {
         return isDestroyed() ? false : mNavigationController.canGoBack();
     }
 
     /**
      * @see android.webkit.WebView#goBack()
      */
     public void goBack() {
+        if (TRACE) Log.d(TAG, "goBack");
         if (!isDestroyed()) mNavigationController.goBack();
     }
 
     /**
      * @see android.webkit.WebView#canGoForward()
      */
     public boolean canGoForward() {
         return isDestroyed() ? false : mNavigationController.canGoForward();
     }
 
     /**
      * @see android.webkit.WebView#goForward()
      */
     public void goForward() {
+        if (TRACE) Log.d(TAG, "goForward");
         if (!isDestroyed()) mNavigationController.goForward();
     }
 
     /**
      * @see android.webkit.WebView#canGoBackOrForward(int)
      */
     public boolean canGoBackOrForward(int steps) {
         return isDestroyed() ? false : mNavigationController.canGoToOffset(steps);
     }
 
     /**
      * @see android.webkit.WebView#goBackOrForward(int)
      */
     public void goBackOrForward(int steps) {
+        if (TRACE) Log.d(TAG, "goBackOrForwad=" + steps);
         if (!isDestroyed()) mNavigationController.goToOffset(steps);
     }
 
     /**
      * @see android.webkit.WebView#pauseTimers()
      */
     public void pauseTimers() {
+        if (TRACE) Log.d(TAG, "pauseTimers");
         if (!isDestroyed()) ContentViewStatics.setWebKitSharedTimersSuspended(true);
     }
 
     /**
      * @see android.webkit.WebView#resumeTimers()
      */
     public void resumeTimers() {
+        if (TRACE) Log.d(TAG, "resumeTimers");
         if (!isDestroyed()) ContentViewStatics.setWebKitSharedTimersSuspended(false);
     }
 
     /**
      * @see android.webkit.WebView#onPause()
      */
     public void onPause() {
+        if (TRACE) Log.d(TAG, "onPause");
         if (mIsPaused || isDestroyed()) return;
         mIsPaused = true;
         nativeSetIsPaused(mNativeAwContents, mIsPaused);
         mContentViewCore.onHide();
     }
 
     /**
      * @see android.webkit.WebView#onResume()
      */
     public void onResume() {
+        if (TRACE) Log.d(TAG, "onResume");
         if (!mIsPaused || isDestroyed()) return;
         mIsPaused = false;
         nativeSetIsPaused(mNativeAwContents, mIsPaused);
         mContentViewCore.onShow();
     }
 
     /**
      * @see android.webkit.WebView#isPaused()
      */
     public boolean isPaused() {
@@ skipping 21 matching lines @@
         return mAwViewMethods.dispatchKeyEvent(event);
     }
 
     /**
      * Clears the resource cache. Note that the cache is per-application, so this will clear the
      * cache for all WebViews used.
      *
      * @param includeDiskFiles if false, only the RAM cache is cleared
      */
     public void clearCache(boolean includeDiskFiles) {
+        if (TRACE) Log.d(TAG, "clearCache");
         if (!isDestroyed()) nativeClearCache(mNativeAwContents, includeDiskFiles);
     }
 
     public void documentHasImages(Message message) {
         if (!isDestroyed()) nativeDocumentHasImages(mNativeAwContents, message);
     }
 
     public void saveWebArchive(
             final String basename, boolean autoname, final ValueCallback<String> callback) {
+        if (TRACE) Log.d(TAG, "saveWebArchive=" + basename);
         if (!autoname) {
             saveWebArchiveInternal(basename, callback);
             return;
         }
         // If auto-generating the file name, handle the name generation on a background thread
         // as it will require I/O access for checking whether previous files existed.
         new AsyncTask<Void, Void, String>() {
             @Override
             protected String doInBackground(Void... params) {
                 return generateArchiveAutoNamePath(getOriginalUrl(), basename);
@@ skipping 27 matching lines @@
      * @see android.webkit.WebView#getTitle()
      */
     public String getTitle() {
         return isDestroyed() ? null : mWebContents.getTitle();
     }
 
     /**
      * @see android.webkit.WebView#clearHistory()
      */
     public void clearHistory() {
+        if (TRACE) Log.d(TAG, "clearHistory");
         if (!isDestroyed()) mNavigationController.clearHistory();
     }
 
     public String[] getHttpAuthUsernamePassword(String host, String realm) {
         return mBrowserContext.getHttpAuthDatabase(mContext)
                 .getHttpAuthUsernamePassword(host, realm);
     }
 
     public void setHttpAuthUsernamePassword(String host, String realm, String username,
             String password) {
+        if (TRACE) Log.d(TAG, "setHttpAuthUsernamePassword=" + host);
         mBrowserContext.getHttpAuthDatabase(mContext)
                 .setHttpAuthUsernamePassword(host, realm, username, password);
     }
 
     /**
      * @see android.webkit.WebView#getCertificate()
      */
     public SslCertificate getCertificate() {
         return isDestroyed() ? null
                 : SslUtil.getCertificateFromDerBytes(nativeGetCertificate(mNativeAwContents));
     }
 
     /**
      * @see android.webkit.WebView#clearSslPreferences()
      */
     public void clearSslPreferences() {
+        if (TRACE) Log.d(TAG, "clearSslPreferences");
         if (!isDestroyed()) mNavigationController.clearSslPreferences();
     }
 
     /**
      * Method to return all hit test values relevant to public WebView API.
      * Note that this expose more data than needed for WebView.getHitTestResult.
      * Unsafely returning reference to mutable internal object to avoid excessive
      * garbage allocation on repeated calls.
      */
     public HitTestData getLastHitTestResult() {
+        if (TRACE) Log.d(TAG, "getLastHitTestResult");
         if (isDestroyed()) return null;
         nativeUpdateLastHitTestData(mNativeAwContents);
         return mPossiblyStaleHitTestData;
     }
 
     /**
      * @see android.webkit.WebView#requestFocusNodeHref()
      */
     public void requestFocusNodeHref(Message msg) {
+        if (TRACE) Log.d(TAG, "requestFocusNodeHref");
         if (msg == null || isDestroyed()) return;
 
         nativeUpdateLastHitTestData(mNativeAwContents);
         Bundle data = msg.getData();
 
         // In order to maintain compatibility with the old WebView's implementation,
         // the absolute (full) url is passed in the |url| field, not only the href attribute.
         // Note: HitTestData could be cleaned up at this point. See http://crbug.com/290992.
         data.putString("url", mPossiblyStaleHitTestData.href);
         data.putString("title", mPossiblyStaleHitTestData.anchorText);
         data.putString("src", mPossiblyStaleHitTestData.imgSrc);
         msg.setData(data);
         msg.sendToTarget();
     }
 
     /**
      * @see android.webkit.WebView#requestImageRef()
      */
     public void requestImageRef(Message msg) {
+        if (TRACE) Log.d(TAG, "requestImageRef");
         if (msg == null || isDestroyed()) return;
 
         nativeUpdateLastHitTestData(mNativeAwContents);
         Bundle data = msg.getData();
         data.putString("url", mPossiblyStaleHitTestData.imgSrc);
         msg.setData(data);
         msg.sendToTarget();
     }
 
     @VisibleForTesting
     public float getPageScaleFactor() {
         return mPageScaleFactor;
     }
 
     /**
      * @see android.webkit.WebView#getScale()
      *
      * Please note that the scale returned is the page scale multiplied by
      * the screen density factor. See CTS WebViewTest.testSetInitialScale.
      */
     public float getScale() {
         return (float) (mPageScaleFactor * mDIPScale);
     }
 
     /**
      * @see android.webkit.WebView#flingScroll(int, int)
      */
     public void flingScroll(int velocityX, int velocityY) {
+        if (TRACE) Log.d(TAG, "flingScroll");
         mScrollOffsetManager.flingScroll(velocityX, velocityY);
     }
 
     /**
      * @see android.webkit.WebView#pageUp(boolean)
      */
     public boolean pageUp(boolean top) {
+        if (TRACE) Log.d(TAG, "pageUp");
         return mScrollOffsetManager.pageUp(top);
     }
 
     /**
      * @see android.webkit.WebView#pageDown(boolean)
      */
     public boolean pageDown(boolean bottom) {
+        if (TRACE) Log.d(TAG, "pageDown");
         return mScrollOffsetManager.pageDown(bottom);
     }
 
     /**
      * @see android.webkit.WebView#canZoomIn()
      */
     // This method uses the term 'zoom' for legacy reasons, but relates
     // to what chrome calls the 'page scale factor'.
     public boolean canZoomIn() {
         final float zoomInExtent = mMaxPageScaleFactor - mPageScaleFactor;
@@ skipping 46 matching lines @@
         if (delta < 0.01f || delta > 100.0f) {
             throw new IllegalStateException("zoom delta value outside [0.01, 100] range.");
         }
         mContentViewCore.pinchByDelta(delta);
     }
 
     /**
      * @see android.webkit.WebView#invokeZoomPicker()
      */
     public void invokeZoomPicker() {
+        if (TRACE) Log.d(TAG, "invokeZoomPicker");
         if (!isDestroyed()) mContentViewCore.invokeZoomPicker();
     }
 
     /**
      * @see android.webkit.WebView#preauthorizePermission(Uri, long)
      */
     public void preauthorizePermission(Uri origin, long resources) {
         if (isDestroyed()) return;
         nativePreauthorizePermission(mNativeAwContents, origin.toString(), resources);
     }
 
     /**
      * @see ContentViewCore.evaluateJavaScript(String, JavaScriptCallback)
      */
     public void evaluateJavaScript(String script, final ValueCallback<String> callback) {
+        if (TRACE) Log.d(TAG, "evaluateJavascript=" + script);
         if (isDestroyed()) return;
         JavaScriptCallback jsCallback = null;
         if (callback != null) {
             jsCallback = new JavaScriptCallback() {
                 @Override
                 public void handleJavaScriptResult(String jsonResult) {
                     callback.onReceiveValue(jsonResult);
                 }
             };
         }
@@ skipping 30 matching lines @@
     }
 
     // Implements PostMessageSender.PostMessageSenderDelegate interface method.
     @Override
     public void onPostMessageQueueEmpty() { }
 
     // Implements PostMessageSender.PostMessageSenderDelegate interface method.
     @Override
     public void postMessageToWeb(String frameName, String message, String targetOrigin,
             int[] sentPortIds) {
+        if (TRACE) Log.d(TAG, "postMessageToWeb. TargetOrigin=" + targetOrigin);
         if (isDestroyed()) return;
         nativePostMessageToFrame(mNativeAwContents, frameName, message, targetOrigin,
                 sentPortIds);
     }
 
     /**
      * Creates a message channel and returns the ports for each end of the channel.
      */
     public MessagePort[] createMessageChannel() {
+        if (TRACE) Log.d(TAG, "createMessageChannel");
         if (isDestroyed()) return null;
         MessagePort[] ports = mBrowserContext.getMessagePortService().createMessageChannel();
         nativeCreateMessageChannel(mNativeAwContents, ports);
         return ports;
     }
 
     public boolean hasAccessedInitialDocument() {
         if (isDestroyed()) return false;
         return mWebContents.hasAccessedInitialDocument();
     }
@@ skipping 110 matching lines @@
     /**
      * Key for opaque state in bundle. Note this is only public for tests.
      */
     public static final String SAVE_RESTORE_STATE_KEY = "WEBVIEW_CHROMIUM_STATE";
 
     /**
      * Save the state of this AwContents into provided Bundle.
      * @return False if saving state failed.
      */
     public boolean saveState(Bundle outState) {
+        if (TRACE) Log.d(TAG, "saveState");
         if (isDestroyed() || outState == null) return false;
 
         byte[] state = nativeGetOpaqueState(mNativeAwContents);
         if (state == null) return false;
 
         outState.putByteArray(SAVE_RESTORE_STATE_KEY, state);
         return true;
     }
 
     /**
      * Restore the state of this AwContents into provided Bundle.
      * @param inState Must be a bundle returned by saveState.
      * @return False if restoring state failed.
      */
     public boolean restoreState(Bundle inState) {
+        if (TRACE) Log.d(TAG, "restoreState");
         if (isDestroyed() || inState == null) return false;
 
         byte[] state = inState.getByteArray(SAVE_RESTORE_STATE_KEY);
         if (state == null) return false;
 
         boolean result = nativeRestoreFromOpaqueState(mNativeAwContents, state);
 
         // The onUpdateTitle callback normally happens when a page is loaded,
         // but is optimized out in the restoreState case because the title is
         // already restored. See WebContentsImpl::UpdateTitleForEntry. So we
         // call the callback explicitly here.
         if (result) mContentsClient.onReceivedTitle(mWebContents.getTitle());
 
         return result;
     }
 
     /**
      * @see ContentViewCore#addPossiblyUnsafeJavascriptInterface(Object, String, Class)
      */
     @SuppressLint("NewApi")  // JavascriptInterface requires API level 17.
     public void addJavascriptInterface(Object object, String name) {
+        if (TRACE) Log.d(TAG, "addJavascriptInterface=" + name);
         if (isDestroyed()) return;
         Class<? extends Annotation> requiredAnnotation = null;
         if (mAppTargetSdkVersion >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
             requiredAnnotation = JavascriptInterface.class;
         }
         mContentViewCore.addPossiblyUnsafeJavascriptInterface(object, name, requiredAnnotation);
     }
 
     /**
      * @see android.webkit.WebView#removeJavascriptInterface(String)
      */
     public void removeJavascriptInterface(String interfaceName) {
+        if (TRACE) Log.d(TAG, "removeJavascriptInterface=" + interfaceName);
         if (!isDestroyed()) mContentViewCore.removeJavascriptInterface(interfaceName);
     }
 
     /**
      * If native accessibility (not script injection) is enabled, and if this is
      * running on JellyBean or later, returns an AccessibilityNodeProvider that
      * implements native accessibility for this view. Returns null otherwise.
      * @return The AccessibilityNodeProvider, if available, or null otherwise.
      */
     public AccessibilityNodeProvider getAccessibilityNodeProvider() {
@@ skipping 23 matching lines @@
      */
     public boolean performAccessibilityAction(int action, Bundle arguments) {
         return isDestroyed() ? false
                 : mContentViewCore.performAccessibilityAction(action, arguments);
     }
 
     /**
      * @see android.webkit.WebView#clearFormData()
      */
     public void hideAutofillPopup() {
+        if (TRACE) Log.d(TAG, "hideAutofillPopup");
         if (mAwAutofillClient != null) {
             mAwAutofillClient.hideAutofillPopup();
         }
     }
 
     public void setNetworkAvailable(boolean networkUp) {
+        if (TRACE) Log.d(TAG, "setNetworkAvailable=" + networkUp);
         if (!isDestroyed()) nativeSetJsOnlineProperty(mNativeAwContents, networkUp);
     }
 
     /**
      * Inserts a {@link VisualStateCallback}.
      *
      * The {@link VisualStateCallback} will be inserted in Blink and will be invoked when the
      * contents of the DOM tree at the moment that the callback was inserted (or later) are drawn
      * into the screen. In other words, the following events need to happen before the callback is
      * invoked:
      * 1. The DOM tree is committed becoming the pending tree - see ThreadProxy::BeginMainFrame
      * 2. The pending tree is activated becoming the active tree
      * 3. A frame swap happens that draws the active tree into the screen
      *
      * @param requestId an id that will be returned from the callback invocation to allow
      * callers to match requests with callbacks.
      * @param callback the callback to be inserted
      * @throw IllegalStateException if this method is invoked after {@link #destroy()} has been
      * called.
      */
     public void insertVisualStateCallback(long requestId, VisualStateCallback callback) {
+        if (TRACE) Log.d(TAG, "insertVisualStateCallback");
         if (isDestroyed()) throw new IllegalStateException(
                 "insertVisualStateCallback cannot be called after the WebView has been destroyed");
         nativeInsertVisualStateCallback(mNativeAwContents, requestId, callback);
     }
 
     public boolean getDidAttemptLoad() {
         if (mDidAttemptLoad) return mDidAttemptLoad;
         mDidAttemptLoad = mWebContentsObserver.hasStartedAnyProvisionalLoad();
         return mDidAttemptLoad;
     }
@@ skipping 693 matching lines @@
     private native void nativeCreatePdfExporter(long nativeAwContents, AwPdfExporter awPdfExporter);
 
     private native void nativePreauthorizePermission(long nativeAwContents, String origin,
             long resources);
 
     private native void nativePostMessageToFrame(long nativeAwContents, String frameId,
             String message, String targetOrigin, int[] msgPorts);
 
     private native void nativeCreateMessageChannel(long nativeAwContents, MessagePort[] ports);
 }