Implement Crash Handle API

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.annotation.TargetApi;
 import android.app.Activity;
 import android.content.ComponentCallbacks2;
@@ skipping 341 matching lines @@
     // we are a child of a ListView. This may cause many toggles of View focus, which we suppress
     // when in this state.
     private boolean mTemporarilyDetached;
 
     private Handler mHandler;
 
     // True when this AwContents has been destroyed.
     // Do not use directly, call isDestroyed() instead.
     private boolean mIsDestroyed;
 
+    // True if this AwContents is in no operation state.
+    // Do not use directly, call isNoOperation() instead.
+    private boolean mIsNoOperation;
+
     private static String sCurrentLocales = "";
 
     private static final class AwContentsDestroyRunnable implements Runnable {
         private final long mNativeAwContents;
         // Hold onto a reference to the window (via its wrapper), so that it is not destroyed
         // until we are done here.
         private final WindowAndroidWrapper mWindowAndroid;
 
         private AwContentsDestroyRunnable(
                 long nativeAwContents, WindowAndroidWrapper windowAndroid) {
@@ skipping 201 matching lines @@
                     scrollRangeX, scrollRangeY, 0, 0, isTouchEvent);
         }
 
         @Override
         public void scrollContainerViewTo(int x, int y) {
             mInternalAccessAdapter.super_scrollTo(x, y);
         }
 
         @Override
         public void scrollNativeTo(int x, int y) {
-            if (!isDestroyed(NO_WARN)) nativeScrollTo(mNativeAwContents, x, y);
+            if (!isDestroyedOrNoOperation(NO_WARN)) nativeScrollTo(mNativeAwContents, x, y);
         }
 
         @Override
         public void smoothScroll(int targetX, int targetY, long durationMs) {
-            if (!isDestroyed(NO_WARN)) nativeSmoothScroll(
-                    mNativeAwContents, targetX, targetY, durationMs);
+            if (!isDestroyedOrNoOperation(NO_WARN)) {
+                nativeSmoothScroll(mNativeAwContents, targetX, targetY, durationMs);
+            }
         }
 
         @Override
         public int getContainerViewScrollX() {
             return mContainerView.getScrollX();
         }
 
         @Override
         public int getContainerViewScrollY() {
             return mContainerView.getScrollY();
@@ skipping 52 matching lines @@
 
     //--------------------------------------------------------------------------------------------
     private class AwComponentCallbacks implements ComponentCallbacks2 {
         @Override
         public void onTrimMemory(final int level) {
             boolean visibleRectEmpty = getGlobalVisibleRect().isEmpty();
             final boolean visible = mIsViewVisible && mIsWindowVisible && !visibleRectEmpty;
             ThreadUtils.runOnUiThreadBlocking(new Runnable() {
                 @Override
                 public void run() {
-                    if (isDestroyed(NO_WARN)) return;
+                    if (isDestroyedOrNoOperation(NO_WARN)) return;
                     if (level >= TRIM_MEMORY_MODERATE) {
                         mInitialFunctor.deleteHardwareRenderer();
                         if (mFullScreenFunctor != null) {
                             mFullScreenFunctor.deleteHardwareRenderer();
                         }
                     }
                     nativeTrimMemory(mNativeAwContents, level, visible);
                 }
             });
         }
@@ skipping 70 matching lines @@
         mAppTargetSdkVersion = mContext.getApplicationInfo().targetSdkVersion;
         mInternalAccessAdapter = internalAccessAdapter;
         mNativeDrawGLFunctorFactory = nativeDrawGLFunctorFactory;
         mInitialFunctor = new AwGLFunctor(mNativeDrawGLFunctorFactory, mContainerView);
         mCurrentFunctor = mInitialFunctor;
         mContentsClient = contentsClient;
         mContentsClient.getCallbackHelper().setCancelCallbackPoller(
                 new AwContentsClientCallbackHelper.CancelCallbackPoller() {
                     @Override
                     public boolean cancelAllCallbacks() {
-                        return AwContents.this.isDestroyed(NO_WARN);
+                        return AwContents.this.isDestroyedOrNoOperation(NO_WARN);
                     }
                 });
         mAwViewMethods = new AwViewMethodsImpl();
         mFullScreenTransitionsState = new FullScreenTransitionsState(
                 mContainerView, mInternalAccessAdapter, mAwViewMethods);
         mContentViewClient = new AwContentViewClient(contentsClient, settings, this, mContext);
         mLayoutSizer = dependencyFactory.createLayoutSizer();
         mSettings = settings;
         mLayoutSizer.setDelegate(new AwLayoutSizerDelegate());
         mWebContentsDelegate = new AwWebContentsDelegateAdapter(
@@ skipping 10 matching lines @@
             public void run() {
                 updateContentViewCoreVisibility();
             }
         };
 
         AwSettings.ZoomSupportChangeListener zoomListener =
                 new AwSettings.ZoomSupportChangeListener() {
                     @Override
                     public void onGestureZoomSupportChanged(
                             boolean supportsDoubleTapZoom, boolean supportsMultiTouchZoom) {
-                        if (isDestroyed(NO_WARN)) return;
+                        if (isDestroyedOrNoOperation(NO_WARN)) return;
                         mContentViewCore.updateDoubleTapSupport(supportsDoubleTapZoom);
                         mContentViewCore.updateMultiTouchZoomSupport(supportsMultiTouchZoom);
                     }
 
                 };
         mSettings.setZoomListener(zoomListener);
         mDefaultVideoPosterRequestHandler = new DefaultVideoPosterRequestHandler(mContentsClient);
         mSettings.setDefaultVideoPosterURL(
                 mDefaultVideoPosterRequestHandler.getDefaultVideoPosterURL());
         mScrollOffsetManager =
@@ skipping 25 matching lines @@
         return mFullScreenTransitionsState.isFullScreen();
     }
 
     /**
      * Transitions this {@link AwContents} to fullscreen mode and returns the
      * {@link View} where the contents will be drawn while in fullscreen, or null
      * if this AwContents has already been destroyed.
      */
     View enterFullScreen() {
         assert !isFullScreen();
-        if (isDestroyed(NO_WARN)) return null;
+        if (isDestroyedOrNoOperation(NO_WARN)) return null;
 
         // Detach to tear down the GL functor if this is still associated with the old
         // container view. It will be recreated during the next call to onDraw attached to
         // the new container view.
         onDetachedFromWindow();
 
         // In fullscreen mode FullScreenView owns the AwViewMethodsImpl and AwContents
         // a NullAwViewMethods.
         FullScreenView fullScreenView = new FullScreenView(mContext, mAwViewMethods, this);
         fullScreenView.setFocusable(true);
@@ skipping 10 matching lines @@
         setInternalAccessAdapter(fullScreenView.getInternalAccessAdapter());
         setContainerView(fullScreenView, mFullScreenFunctor);
 
         return fullScreenView;
     }
 
     /**
      * Called when the app has requested to exit fullscreen.
      */
     void requestExitFullscreen() {
-        if (!isDestroyed(NO_WARN)) mContentViewCore.getWebContents().exitFullscreen();
+        if (!isDestroyedOrNoOperation(NO_WARN)) mContentViewCore.getWebContents().exitFullscreen();
     }
 
     /**
      * Returns this {@link AwContents} to embedded mode, where the {@link AwContents} are drawn
      * in the WebView.
      */
     void exitFullScreen() {
-        if (!isFullScreen() || isDestroyed(NO_WARN)) {
+        if (!isFullScreen() || isDestroyedOrNoOperation(NO_WARN)) {
             // exitFullScreen() can be called without a prior call to enterFullScreen() if a
             // "misbehave" app overrides onShowCustomView but does not add the custom view to
             // the window. Exiting avoids a crash.
             return;
         }
 
         // Detach to tear down the GL functor if this is still associated with the old
         // container view. It will be recreated during the next call to onDraw attached to
         // the new container view.
         // NOTE: we cannot use mAwViewMethods here because its type is NullAwViewMethods.
@@ skipping 197 matching lines @@
             mWebContentsObserver.destroy();
         }
         mWebContentsObserver = new AwWebContentsObserver(mWebContents, this, mContentsClient);
     }
 
     /**
      * Called on the "source" AwContents that is opening the popup window to
      * provide the AwContents to host the pop up content.
      */
     public void supplyContentsForPopup(AwContents newContents) {
-        if (isDestroyed(WARN)) return;
+        if (isDestroyedOrNoOperation(WARN)) return;
         long popupNativeAwContents = nativeReleasePopupAwContents(mNativeAwContents);
         if (popupNativeAwContents == 0) {
             Log.w(TAG, "Popup WebView bind failed: no pending content.");
             if (newContents != null) newContents.destroy();
             return;
         }
         if (newContents == null) {
             nativeDestroy(popupNativeAwContents);
             return;
         }
 
         newContents.receivePopupContents(popupNativeAwContents);
     }
 
     // Recap: supplyContentsForPopup() is called on the parent window's content, this method is
     // called on the popup window's content.
     private void receivePopupContents(long popupNativeAwContents) {
-        if (isDestroyed(WARN)) return;
+        if (isDestroyedOrNoOperation(WARN)) return;
         mDeferredShouldOverrideUrlLoadingIsPendingForPopup = true;
         // Save existing view state.
         final boolean wasAttached = mIsAttachedToWindow;
         final boolean wasViewVisible = mIsViewVisible;
         final boolean wasWindowVisible = mIsWindowVisible;
         final boolean wasPaused = mIsPaused;
         final boolean wasFocused = mContainerViewFocused;
         final boolean wasWindowFocused = mWindowFocused;
 
         // Properly clean up existing mContentViewCore and mNativeAwContents.
@@ skipping 34 matching lines @@
         for (Map.Entry<String, Pair<Object, Class>> entry : javascriptInterfaces.entrySet()) {
             @SuppressWarnings("unchecked")
             Class<? extends Annotation> requiredAnnotation = entry.getValue().second;
             mContentViewCore.addPossiblyUnsafeJavascriptInterface(
                     entry.getValue().first,
                     entry.getKey(),
                     requiredAnnotation);
         }
     }
 
+    @CalledByNative
+    private void onRenderProcessGone(int childProcessID) {
+        // This is the first callback we got for render process gone, we can't destroy the WebView
+        // now because we need to get next callback onRenderProcessGoneWithDetail() to know whether
+        // render process crashed or was killed.
+        // However, we should make WebView no operation to avoid being in weird states.
+        // TODO: We might be able to combine destroyed and no operation states.
+        mIsNoOperation = true;
+    }
+
+    @CalledByNative
+    private boolean onRenderProcessGoneDetail(int childProcessID, boolean crashed) {
+        if (isDestroyed(NO_WARN)) return false;
+        return mContentsClient.onRenderProcessGone(new AwRenderProcessGoneDetail(crashed));
+    }
+
+    private boolean isNoOperation() {
+        return mIsNoOperation;
+    }
+
+    private boolean isDestroyedOrNoOperation(int warnIfDestroyed) {
+        return isDestroyed(warnIfDestroyed) || isNoOperation();
+    }
+
     /**
      * Destroys this object and deletes its native counterpart.
      */
     public void destroy() {
         if (TRACE) Log.i(TAG, "%s destroy", this);
         if (isDestroyed(NO_WARN)) return;
 
         // Remove pending messages
         mContentsClient.getCallbackHelper().removeCallbacksAndMessages();
 
         if  (mPostMessageSender != null) {
             mBrowserContext.getMessagePortService().removeObserver(mPostMessageSender);
             mPostMessageSender = null;
         }
 
         if (mIsAttachedToWindow) {
             Log.w(TAG, "WebView.destroy() called while WebView is still attached to window.");
             // Need to call detach to avoid leaks because the real detach later will be ignored.
             onDetachedFromWindow();
         }
+        mIsNoOperation = true;
         mIsDestroyed = true;
         mHandler.post(new Runnable() {
             @Override
             public void run() {
                 destroyNatives();
             }
         });
     }
 
     /**
@@ skipping 58 matching lines @@
     public NavigationController getNavigationController() {
         return mNavigationController;
     }
 
     // Can be called from any thread.
     public AwSettings getSettings() {
         return mSettings;
     }
 
     public AwPdfExporter getPdfExporter() {
-        if (isDestroyed(WARN)) return null;
+        if (isDestroyedOrNoOperation(WARN)) return null;
         if (mAwPdfExporter == null) {
             mAwPdfExporter = new AwPdfExporter(mContainerView);
             nativeCreatePdfExporter(mNativeAwContents, mAwPdfExporter);
         }
         return mAwPdfExporter;
     }
 
     public static void setAwDrawSWFunctionTable(long functionTablePointer) {
         nativeSetAwDrawSWFunctionTable(functionTablePointer);
         // Force auxiliary bitmap rendering in emulators.
@@ skipping 15 matching lines @@
     public static Activity activityFromContext(Context context) {
         return WindowAndroid.activityFromContext(context);
     }
     /**
      * Disables contents of JS-to-Java bridge objects to be inspectable using
      * Object.keys() method and "for .. in" loops. This is intended for applications
      * targeting earlier Android releases where this was not possible, and we want
      * to ensure backwards compatible behavior.
      */
     public void disableJavascriptInterfacesInspection() {
-        if (!isDestroyed(WARN)) mContentViewCore.setAllowJavascriptInterfacesInspection(false);
+        if (!isDestroyedOrNoOperation(WARN)) {
+            mContentViewCore.setAllowJavascriptInterfacesInspection(false);
+        }
     }
 
     /**
      * Intended for test code.
      * @return the number of native instances of this class.
      */
     @VisibleForTesting
     public static int getNativeInstanceCount() {
         return nativeGetNativeInstanceCount();
     }
@@ skipping 24 matching lines @@
 
     public void setLayoutParams(final ViewGroup.LayoutParams layoutParams) {
         mLayoutSizer.onLayoutParamsChange();
     }
 
     public void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
         mAwViewMethods.onMeasure(widthMeasureSpec, heightMeasureSpec);
     }
 
     public int getContentHeightCss() {
-        if (isDestroyed(WARN)) return 0;
+        if (isDestroyedOrNoOperation(WARN)) return 0;
         return (int) Math.ceil(mContentHeightDip);
     }
 
     public int getContentWidthCss() {
-        if (isDestroyed(WARN)) return 0;
+        if (isDestroyedOrNoOperation(WARN)) return 0;
         return (int) Math.ceil(mContentWidthDip);
     }
 
     public Picture capturePicture() {
         if (TRACE) Log.i(TAG, "%s capturePicture", this);
-        if (isDestroyed(WARN)) return null;
+        if (isDestroyedOrNoOperation(WARN)) return null;
         return new AwPicture(nativeCapturePicture(mNativeAwContents,
                 mScrollOffsetManager.computeHorizontalScrollRange(),
                 mScrollOffsetManager.computeVerticalScrollRange()));
     }
 
     public void clearView() {
         if (TRACE) Log.i(TAG, "%s clearView", this);
-        if (!isDestroyed(WARN)) nativeClearView(mNativeAwContents);
+        if (!isDestroyedOrNoOperation(WARN)) 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.i(TAG, "%s enableOnNewPicture=%s", this, enabled);
-        if (isDestroyed(WARN)) return;
+        if (isDestroyedOrNoOperation(WARN)) 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.i(TAG, "%s findAllAsync", this);
-        if (!isDestroyed(WARN)) nativeFindAllAsync(mNativeAwContents, searchString);
+        if (!isDestroyedOrNoOperation(WARN)) nativeFindAllAsync(mNativeAwContents, searchString);
     }
 
     public void findNext(boolean forward) {
         if (TRACE) Log.i(TAG, "%s findNext", this);
-        if (!isDestroyed(WARN)) nativeFindNext(mNativeAwContents, forward);
+        if (!isDestroyedOrNoOperation(WARN)) nativeFindNext(mNativeAwContents, forward);
     }
 
     public void clearMatches() {
         if (TRACE) Log.i(TAG, "%s clearMatches", this);
-        if (!isDestroyed(WARN)) nativeClearMatches(mNativeAwContents);
+        if (!isDestroyedOrNoOperation(WARN)) nativeClearMatches(mNativeAwContents);
     }
 
     /**
      * @return load progress of the WebContents.
      */
     public int getMostRecentProgress() {
-        if (isDestroyed(WARN)) return 0;
+        if (isDestroyedOrNoOperation(WARN)) return 0;
         // WebContentsDelegateAndroid conveniently caches the most recent notified value for us.
         return mWebContentsDelegate.getMostRecentProgress();
     }
 
     public Bitmap getFavicon() {
-        if (isDestroyed(WARN)) return null;
+        if (isDestroyedOrNoOperation(WARN)) return null;
         return mFavicon;
     }
 
     private void requestVisitedHistoryFromClient() {
         ValueCallback<String[]> callback = new ValueCallback<String[]>() {
             @Override
             public void onReceiveValue(final String[] value) {
                 if (value != null) {
                     // Replace null values with empty strings, because they can't be represented as
                     // native strings.
                     for (int i = 0; i < value.length; i++) {
                         if (value[i] == null) value[i] = "";
                     }
                 }
 
                 ThreadUtils.runOnUiThread(new Runnable() {
                     @Override
                     public void run() {
-                        if (!isDestroyed(NO_WARN)) nativeAddVisitedLinks(mNativeAwContents, value);
+                        if (!isDestroyedOrNoOperation(NO_WARN)) {
+                            nativeAddVisitedLinks(mNativeAwContents, value);
+                        }
                     }
                 });
             }
         };
         mContentsClient.getVisitedHistory(callback);
     }
 
     /**
      * WebView.loadUrl.
      */
     public void loadUrl(String url, Map<String, String> additionalHttpHeaders) {
         if (TRACE) Log.i(TAG, "%s loadUrl(extra headers)=%s", this, url);
-        if (isDestroyed(WARN)) return;
+        if (isDestroyedOrNoOperation(WARN)) return;
         // 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(new HashMap<String, String>(additionalHttpHeaders));
         }
         loadUrl(params);
     }
 
     /**
      * WebView.loadUrl.
      */
     public void loadUrl(String url) {
         if (TRACE) Log.i(TAG, "%s loadUrl=%s", this, url);
-        if (isDestroyed(WARN)) return;
+        if (isDestroyedOrNoOperation(WARN)) return;
         // Early out to match old WebView implementation
         if (url == null) {
             return;
         }
         loadUrl(url, null);
     }
 
     /**
      * WebView.postUrl.
      */
     public void postUrl(String url, byte[] postData) {
         if (TRACE) Log.i(TAG, "%s postUrl=%s", this, url);
-        if (isDestroyed(WARN)) return;
+        if (isDestroyedOrNoOperation(WARN)) return;
         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 12 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.i(TAG, "%s loadData", this);
-        if (isDestroyed(WARN)) return;
+        if (isDestroyedOrNoOperation(WARN)) return;
         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.i(TAG, "%s loadDataWithBaseURL=%s", this, baseUrl);
-        if (isDestroyed(WARN)) return;
+        if (isDestroyedOrNoOperation(WARN)) return;
 
         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".
@@ skipping 85 matching lines @@
             mContentsClient.getCallbackHelper().postOnPageStarted(params.getBaseUrl());
         }
     }
 
     /**
      * Get the URL of the current page.
      *
      * @return The URL of the current page or null if it's empty.
      */
     public String getUrl() {
-        if (isDestroyed(WARN)) return null;
+        if (isDestroyedOrNoOperation(WARN)) return null;
         String url =  mWebContents.getUrl();
         if (url == null || url.trim().isEmpty()) return null;
         return url;
     }
 
     /**
      * Gets the last committed URL. It represents the current page that is
      * displayed in WebContents. It represents the current security context.
      *
      * @return The URL of the current page or null if it's empty.
      */
     public String getLastCommittedUrl() {
-        if (isDestroyed(NO_WARN)) return null;
+        if (isDestroyedOrNoOperation(NO_WARN)) return null;
         String url = mWebContents.getLastCommittedUrl();
         if (url == null || url.trim().isEmpty()) return null;
         return url;
     }
 
     public void requestFocus() {
         mAwViewMethods.requestFocus();
     }
 
     public void setBackgroundColor(int color) {
         mBaseBackgroundColor = color;
-        if (!isDestroyed(WARN)) nativeSetBackgroundColor(mNativeAwContents, color);
+        if (!isDestroyedOrNoOperation(WARN)) nativeSetBackgroundColor(mNativeAwContents, color);
     }
 
     /**
      * @see android.view.View#setLayerType()
      */
     public void setLayerType(int layerType, Paint paint) {
         mAwViewMethods.setLayerType(layerType, paint);
     }
 
     int getEffectiveBackgroundColor() {
         // Do not ask the ContentViewCore for the background color, as it will always
         // report white prior to initial navigation or post destruction,  whereas we want
         // to use the client supplied base value in those cases.
-        if (isDestroyed(NO_WARN) || !mContentsClient.isCachedRendererBackgroundColorValid()) {
+        if (isDestroyedOrNoOperation(NO_WARN)
+                || !mContentsClient.isCachedRendererBackgroundColorValid()) {
             return mBaseBackgroundColor;
         }
         return mContentsClient.getCachedRendererBackgroundColor();
     }
 
     public boolean isMultiTouchZoomSupported() {
         return mSettings.supportsMultiTouchZoom();
     }
 
     public View getZoomControlsForTest() {
@@ skipping 75 matching lines @@
      */
     public void onContainerViewOverScrolled(int scrollX, int scrollY, boolean clampedX,
             boolean clampedY) {
         mAwViewMethods.onContainerViewOverScrolled(scrollX, scrollY, clampedX, clampedY);
     }
 
     /**
      * @see android.webkit.WebView#requestChildRectangleOnScreen(View, Rect, boolean)
      */
     public boolean requestChildRectangleOnScreen(View child, Rect rect, boolean immediate) {
-        if (isDestroyed(WARN)) return false;
+        if (isDestroyedOrNoOperation(WARN)) return false;
         return mScrollOffsetManager.requestChildRectangleOnScreen(
                 child.getLeft() - child.getScrollX(), child.getTop() - child.getScrollY(),
                 rect, immediate);
     }
 
     /**
      * @see View#computeHorizontalScrollRange()
      */
     public int computeHorizontalScrollRange() {
         return mAwViewMethods.computeHorizontalScrollRange();
@@ skipping 32 matching lines @@
      */
     public void computeScroll() {
         mAwViewMethods.computeScroll();
     }
 
     /**
      * @see android.webkit.WebView#stopLoading()
      */
     public void stopLoading() {
         if (TRACE) Log.i(TAG, "%s stopLoading", this);
-        if (!isDestroyed(WARN)) mWebContents.stop();
+        if (!isDestroyedOrNoOperation(WARN)) mWebContents.stop();
     }
 
     /**
      * @see android.webkit.WebView#reload()
      */
     public void reload() {
         if (TRACE) Log.i(TAG, "%s reload", this);
-        if (!isDestroyed(WARN)) mNavigationController.reload(true);
+        if (!isDestroyedOrNoOperation(WARN)) mNavigationController.reload(true);
     }
 
     /**
      * @see android.webkit.WebView#canGoBack()
      */
     public boolean canGoBack() {
-        return isDestroyed(WARN) ? false : mNavigationController.canGoBack();
+        return isDestroyedOrNoOperation(WARN) ? false : mNavigationController.canGoBack();
     }
 
     /**
      * @see android.webkit.WebView#goBack()
      */
     public void goBack() {
         if (TRACE) Log.i(TAG, "%s goBack", this);
-        if (!isDestroyed(WARN)) mNavigationController.goBack();
+        if (!isDestroyedOrNoOperation(WARN)) mNavigationController.goBack();
     }
 
     /**
      * @see android.webkit.WebView#canGoForward()
      */
     public boolean canGoForward() {
-        return isDestroyed(WARN) ? false : mNavigationController.canGoForward();
+        return isDestroyedOrNoOperation(WARN) ? false : mNavigationController.canGoForward();
     }
 
     /**
      * @see android.webkit.WebView#goForward()
      */
     public void goForward() {
         if (TRACE) Log.i(TAG, "%s goForward", this);
-        if (!isDestroyed(WARN)) mNavigationController.goForward();
+        if (!isDestroyedOrNoOperation(WARN)) mNavigationController.goForward();
     }
 
     /**
      * @see android.webkit.WebView#canGoBackOrForward(int)
      */
     public boolean canGoBackOrForward(int steps) {
-        return isDestroyed(WARN) ? false : mNavigationController.canGoToOffset(steps);
+        return isDestroyedOrNoOperation(WARN) ? false : mNavigationController.canGoToOffset(steps);
     }
 
     /**
      * @see android.webkit.WebView#goBackOrForward(int)
      */
     public void goBackOrForward(int steps) {
         if (TRACE) Log.i(TAG, "%s goBackOrForwad=%d", this, steps);
-        if (!isDestroyed(WARN)) mNavigationController.goToOffset(steps);
+        if (!isDestroyedOrNoOperation(WARN)) mNavigationController.goToOffset(steps);
     }
 
     /**
      * @see android.webkit.WebView#pauseTimers()
      */
     public void pauseTimers() {
         if (TRACE) Log.i(TAG, "%s pauseTimers", this);
-        if (!isDestroyed(WARN)) ContentViewStatics.setWebKitSharedTimersSuspended(true);
+        if (!isDestroyedOrNoOperation(WARN)) {
+            ContentViewStatics.setWebKitSharedTimersSuspended(true);
+        }
     }
 
     /**
      * @see android.webkit.WebView#resumeTimers()
      */
     public void resumeTimers() {
         if (TRACE) Log.i(TAG, "%s resumeTimers", this);
-        if (!isDestroyed(WARN)) ContentViewStatics.setWebKitSharedTimersSuspended(false);
+        if (!isDestroyedOrNoOperation(WARN)) {
+            ContentViewStatics.setWebKitSharedTimersSuspended(false);
+        }
     }
 
     /**
      * @see android.webkit.WebView#onPause()
      */
     public void onPause() {
         if (TRACE) Log.i(TAG, "%s onPause", this);
-        if (mIsPaused || isDestroyed(NO_WARN)) return;
+        if (mIsPaused || isDestroyedOrNoOperation(NO_WARN)) return;
         mIsPaused = true;
         nativeSetIsPaused(mNativeAwContents, mIsPaused);
 
         // Geolocation is paused/resumed via the page visibility mechanism.
         updateContentViewCoreVisibility();
     }
 
     /**
      * @see android.webkit.WebView#onResume()
      */
     public void onResume() {
         if (TRACE) Log.i(TAG, "%s onResume", this);
-        if (!mIsPaused || isDestroyed(NO_WARN)) return;
+        if (!mIsPaused || isDestroyedOrNoOperation(NO_WARN)) return;
         mIsPaused = false;
         nativeSetIsPaused(mNativeAwContents, mIsPaused);
         updateContentViewCoreVisibility();
     }
 
     /**
      * @see android.webkit.WebView#isPaused()
      */
     public boolean isPaused() {
-        return isDestroyed(WARN) ? false : mIsPaused;
+        return isDestroyedOrNoOperation(WARN) ? false : mIsPaused;
     }
 
     /**
      * @see android.webkit.WebView#onCreateInputConnection(EditorInfo)
      */
     public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
         return mAwViewMethods.onCreateInputConnection(outAttrs);
     }
 
     /**
@@ skipping 18 matching lines @@
     }
 
     /**
      * 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.i(TAG, "%s clearCache", this);
-        if (!isDestroyed(WARN)) nativeClearCache(mNativeAwContents, includeDiskFiles);
+        if (!isDestroyedOrNoOperation(WARN)) nativeClearCache(mNativeAwContents, includeDiskFiles);
     }
 
     public void documentHasImages(Message message) {
-        if (!isDestroyed(WARN)) nativeDocumentHasImages(mNativeAwContents, message);
+        if (!isDestroyedOrNoOperation(WARN)) nativeDocumentHasImages(mNativeAwContents, message);
     }
 
     public void saveWebArchive(
             final String basename, boolean autoname, final ValueCallback<String> callback) {
         if (TRACE) Log.i(TAG, "%s saveWebArchive=%s", this, 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);
             }
 
             @Override
             protected void onPostExecute(String result) {
                 saveWebArchiveInternal(result, callback);
             }
         }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
     }
 
     public String getOriginalUrl() {
-        if (isDestroyed(WARN)) return null;
+        if (isDestroyedOrNoOperation(WARN)) return null;
         NavigationHistory history = mNavigationController.getNavigationHistory();
         int currentIndex = history.getCurrentEntryIndex();
         if (currentIndex >= 0 && currentIndex < history.getEntryCount()) {
             return history.getEntryAtIndex(currentIndex).getOriginalUrl();
         }
         return null;
     }
 
     /**
      * @see ContentViewCore#getNavigationHistory()
      */
     public NavigationHistory getNavigationHistory() {
-        return isDestroyed(WARN) ? null : mNavigationController.getNavigationHistory();
+        return isDestroyedOrNoOperation(WARN) ? null : mNavigationController.getNavigationHistory();
     }
 
     /**
      * @see android.webkit.WebView#getTitle()
      */
     public String getTitle() {
-        return isDestroyed(WARN) ? null : mWebContents.getTitle();
+        return isDestroyedOrNoOperation(WARN) ? null : mWebContents.getTitle();
     }
 
     /**
      * @see android.webkit.WebView#clearHistory()
      */
     public void clearHistory() {
         if (TRACE) Log.i(TAG, "%s clearHistory", this);
-        if (!isDestroyed(WARN)) mNavigationController.clearHistory();
+        if (!isDestroyedOrNoOperation(WARN)) mNavigationController.clearHistory();
     }
 
     /**
      * @see android.webkit.WebView#getCertificate()
      */
     public SslCertificate getCertificate() {
-        return isDestroyed(WARN) ? null
+        return isDestroyedOrNoOperation(WARN) ? null
                 : SslUtil.getCertificateFromDerBytes(nativeGetCertificate(mNativeAwContents));
     }
 
     /**
      * @see android.webkit.WebView#clearSslPreferences()
      */
     public void clearSslPreferences() {
         if (TRACE) Log.i(TAG, "%s clearSslPreferences", this);
-        if (!isDestroyed(WARN)) mNavigationController.clearSslPreferences();
+        if (!isDestroyedOrNoOperation(WARN)) 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.i(TAG, "%s getLastHitTestResult", this);
-        if (isDestroyed(WARN)) return null;
+        if (isDestroyedOrNoOperation(WARN)) return null;
         nativeUpdateLastHitTestData(mNativeAwContents);
         return mPossiblyStaleHitTestData;
     }
 
     /**
      * @see android.webkit.WebView#requestFocusNodeHref()
      */
     public void requestFocusNodeHref(Message msg) {
         if (TRACE) Log.i(TAG, "%s requestFocusNodeHref", this);
-        if (msg == null || isDestroyed(WARN)) return;
+        if (msg == null || isDestroyedOrNoOperation(WARN)) 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.i(TAG, "%s requestImageRef", this);
-        if (msg == null || isDestroyed(WARN)) return;
+        if (msg == null || isDestroyedOrNoOperation(WARN)) 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() {
-        if (isDestroyed(WARN)) return 1;
+        if (isDestroyedOrNoOperation(WARN)) return 1;
         return mPageScaleFactor * mContentViewCore.getDeviceScaleFactor();
     }
 
     /**
      * @see android.webkit.WebView#flingScroll(int, int)
      */
     public void flingScroll(int velocityX, int velocityY) {
         if (TRACE) Log.i(TAG, "%s flingScroll", this);
-        if (isDestroyed(WARN)) return;
+        if (isDestroyedOrNoOperation(WARN)) return;
         mContentViewCore.flingViewport(SystemClock.uptimeMillis(), -velocityX, -velocityY);
     }
 
     /**
      * @see android.webkit.WebView#pageUp(boolean)
      */
     public boolean pageUp(boolean top) {
         if (TRACE) Log.i(TAG, "%s pageUp", this);
-        if (isDestroyed(WARN)) return false;
+        if (isDestroyedOrNoOperation(WARN)) return false;
         return mScrollOffsetManager.pageUp(top);
     }
 
     /**
      * @see android.webkit.WebView#pageDown(boolean)
      */
     public boolean pageDown(boolean bottom) {
         if (TRACE) Log.i(TAG, "%s pageDown", this);
-        if (isDestroyed(WARN)) return false;
+        if (isDestroyedOrNoOperation(WARN)) return false;
         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() {
-        if (isDestroyed(WARN)) return false;
+        if (isDestroyedOrNoOperation(WARN)) return false;
         final float zoomInExtent = mMaxPageScaleFactor - mPageScaleFactor;
         return zoomInExtent > ZOOM_CONTROLS_EPSILON;
     }
 
     /**
      * @see android.webkit.WebView#canZoomOut()
      */
     // This method uses the term 'zoom' for legacy reasons, but relates
     // to what chrome calls the 'page scale factor'.
     public boolean canZoomOut() {
-        if (isDestroyed(WARN)) return false;
+        if (isDestroyedOrNoOperation(WARN)) return false;
         final float zoomOutExtent = mPageScaleFactor - mMinPageScaleFactor;
         return zoomOutExtent > ZOOM_CONTROLS_EPSILON;
     }
 
     /**
      * @see android.webkit.WebView#zoomIn()
      */
     // This method uses the term 'zoom' for legacy reasons, but relates
     // to what chrome calls the 'page scale factor'.
     public boolean zoomIn() {
@@ skipping 16 matching lines @@
         zoomBy(0.8f);
         return true;
     }
 
     /**
      * @see android.webkit.WebView#zoomBy()
      */
     // This method uses the term 'zoom' for legacy reasons, but relates
     // to what chrome calls the 'page scale factor'.
     public void zoomBy(float delta) {
-        if (isDestroyed(WARN)) return;
+        if (isDestroyedOrNoOperation(WARN)) return;
         if (delta < 0.01f || delta > 100.0f) {
             throw new IllegalStateException("zoom delta value outside [0.01, 100] range.");
         }
         nativeZoomBy(mNativeAwContents, delta);
     }
 
     /**
      * @see android.webkit.WebView#invokeZoomPicker()
      */
     public void invokeZoomPicker() {
         if (TRACE) Log.i(TAG, "%s invokeZoomPicker", this);
-        if (!isDestroyed(WARN)) mZoomControls.invokeZoomPicker();
+        if (!isDestroyedOrNoOperation(WARN)) mZoomControls.invokeZoomPicker();
     }
 
     /**
      * @see android.webkit.WebView#preauthorizePermission(Uri, long)
      */
     public void preauthorizePermission(Uri origin, long resources) {
-        if (isDestroyed(NO_WARN)) return;
+        if (isDestroyedOrNoOperation(NO_WARN)) return;
         nativePreauthorizePermission(mNativeAwContents, origin.toString(), resources);
     }
 
     /**
      * @see ContentViewCore.evaluateJavaScript(String, JavaScriptCallback)
      */
     public void evaluateJavaScript(String script, final ValueCallback<String> callback) {
         if (TRACE) Log.i(TAG, "%s evaluateJavascript=%s", this, script);
-        if (isDestroyed(WARN)) return;
+        if (isDestroyedOrNoOperation(WARN)) return;
         JavaScriptCallback jsCallback = null;
         if (callback != null) {
             jsCallback = new JavaScriptCallback() {
                 @Override
                 public void handleJavaScriptResult(String jsonResult) {
                     callback.onReceiveValue(jsonResult);
                 }
             };
         }
 
         mWebContents.evaluateJavaScript(script, jsCallback);
     }
 
     public void evaluateJavaScriptForTests(String script, final ValueCallback<String> callback) {
         if (TRACE) Log.i(TAG, "%s evaluateJavascriptForTests=%s", this, script);
-        if (isDestroyed(NO_WARN)) return;
+        if (isDestroyedOrNoOperation(NO_WARN)) return;
         JavaScriptCallback jsCallback = null;
         if (callback != null) {
             jsCallback = new JavaScriptCallback() {
                 @Override
                 public void handleJavaScriptResult(String jsonResult) {
                     callback.onReceiveValue(jsonResult);
                 }
             };
         }
 
         mWebContents.evaluateJavaScriptForTests(script, jsCallback);
     }
 
     /**
      * Post a message to a frame.
      *
      * @param frameName The name of the frame. If the name is null the message is posted
      *                  to the main frame.
      * @param message   The message
      * @param targetOrigin  The target origin
      * @param sentPorts The sent message ports, if any. Pass null if there is no
      *                  message ports to pass.
      */
     public void postMessageToFrame(
             String frameName, String message, String targetOrigin, MessagePort[] sentPorts) {
-        if (isDestroyed(WARN)) return;
+        if (isDestroyedOrNoOperation(WARN)) return;
         if (mPostMessageSender == null) {
             AppWebMessagePortService service = mBrowserContext.getMessagePortService();
             mPostMessageSender = new PostMessageSender(this, service);
             service.addObserver(mPostMessageSender);
         }
         mPostMessageSender.postMessage(frameName, message, targetOrigin,
                 (AppWebMessagePort[]) sentPorts);
     }
 
     // Implements PostMessageSender.PostMessageSenderDelegate interface method.
     @Override
     public boolean isPostMessageSenderReady() {
         return true;
     }
 
     // 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.i(TAG, "%s postMessageToWeb. TargetOrigin=%s", this, targetOrigin);
-        if (isDestroyed(NO_WARN)) return;
+        if (isDestroyedOrNoOperation(NO_WARN)) return;
         nativePostMessageToFrame(mNativeAwContents, frameName, message, targetOrigin,
                 sentPortIds);
     }
 
     /**
      * Creates a message channel and returns the ports for each end of the channel.
      */
     public AppWebMessagePort[] createMessageChannel() {
         if (TRACE) Log.i(TAG, "%s createMessageChannel", this);
-        if (isDestroyed(WARN)) return null;
+        if (isDestroyedOrNoOperation(WARN)) return null;
         AppWebMessagePort[] ports = mBrowserContext.getMessagePortService().createMessageChannel();
         nativeCreateMessageChannel(mNativeAwContents, ports);
         return ports;
     }
 
     public boolean hasAccessedInitialDocument() {
-        if (isDestroyed(NO_WARN)) return false;
+        if (isDestroyedOrNoOperation(NO_WARN)) return false;
         return mWebContents.hasAccessedInitialDocument();
     }
 
     @TargetApi(Build.VERSION_CODES.M)
     public void onProvideVirtualStructure(ViewStructure structure) {
-        if (isDestroyed(WARN)) return;
+        if (isDestroyedOrNoOperation(WARN)) return;
         if (!mWebContentsObserver.didEverCommitNavigation()) {
             // TODO(sgurun) write a test case for this condition crbug/605251
             structure.setChildCount(0);
             return;
         }
         // for webview, the platform already calculates the scroll (as it is a view) in
         // ViewStructure tree. Do not offset for it in the snapshop x,y position calculations.
         mContentViewCore.onProvideVirtualStructure(structure, true);
     }
 
@@ skipping 53 matching lines @@
      * @see android.view.View#onHoverEvent()
      */
     public boolean onHoverEvent(MotionEvent event) {
         return mAwViewMethods.onHoverEvent(event);
     }
 
     /**
      * @see android.view.View#onGenericMotionEvent()
      */
     public boolean onGenericMotionEvent(MotionEvent event) {
-        return isDestroyed(NO_WARN) ? false : mContentViewCore.onGenericMotionEvent(event);
+        return isDestroyedOrNoOperation(NO_WARN) ? false :
+            mContentViewCore.onGenericMotionEvent(event);
     }
 
     /**
      * @see android.view.View#onConfigurationChanged()
      */
     public void onConfigurationChanged(Configuration newConfig) {
         mAwViewMethods.onConfigurationChanged(newConfig);
     }
 
     /**
@@ skipping 62 matching lines @@
 
     /**
      * @see android.view.View#onWindowVisibilityChanged()
      */
     public void onWindowVisibilityChanged(int visibility) {
         mAwViewMethods.onWindowVisibilityChanged(visibility);
     }
 
     private void setViewVisibilityInternal(boolean visible) {
         mIsViewVisible = visible;
-        if (!isDestroyed(NO_WARN)) nativeSetViewVisibility(mNativeAwContents, mIsViewVisible);
+        if (!isDestroyedOrNoOperation(NO_WARN)) {
+            nativeSetViewVisibility(mNativeAwContents, mIsViewVisible);
+        }
         updateContentViewCoreVisibility();
     }
 
     private void setWindowVisibilityInternal(boolean visible) {
         mInvalidateRootViewOnNextDraw |= Build.VERSION.SDK_INT <= Build.VERSION_CODES.LOLLIPOP
                 && visible && !mIsWindowVisible;
         mIsWindowVisible = visible;
-        if (!isDestroyed(NO_WARN)) nativeSetWindowVisibility(mNativeAwContents, mIsWindowVisible);
+        if (!isDestroyedOrNoOperation(NO_WARN)) {
+            nativeSetWindowVisibility(mNativeAwContents, mIsWindowVisible);
+        }
         postUpdateContentViewCoreVisibility();
     }
 
     private void postUpdateContentViewCoreVisibility() {
         if (mIsUpdateVisibilityTaskPending) return;
         // When WebView is attached to a visible window, WebView will be
         // attached to a window whose visibility is initially invisible, then
         // the window visibility will be updated to true. This means CVC
         // visibility will be set to false then true immediately, in the same
         // function call of View#dispatchAttachedToWindow.  DetachedFromWindow
         // is a similar case, where window visibility changes before AwContents
         // is detached from window.
         //
         // To prevent this flip of CVC visibility, post the task to update CVC
         // visibility during attach, detach and window visibility change.
         mIsUpdateVisibilityTaskPending = true;
         mHandler.post(mUpdateVisibilityRunnable);
     }
 
     private void updateContentViewCoreVisibility() {
         mIsUpdateVisibilityTaskPending = false;
-        if (isDestroyed(NO_WARN)) return;
+        if (isDestroyedOrNoOperation(NO_WARN)) return;
         boolean contentViewCoreVisible = nativeIsVisible(mNativeAwContents);
 
         if (contentViewCoreVisible && !mIsContentViewCoreVisible) {
             mContentViewCore.onShow();
         } else if (!contentViewCoreVisible && mIsContentViewCoreVisible) {
             mContentViewCore.onHide();
         }
         mIsContentViewCoreVisible = contentViewCoreVisible;
     }
 
     /**
      * Returns true if the page is visible according to DOM page visibility API.
      * See http://www.w3.org/TR/page-visibility/
      * This method is only called by tests and will return the supposed CVC
      * visibility without waiting a pending mUpdateVisibilityRunnable to run.
      */
     @VisibleForTesting
     public boolean isPageVisible() {
-        if (isDestroyed(NO_WARN)) return mIsContentViewCoreVisible;
+        if (isDestroyedOrNoOperation(NO_WARN)) return mIsContentViewCoreVisible;
         return nativeIsVisible(mNativeAwContents);
     }
 
     /**
      * 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.i(TAG, "%s saveState", this);
-        if (isDestroyed(WARN) || outState == null) return false;
+        if (isDestroyedOrNoOperation(WARN) || 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.i(TAG, "%s restoreState", this);
-        if (isDestroyed(WARN) || inState == null) return false;
+        if (isDestroyedOrNoOperation(WARN) || 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.i(TAG, "%s addJavascriptInterface=%s", this, name);
-        if (isDestroyed(WARN)) return;
+        if (isDestroyedOrNoOperation(WARN)) 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.i(TAG, "%s removeJavascriptInterface=%s", this, interfaceName);
-        if (!isDestroyed(WARN)) mContentViewCore.removeJavascriptInterface(interfaceName);
+        if (!isDestroyedOrNoOperation(WARN)) {
+            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() {
-        return isDestroyed(WARN) ? null : mContentViewCore.getAccessibilityNodeProvider();
+        return isDestroyedOrNoOperation(WARN) ? null
+                : mContentViewCore.getAccessibilityNodeProvider();
     }
 
     /**
      * @see android.webkit.WebView#onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo)
      */
     public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) {
         // TODO(boliu): remove this method.
     }
 
     /**
      * @see android.webkit.WebView#onInitializeAccessibilityEvent(AccessibilityEvent)
      */
     public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
      // TODO(boliu): remove this method.
     }
 
     public boolean supportsAccessibilityAction(int action) {
-        return isDestroyed(WARN) ? false : mContentViewCore.supportsAccessibilityAction(action);
+        return isDestroyedOrNoOperation(WARN) ? false
+                : mContentViewCore.supportsAccessibilityAction(action);
     }
 
     /**
      * @see android.webkit.WebView#performAccessibilityAction(int, Bundle)
      */
     public boolean performAccessibilityAction(int action, Bundle arguments) {
-        return isDestroyed(WARN) ? false
+        return isDestroyedOrNoOperation(WARN) ? false
                 : mContentViewCore.performAccessibilityAction(action, arguments);
     }
 
     /**
      * @see android.webkit.WebView#clearFormData()
      */
     public void hideAutofillPopup() {
         if (TRACE) Log.i(TAG, "%s hideAutofillPopup", this);
         if (mAwAutofillClient != null) {
             mAwAutofillClient.hideAutofillPopup();
         }
     }
 
     public void setNetworkAvailable(boolean networkUp) {
         if (TRACE) Log.i(TAG, "%s setNetworkAvailable=%s", this, networkUp);
-        if (!isDestroyed(WARN)) {
+        if (!isDestroyedOrNoOperation(WARN)) {
             // For backward compatibility when an app uses this API disable the
             // Network Information API to prevent inconsistencies,
             // see crbug.com/520088.
             NetworkChangeNotifier.setAutoDetectConnectivityState(false);
             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.i(TAG, "%s insertVisualStateCallback", this);
         if (isDestroyed(NO_WARN)) throw new IllegalStateException(
                 "insertVisualStateCallback cannot be called after the WebView has been destroyed");
         nativeInsertVisualStateCallback(mNativeAwContents, requestId, callback);

[Tobias Sargeant, 2017/01/19 17:28:03]

You need to change this to fire the callback immediately if mIsNoOperation.

[michaelbai, 2017/01/19 17:33:31]

So, nativeInsertVisualStateCallback doesn't fire callback immediately? The
method's behavior does't change no matter WebView is no operation or not, this
is what we expected, isn't it?

     }
 
     public boolean isPopupWindow() {
         return mIsPopupWindow;
     }
 
     //--------------------------------------------------------------------------------------------
     //  Methods called from native via JNI
     //--------------------------------------------------------------------------------------------
 
@@ skipping 32 matching lines @@
     @CalledByNative
     private void onReceivedHttpAuthRequest(AwHttpAuthHandler handler, String host, String realm) {
         mContentsClient.onReceivedHttpAuthRequest(handler, host, realm);
     }
 
     public AwGeolocationPermissions getGeolocationPermissions() {
         return mBrowserContext.getGeolocationPermissions();
     }
 
     public void invokeGeolocationCallback(boolean value, String requestingFrame) {
-        if (isDestroyed(NO_WARN)) return;
+        if (isDestroyedOrNoOperation(NO_WARN)) return;
         nativeInvokeGeolocationCallback(mNativeAwContents, value, requestingFrame);
     }
 
     @CalledByNative
     private void onGeolocationPermissionsShowPrompt(String origin) {
-        if (isDestroyed(NO_WARN)) return;
+        if (isDestroyedOrNoOperation(NO_WARN)) return;
         AwGeolocationPermissions permissions = mBrowserContext.getGeolocationPermissions();
         // Reject if geoloaction is disabled, or the origin has a retained deny
         if (!mSettings.getGeolocationEnabled()) {
             nativeInvokeGeolocationCallback(mNativeAwContents, false, origin);
             return;
         }
         // Allow if the origin has a retained allow
         if (permissions.hasOrigin(origin)) {
             nativeInvokeGeolocationCallback(mNativeAwContents, permissions.isOriginAllowed(origin),
                     origin);
@@ skipping 152 matching lines @@
         if (mPageScaleFactor != pageScaleFactor) {
             float oldPageScaleFactor = mPageScaleFactor;
             mPageScaleFactor = pageScaleFactor;
             float dipScale = mContentViewCore.getDeviceScaleFactor();
             mContentsClient.getCallbackHelper().postOnScaleChangedScaled(
                     oldPageScaleFactor * dipScale, mPageScaleFactor * dipScale);
         }
     }
 
     private void saveWebArchiveInternal(String path, final ValueCallback<String> callback) {
-        if (path == null || isDestroyed(WARN)) {
+        if (path == null || isDestroyedOrNoOperation(WARN)) {
             ThreadUtils.runOnUiThread(new Runnable() {
                 @Override
                 public void run() {
                     callback.onReceiveValue(null);
                 }
             });
         } else {
             nativeGenerateMHTML(mNativeAwContents, path, callback);
         }
     }
@@ skipping 27 matching lines @@
             testName = baseName + name + "-" + i + WEB_ARCHIVE_EXTENSION;
             if (!new File(testName).exists()) return testName;
         }
 
         Log.e(TAG, "Unable to auto generate archive name for path: %s", baseName);
         return null;
     }
 
     @Override
     public void extractSmartClipData(int x, int y, int width, int height) {
-        if (!isDestroyed(WARN)) mContentViewCore.extractSmartClipData(x, y, width, height);
+        if (!isDestroyedOrNoOperation(WARN)) {
+            mContentViewCore.extractSmartClipData(x, y, width, height);
+        }
     }
 
     @Override
     public void setSmartClipResultHandler(final Handler resultHandler) {
-        if (isDestroyed(WARN)) return;
+        if (isDestroyedOrNoOperation(WARN)) return;
 
         if (resultHandler == null) {
             mContentViewCore.setSmartClipDataListener(null);
             return;
         }
         mContentViewCore.setSmartClipDataListener(new ContentViewCore.SmartClipDataListener() {
             @Override
             public void onSmartClipDataExtracted(String text, String html, Rect clipRect) {
                 Bundle bundle = new Bundle();
                 bundle.putString("url", mContentViewCore.getWebContents().getVisibleUrl());
                 bundle.putString("title", mContentViewCore.getWebContents().getTitle());
                 bundle.putParcelable("rect", clipRect);
                 bundle.putString("text", text);
                 bundle.putString("html", html);
                 try {
                     Message msg = Message.obtain(resultHandler, 0);
                     msg.setData(bundle);
                     msg.sendToTarget();
                 } catch (Exception e) {
                     Log.e(TAG, "Error calling handler for smart clip data: ", e);
                 }
             }
         });
     }
 
     protected void insertVisualStateCallbackIfNotDestroyed(
             long requestId, VisualStateCallback callback) {
         if (TRACE) Log.i(TAG, "%s insertVisualStateCallbackIfNotDestroyed", this);
-        if (isDestroyed(NO_WARN)) return;
+        if (isDestroyedOrNoOperation(NO_WARN)) return;
         nativeInsertVisualStateCallback(mNativeAwContents, requestId, callback);
     }
 
     // --------------------------------------------------------------------------------------------
     // This is the AwViewMethods implementation that does real work. The AwViewMethodsImpl is
     // hooked up to the WebView in embedded mode and to the FullScreenView in fullscreen mode,
     // but not to both at the same time.
     private class AwViewMethodsImpl implements AwViewMethods {
         private int mLayerType = View.LAYER_TYPE_NONE;
         private ComponentCallbacks2 mComponentCallbacks;
 
         // Only valid within software onDraw().
         private final Rect mClipBoundsTemporary = new Rect();
 
         @Override
         public void onDraw(Canvas canvas) {
-            if (isDestroyed(NO_WARN)) {
+            if (isDestroyedOrNoOperation(NO_WARN)) {
                 TraceEvent.instant("EarlyOut_destroyed");
                 canvas.drawColor(getEffectiveBackgroundColor());
                 return;
             }
 
             // For hardware draws, the clip at onDraw time could be different
             // from the clip during DrawGL.
             if (!canvas.isHardwareAccelerated() && !canvas.getClipBounds(mClipBoundsTemporary)) {
                 TraceEvent.instant("EarlyOut_software_empty_clip");
                 return;
@@ skipping 30 matching lines @@
             }
         }
 
         @Override
         public void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
             mLayoutSizer.onMeasure(widthMeasureSpec, heightMeasureSpec);
         }
 
         @Override
         public void requestFocus() {
-            if (isDestroyed(NO_WARN)) return;
+            if (isDestroyedOrNoOperation(NO_WARN)) return;
             if (!mContainerView.isInTouchMode() && mSettings.shouldFocusFirstNode()) {
                 nativeFocusFirstNode(mNativeAwContents);
             }
         }
 
         @Override
         public void setLayerType(int layerType, Paint paint) {
             mLayerType = layerType;
             updateHardwareAcceleratedFeaturesToggle();
         }
 
         private void updateHardwareAcceleratedFeaturesToggle() {
             mSettings.setEnableSupportedHardwareAcceleratedFeatures(
                     mIsAttachedToWindow && mContainerView.isHardwareAccelerated()
                             && (mLayerType == View.LAYER_TYPE_NONE
                                     || mLayerType == View.LAYER_TYPE_HARDWARE));
         }
 
         @Override
         public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
-            return isDestroyed(NO_WARN) ? null : mContentViewCore.onCreateInputConnection(outAttrs);
+            return isDestroyedOrNoOperation(NO_WARN) ? null
+                    : mContentViewCore.onCreateInputConnection(outAttrs);
         }
 
         @Override
         public boolean onDragEvent(DragEvent event) {
             return mContentViewCore.onDragEvent(event);
         }
 
         @Override
         public boolean onKeyUp(int keyCode, KeyEvent event) {
-            return isDestroyed(NO_WARN) ? false : mContentViewCore.onKeyUp(keyCode, event);
+            return isDestroyedOrNoOperation(NO_WARN) ? false
+                    : mContentViewCore.onKeyUp(keyCode, event);
         }
 
         @Override
         public boolean dispatchKeyEvent(KeyEvent event) {
-            if (isDestroyed(NO_WARN)) return false;
+            if (isDestroyedOrNoOperation(NO_WARN)) return false;
             if (isDpadEvent(event)) {
                 mSettings.setSpatialNavigationEnabled(true);
             }
             return mContentViewCore.dispatchKeyEvent(event);
         }
 
         private boolean isDpadEvent(KeyEvent event) {
             if (event.getAction() == KeyEvent.ACTION_DOWN) {
                 switch (event.getKeyCode()) {
                     case KeyEvent.KEYCODE_DPAD_CENTER:
                     case KeyEvent.KEYCODE_DPAD_DOWN:
                     case KeyEvent.KEYCODE_DPAD_UP:
                     case KeyEvent.KEYCODE_DPAD_LEFT:
                     case KeyEvent.KEYCODE_DPAD_RIGHT:
                         return true;
                 }
             }
             return false;
         }
 
         @Override
         public boolean onTouchEvent(MotionEvent event) {
-            if (isDestroyed(NO_WARN)) return false;
+            if (isDestroyedOrNoOperation(NO_WARN)) return false;
             if (event.getActionMasked() == MotionEvent.ACTION_DOWN) {
                 mSettings.setSpatialNavigationEnabled(false);
             }
 
             mScrollOffsetManager.setProcessingTouchEvent(true);
             boolean rv = mContentViewCore.onTouchEvent(event);
             mScrollOffsetManager.setProcessingTouchEvent(false);
 
             if (event.getActionMasked() == MotionEvent.ACTION_DOWN) {
                 // Note this will trigger IPC back to browser even if nothing is
@@ skipping 12 matching lines @@
                     mOverScrollGlow.setShouldPull(false);
                     mOverScrollGlow.releaseAll();
                 }
             }
 
             return rv;
         }
 
         @Override
         public boolean onHoverEvent(MotionEvent event) {
-            return isDestroyed(NO_WARN) ? false : mContentViewCore.onHoverEvent(event);
+            return isDestroyedOrNoOperation(NO_WARN) ? false : mContentViewCore.onHoverEvent(event);
         }
 
         @Override
         public boolean onGenericMotionEvent(MotionEvent event) {
-            return isDestroyed(NO_WARN) ? false : mContentViewCore.onGenericMotionEvent(event);
+            return isDestroyedOrNoOperation(NO_WARN) ? false
+                    : mContentViewCore.onGenericMotionEvent(event);
         }
 
         @Override
         public void onConfigurationChanged(Configuration newConfig) {
-            if (!isDestroyed(NO_WARN)) mContentViewCore.onConfigurationChanged(newConfig);
+            if (!isDestroyedOrNoOperation(NO_WARN)) {
+                mContentViewCore.onConfigurationChanged(newConfig);
+            }
         }
 
         @Override
         public void onAttachedToWindow() {
-            if (isDestroyed(NO_WARN)) return;
+            if (isDestroyedOrNoOperation(NO_WARN)) return;
             if (mIsAttachedToWindow) {
                 Log.w(TAG, "onAttachedToWindow called when already attached. Ignoring");
                 return;
             }
             mIsAttachedToWindow = true;
 
             mContentViewCore.onAttachedToWindow();
             nativeOnAttachedToWindow(mNativeAwContents, mContainerView.getWidth(),
                     mContainerView.getHeight());
             updateHardwareAcceleratedFeaturesToggle();
             postUpdateContentViewCoreVisibility();
             mCurrentFunctor.onAttachedToWindow();
 
             updateDefaultLocale();
             mSettings.updateAcceptLanguages();
 
             if (mComponentCallbacks != null) return;
             mComponentCallbacks = new AwComponentCallbacks();
             mContext.registerComponentCallbacks(mComponentCallbacks);
         }
 
         @Override
         public void onDetachedFromWindow() {
-            if (isDestroyed(NO_WARN)) return;
+            if (isDestroyedOrNoOperation(NO_WARN)) return;
             if (!mIsAttachedToWindow) {
                 Log.w(TAG, "onDetachedFromWindow called when already detached. Ignoring");
                 return;
             }
             mIsAttachedToWindow = false;
             hideAutofillPopup();
             nativeOnDetachedFromWindow(mNativeAwContents);
 
             mContentViewCore.onDetachedFromWindow();
             updateHardwareAcceleratedFeaturesToggle();
             postUpdateContentViewCoreVisibility();
             mCurrentFunctor.onDetachedFromWindow();
 
             if (mComponentCallbacks != null) {
                 mContext.unregisterComponentCallbacks(mComponentCallbacks);
                 mComponentCallbacks = null;
             }
 
             mScrollAccessibilityHelper.removePostedCallbacks();
             mZoomControls.dismissZoomPicker();
         }
 
         @Override
         public void onWindowFocusChanged(boolean hasWindowFocus) {
-            if (isDestroyed(NO_WARN)) return;
+            if (isDestroyedOrNoOperation(NO_WARN)) return;
             mWindowFocused = hasWindowFocus;
             mContentViewCore.onWindowFocusChanged(hasWindowFocus);
         }
 
         @Override
         public void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
-            if (isDestroyed(NO_WARN)) return;
+            if (isDestroyedOrNoOperation(NO_WARN)) return;
             mContainerViewFocused = focused;
             mContentViewCore.onFocusChanged(focused);
         }
 
         @Override
         public void onSizeChanged(int w, int h, int ow, int oh) {
-            if (isDestroyed(NO_WARN)) return;
+            if (isDestroyedOrNoOperation(NO_WARN)) return;
             mScrollOffsetManager.setContainerViewSize(w, h);
             // The AwLayoutSizer needs to go first so that if we're in
             // fixedLayoutSize mode the update
             // to enter fixedLayoutSize mode is sent before the first resize
             // update.
             mLayoutSizer.onSizeChanged(w, h, ow, oh);
             mContentViewCore.onPhysicalBackingSizeChanged(w, h);
             mContentViewCore.onSizeChanged(w, h, ow, oh);
             nativeOnSizeChanged(mNativeAwContents, w, h, ow, oh);
         }
@@ skipping 57 matching lines @@
             return mScrollOffsetManager.computeVerticalScrollOffset();
         }
 
         @Override
         public int computeVerticalScrollExtent() {
             return mScrollOffsetManager.computeVerticalScrollExtent();
         }
 
         @Override
         public void computeScroll() {
-            if (isDestroyed(NO_WARN)) return;
+            if (isDestroyedOrNoOperation(NO_WARN)) return;
             nativeOnComputeScroll(mNativeAwContents, AnimationUtils.currentAnimationTimeMillis());
         }
     }
 
     // Return true if the GeolocationPermissionAPI should be used.
     @CalledByNative
     private boolean useLegacyGeolocationPermissionAPI() {
         // Always return true since we are not ready to swap the geolocation yet.
         // TODO: If we decide not to migrate the geolocation, there are some unreachable
         // code need to remove. http://crbug.com/396184.
@@ skipping 88 matching lines @@
 
     private native void nativePostMessageToFrame(long nativeAwContents, String frameId,
             String message, String targetOrigin, int[] msgPorts);
 
     private native void nativeCreateMessageChannel(
             long nativeAwContents, AppWebMessagePort[] ports);
 
     private native void nativeGrantFileSchemeAccesstoChildProcess(long nativeAwContents);
     private native void nativeResumeLoadingCreatedPopupWebContents(long nativeAwContents);
 }