Introduce a delay before a high priority binding is unbound (reland).

content/public/android/java/src/org/chromium/content/browser/ChildProcessConnection.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.content.browser;
 
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.ServiceConnection;
@@ skipping 250 matching lines @@
 
     /**
      * Terminates the connection to IChildProcessService, closing all bindings. It is safe to call
      * this multiple times.
      */
     void stop() {
         synchronized(mUiThreadLock) {
             mInitialBinding.unbind();
             mStrongBinding.unbind();
             mWaivedBinding.unbind();
-            mAttachAsActiveCount = 0;
             if (mService != null) {
                 mService = null;
                 mPID = 0;
             }
             mConnectionParams = null;
             mServiceConnectComplete = false;
         }
     }
 
     // Called on the main thread to notify that the bindService() call failed (returned false).
@@ skipping 66 matching lines @@
                 Log.w(TAG, "Failed to close FD.", ioe);
             }
         }
         mConnectionParams = null;
         if (onConnectionCallback != null) {
             onConnectionCallback.run();
         }
         TraceEvent.end();
     }
 
+    private static final long REMOVE_INITIAL_BINDING_DELAY_MILLIS = 1 * 1000;  // One second.
+
     /**
      * Called to remove the strong binding estabilished when the connection was started. It is safe
-     * to call this multiple times.
+     * to call this multiple times. The binding is removed after a fixed delay period so that the
+     * renderer will not be killed immediately after the call.
      */
     void removeInitialBinding() {
-        synchronized(mUiThreadLock) {
-            mInitialBinding.unbind();
-        }
+        ThreadUtils.postOnUiThreadDelayed(new Runnable() {

[klobag.chromium, 2013/07/19 16:19:55]

why need this?

[klobag.chromium, 2013/07/19 18:19:05]

Just saw the comment in the other CL, thanks.

This can be called a lot even it only needs to be called once. Can we avoid spam
the message queue? 

[ppi, 2013/07/22 13:50:38]

Done.

+            @Override
+            public void run() {
+                synchronized(mUiThreadLock) {
+                    mInitialBinding.unbind();
+                }
+            }
+        }, REMOVE_INITIAL_BINDING_DELAY_MILLIS);
     }
 
     /**
      * Called when the service becomes active, ie important to the caller. This is handled by
      * setting up a binding that will make the service as important as the main process. We allow
      * callers to indicate the same connection as active multiple times. Instead of maintaining
      * multiple bindings, we count the requests and unbind when the count drops to zero.
      */
     void attachAsActive() {
         synchronized(mUiThreadLock) {
             if (mService == null) {
                 Log.w(TAG, "The connection is not bound for " + mPID);
                 return;
             }
             if (mAttachAsActiveCount == 0) {
                 mStrongBinding.bind(null);
             }
             mAttachAsActiveCount++;
         }
     }
 
+    private static final long DETACH_AS_ACTIVE_DELAY_MILLIS = 5 * 1000;  // Five seconds.
+
     /**
-     * Called when the service is no longer considered active.
+     * Called when the service is no longer considered active. Actual binding is removed after a
+     * fixed delay period so that the renderer will not be killed immediately after the call.
      */
     void detachAsActive() {
-        synchronized(mUiThreadLock) {
-            assert mAttachAsActiveCount > 0;
-            if (mService == null) {
-                Log.w(TAG, "The connection is not bound for " + mPID);
-                return;
+        ThreadUtils.postOnUiThreadDelayed(new Runnable() {
+            @Override
+            public void run() {
+                synchronized(mUiThreadLock) {
+                    assert mAttachAsActiveCount > 0;
+                    if (mService == null) {

[klobag.chromium, 2013/07/19 16:19:55]

If you move line 405 to above 410, you can leave stop() unchanged. Otherwise can
you add a comment in stop() to explain why we don't reset the count?

[ppi, 2013/07/22 13:50:38]

Thanks, done (moved).

+                        Log.w(TAG, "The connection is not bound for " + mPID);
+                        return;
+                    }
+                    mAttachAsActiveCount--;
+                    if (mAttachAsActiveCount == 0) {
+                        mStrongBinding.unbind();
+                    }
+                }
             }
-            mAttachAsActiveCount--;
-            if (mAttachAsActiveCount == 0) {
-                mStrongBinding.unbind();
-            }
-        }
+        }, DETACH_AS_ACTIVE_DELAY_MILLIS);
     }
 
 
     /**
      * @return The connection PID, or 0 if not yet connected.
      */
     public int getPid() {
         synchronized(mUiThreadLock) {
             return mPID;
         }
     }
 }