diff --git a/core/java/android/webkit/WebView.java b/core/java/android/webkit/WebView.java
index 040bf15..9098639 100644
--- a/core/java/android/webkit/WebView.java
+++ b/core/java/android/webkit/WebView.java
@@ -5619,6 +5619,11 @@
             overScrollBy(deltaX, deltaY, oldX, oldY,
                     rangeX, rangeY,
                     mOverscrollDistance, mOverscrollDistance, true);
+            if (mEdgeGlowTop != null &&
+                    (!mEdgeGlowTop.isFinished() || !mEdgeGlowBottom.isFinished() ||
+                            !mEdgeGlowLeft.isFinished() || !mEdgeGlowRight.isFinished())) {
+                invalidate();
+            }
         }
         if (!getSettings().getBuiltInZoomControls()) {
             boolean showPlusMinus = mMinZoomScale < mMaxZoomScale;
diff --git a/core/tests/coretests/src/android/bluetooth/BluetoothStressTest.java b/core/tests/coretests/src/android/bluetooth/BluetoothStressTest.java
index 149685c..892dc8a 100644
--- a/core/tests/coretests/src/android/bluetooth/BluetoothStressTest.java
+++ b/core/tests/coretests/src/android/bluetooth/BluetoothStressTest.java
@@ -80,12 +80,17 @@
     }
 
     public void testPair() {
+        int iterations = BluetoothTestRunner.sPairIterations;
         BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
-        BluetoothDevice device = adapter.getRemoteDevice(BluetoothTestRunner.sHeadsetAddress);
-
+        BluetoothDevice device = adapter.getRemoteDevice(BluetoothTestRunner.sPairAddress);
         mTestUtils.enable(adapter);
-        mTestUtils.pair(adapter, device);
-        mTestUtils.unpair(adapter, device);
+
+        for (int i = 0; i < iterations; i++) {
+            mTestUtils.writeOutput("pair iteration " + (i + 1) + " of " + iterations);
+            mTestUtils.pair(adapter, device, BluetoothTestRunner.sPairPasskey,
+                    BluetoothTestRunner.sPairPin);
+            mTestUtils.unpair(adapter, device);
+        }
         mTestUtils.disable(adapter);
     }
 
@@ -95,7 +100,8 @@
         BluetoothDevice device = adapter.getRemoteDevice(BluetoothTestRunner.sA2dpAddress);
 
         mTestUtils.enable(adapter);
-        mTestUtils.pair(adapter, device);
+        mTestUtils.pair(adapter, device, BluetoothTestRunner.sPairPasskey,
+                BluetoothTestRunner.sPairPin);
 
         for (int i = 0; i < iterations; i++) {
             mTestUtils.writeOutput("connectA2dp iteration " + (i + 1) + " of " + iterations);
@@ -113,7 +119,8 @@
         BluetoothDevice device = adapter.getRemoteDevice(BluetoothTestRunner.sHeadsetAddress);
 
         mTestUtils.enable(adapter);
-        mTestUtils.pair(adapter, device);
+        mTestUtils.pair(adapter, device, BluetoothTestRunner.sPairPasskey,
+                BluetoothTestRunner.sPairPin);
 
         for (int i = 0; i < iterations; i++) {
             mTestUtils.writeOutput("connectHeadset iteration " + (i + 1) + " of " + iterations);
diff --git a/core/tests/coretests/src/android/bluetooth/BluetoothTestRunner.java b/core/tests/coretests/src/android/bluetooth/BluetoothTestRunner.java
index 2e6daa3..050dc30 100644
--- a/core/tests/coretests/src/android/bluetooth/BluetoothTestRunner.java
+++ b/core/tests/coretests/src/android/bluetooth/BluetoothTestRunner.java
@@ -26,12 +26,17 @@
     public static int sEnableIterations = 100;
     public static int sDiscoverableIterations = 1000;
     public static int sScanIterations = 1000;
+    public static int sPairIterations = 100;
     public static int sConnectHeadsetIterations = 100;
     public static int sConnectA2dpIterations = 100;
 
+    public static String sPairAddress = "";
     public static String sHeadsetAddress = "";
     public static String sA2dpAddress = "";
 
+    public static byte[] sPairPin = {'1', '2', '3', '4'};
+    public static int sPairPasskey = 123456;
+
     @Override
     public TestSuite getAllTests() {
         TestSuite suite = new InstrumentationTestSuite(this);
@@ -75,6 +80,15 @@
             }
         }
 
+        val = arguments.getString("pair_iterations");
+        if (val != null) {
+            try {
+                sPairIterations = Integer.parseInt(val);
+            } catch (NumberFormatException e) {
+                // Invalid argument, fall back to default value
+            }
+        }
+
         val = arguments.getString("connect_a2dp_iterations");
         if (val != null) {
             try {
@@ -93,6 +107,11 @@
             }
         }
 
+        val = arguments.getString("pair_address");
+        if (val != null) {
+            sPairAddress = val;
+        }
+
         val = arguments.getString("headset_address");
         if (val != null) {
             sHeadsetAddress = val;
@@ -102,5 +121,19 @@
         if (val != null) {
             sA2dpAddress = val;
         }
+
+        val = arguments.getString("pair_pin");
+        if (val != null) {
+            sPairPin = BluetoothDevice.convertPinToBytes(val);
+        }
+
+        val = arguments.getString("pair_passkey");
+        if (val != null) {
+            try {
+                sPairPasskey = Integer.parseInt(val);
+            } catch (NumberFormatException e) {
+                // Invalid argument, fall back to default value
+            }
+        }
     }
 }
diff --git a/core/tests/coretests/src/android/bluetooth/BluetoothTestUtils.java b/core/tests/coretests/src/android/bluetooth/BluetoothTestUtils.java
index 2d0424d..f7bb1f9 100644
--- a/core/tests/coretests/src/android/bluetooth/BluetoothTestUtils.java
+++ b/core/tests/coretests/src/android/bluetooth/BluetoothTestUtils.java
@@ -30,6 +30,8 @@
 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
 
 public class BluetoothTestUtils extends Assert {
 
@@ -88,33 +90,6 @@
      */
     private static final int DISCONNECT_HEADSET_TIMEOUT = 20000;
 
-    private static final int DISCOVERY_STARTED_FLAG = 1;
-    private static final int DISCOVERY_FINISHED_FLAG = 1 << 1;
-    private static final int SCAN_MODE_NONE_FLAG = 1 << 2;
-    private static final int SCAN_MODE_CONNECTABLE_FLAG = 1 << 3;
-    private static final int SCAN_MODE_CONNECTABLE_DISCOVERABLE_FLAG = 1 << 4;
-    private static final int STATE_OFF_FLAG = 1 << 5;
-    private static final int STATE_TURNING_ON_FLAG = 1 << 6;
-    private static final int STATE_ON_FLAG = 1 << 7;
-    private static final int STATE_TURNING_OFF_FLAG = 1 << 8;
-    private static final int PAIR_STATE_FLAG = 1 << 9;
-    private static final int PROFILE_A2DP_FLAG = 1 << 10;
-    private static final int PROFILE_HEADSET_FLAG = 1 << 11;
-
-    private static final int PAIR_STATE_BONDED = 1;
-    private static final int PAIR_STATE_BONDING = 1 << 1;
-    private static final int PAIR_STATE_NONE = 1 << 2;
-
-    private static final int A2DP_STATE_DISCONNECTED = 1;
-    private static final int A2DP_STATE_CONNECTING = 1 << 1;
-    private static final int A2DP_STATE_CONNECTED = 1 << 2;
-    private static final int A2DP_STATE_DISCONNECTING = 1 << 3;
-    private static final int A2DP_STATE_PLAYING = 1 << 4;
-
-    private static final int HEADSET_STATE_DISCONNECTED = 1;
-    private static final int HEADSET_STATE_CONNECTING = 1 << 1;
-    private static final int HEADSET_STATE_CONNECTED = 1 << 2;
-
     /**
      * Time between polls in ms.
      */
@@ -155,8 +130,29 @@
     private HeadsetServiceListener mHeadsetServiceListener = new HeadsetServiceListener();
 
     private class BluetoothReceiver extends BroadcastReceiver {
+        private static final int DISCOVERY_STARTED_FLAG = 1;
+        private static final int DISCOVERY_FINISHED_FLAG = 1 << 1;
+        private static final int SCAN_MODE_NONE_FLAG = 1 << 2;
+        private static final int SCAN_MODE_CONNECTABLE_FLAG = 1 << 3;
+        private static final int SCAN_MODE_CONNECTABLE_DISCOVERABLE_FLAG = 1 << 4;
+        private static final int STATE_OFF_FLAG = 1 << 5;
+        private static final int STATE_TURNING_ON_FLAG = 1 << 6;
+        private static final int STATE_ON_FLAG = 1 << 7;
+        private static final int STATE_TURNING_OFF_FLAG = 1 << 8;
+        private static final int PROFILE_A2DP_FLAG = 1 << 9;
+        private static final int PROFILE_HEADSET_FLAG = 1 << 10;
+
+        private static final int A2DP_STATE_DISCONNECTED = 1;
+        private static final int A2DP_STATE_CONNECTING = 1 << 1;
+        private static final int A2DP_STATE_CONNECTED = 1 << 2;
+        private static final int A2DP_STATE_DISCONNECTING = 1 << 3;
+        private static final int A2DP_STATE_PLAYING = 1 << 4;
+
+        private static final int HEADSET_STATE_DISCONNECTED = 1;
+        private static final int HEADSET_STATE_CONNECTING = 1 << 1;
+        private static final int HEADSET_STATE_CONNECTED = 1 << 2;
+
         private int mFiredFlags = 0;
-        private int mPairFiredFlags = 0;
         private int mA2dpFiredFlags = 0;
         private int mHeadsetFiredFlags = 0;
 
@@ -200,21 +196,6 @@
                             mFiredFlags |= STATE_TURNING_OFF_FLAG;
                             break;
                     }
-                } else if (BluetoothDevice.ACTION_BOND_STATE_CHANGED.equals(intent.getAction())) {
-                    mFiredFlags |= PAIR_STATE_FLAG;
-                    int state = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE, -1);
-                    assertNotSame(state, -1);
-                    switch (state) {
-                        case BluetoothDevice.BOND_BONDED:
-                            mPairFiredFlags |= PAIR_STATE_BONDED;
-                            break;
-                        case BluetoothDevice.BOND_BONDING:
-                            mPairFiredFlags |= PAIR_STATE_BONDING;
-                            break;
-                        case BluetoothDevice.BOND_NONE:
-                            mPairFiredFlags |= PAIR_STATE_NONE;
-                            break;
-                    }
                 } else if (BluetoothA2dp.ACTION_SINK_STATE_CHANGED.equals(intent.getAction())) {
                     mFiredFlags |= PROFILE_A2DP_FLAG;
                     int state = intent.getIntExtra(BluetoothA2dp.EXTRA_SINK_STATE, -1);
@@ -262,12 +243,6 @@
             }
         }
 
-        public int getPairFiredFlags() {
-            synchronized (this) {
-                return mPairFiredFlags;
-            }
-        }
-
         public int getA2dpFiredFlags() {
             synchronized (this) {
                 return mA2dpFiredFlags;
@@ -283,14 +258,101 @@
         public void resetFiredFlags() {
             synchronized (this) {
                 mFiredFlags = 0;
-                mPairFiredFlags = 0;
                 mA2dpFiredFlags = 0;
                 mHeadsetFiredFlags = 0;
             }
         }
     }
 
-    private BluetoothReceiver mReceiver = new BluetoothReceiver();
+    private BluetoothReceiver mBluetoothReceiver = new BluetoothReceiver();
+
+    private class PairReceiver extends BroadcastReceiver {
+        private final static int PAIR_FLAG = 1;
+        private static final int PAIR_STATE_BONDED = 1;
+        private static final int PAIR_STATE_BONDING = 1 << 1;
+        private static final int PAIR_STATE_NONE = 1 << 2;
+
+        private int mFiredFlags = 0;
+        private int mPairFiredFlags = 0;
+
+        private BluetoothDevice mDevice;
+        private int mPasskey;
+        private byte[] mPin;
+
+        public PairReceiver(BluetoothDevice device, int passkey, byte[] pin) {
+            super();
+            mDevice = device;
+            mPasskey = passkey;
+            mPin = pin;
+        }
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            synchronized (this) {
+                if (BluetoothDevice.ACTION_PAIRING_REQUEST.equals(intent.getAction())
+                        && mDevice.equals(intent.getParcelableExtra(
+                                BluetoothDevice.EXTRA_DEVICE))) {
+                    int type = intent.getIntExtra(BluetoothDevice.EXTRA_PAIRING_VARIANT,
+                            BluetoothDevice.ERROR);
+                    assertNotSame(type, BluetoothDevice.ERROR);
+                    switch (type) {
+                        case BluetoothDevice.PAIRING_VARIANT_PIN:
+                            mDevice.setPin(mPin);
+                            break;
+                        case BluetoothDevice.PAIRING_VARIANT_PASSKEY:
+                            mDevice.setPasskey(mPasskey);
+                            break;
+                        case BluetoothDevice.PAIRING_VARIANT_PASSKEY_CONFIRMATION:
+                        case BluetoothDevice.PAIRING_VARIANT_CONSENT:
+                            mDevice.setPairingConfirmation(true);
+                            break;
+                        case BluetoothDevice.PAIRING_VARIANT_OOB_CONSENT:
+                            mDevice.setRemoteOutOfBandData();
+                            break;
+                    }
+                } else if (BluetoothDevice.ACTION_BOND_STATE_CHANGED.equals(intent.getAction())
+                        && mDevice.equals(intent.getParcelableExtra(
+                                BluetoothDevice.EXTRA_DEVICE))) {
+                    mFiredFlags |= PAIR_FLAG;
+                    int state = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE,
+                            BluetoothDevice.ERROR);
+                    assertNotSame(state, BluetoothDevice.ERROR);
+                    switch (state) {
+                        case BluetoothDevice.BOND_BONDED:
+                            mPairFiredFlags |= PAIR_STATE_BONDED;
+                            break;
+                        case BluetoothDevice.BOND_BONDING:
+                            mPairFiredFlags |= PAIR_STATE_BONDING;
+                            break;
+                        case BluetoothDevice.BOND_NONE:
+                            mPairFiredFlags |= PAIR_STATE_NONE;
+                            break;
+                    }
+                }
+            }
+        }
+
+        public int getFiredFlags() {
+            synchronized (this) {
+                return mFiredFlags;
+            }
+        }
+
+        public int getPairFiredFlags() {
+            synchronized (this) {
+                return mPairFiredFlags;
+            }
+        }
+
+        public void resetFiredFlags() {
+            synchronized (this) {
+                mFiredFlags = 0;
+                mPairFiredFlags = 0;
+            }
+        }
+    }
+
+    private List<BroadcastReceiver> mReceivers = new ArrayList<BroadcastReceiver>();
 
     public BluetoothTestUtils(Context context, String tag) {
         this(context, tag, null);
@@ -313,19 +375,16 @@
             }
         }
 
-        IntentFilter filter = new IntentFilter();
-        filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
-        filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_STARTED);
-        filter.addAction(BluetoothAdapter.ACTION_SCAN_MODE_CHANGED);
-        filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
-        mContext.registerReceiver(mReceiver, filter);
-
         mA2dp = new BluetoothA2dp(mContext);
         mHeadset = new BluetoothHeadset(mContext, mHeadsetServiceListener);
+        mBluetoothReceiver = getBluetoothReceiver(mContext);
+        mReceivers.add(mBluetoothReceiver);
     }
 
     public void close() {
-        mContext.unregisterReceiver(mReceiver);
+        while (!mReceivers.isEmpty()) {
+            mContext.unregisterReceiver(mReceivers.remove(0));
+        }
 
         if (mOutputWriter != null) {
             try {
@@ -337,8 +396,9 @@
     }
 
     public void enable(BluetoothAdapter adapter) {
-        int mask = STATE_TURNING_ON_FLAG | STATE_ON_FLAG | SCAN_MODE_CONNECTABLE_FLAG;
-        mReceiver.resetFiredFlags();
+        int mask = (BluetoothReceiver.STATE_TURNING_ON_FLAG | BluetoothReceiver.STATE_ON_FLAG
+                | BluetoothReceiver.SCAN_MODE_CONNECTABLE_FLAG);
+        mBluetoothReceiver.resetFiredFlags();
 
         int state = adapter.getState();
         switch (state) {
@@ -363,8 +423,8 @@
             state = adapter.getState();
             if (state == BluetoothAdapter.STATE_ON) {
                 assertTrue(adapter.isEnabled());
-                if ((mReceiver.getFiredFlags() & mask) == mask) {
-                    mReceiver.resetFiredFlags();
+                if ((mBluetoothReceiver.getFiredFlags() & mask) == mask) {
+                    mBluetoothReceiver.resetFiredFlags();
                     writeOutput(String.format("enable() completed in %d ms",
                             (System.currentTimeMillis() - s)));
                     return;
@@ -376,15 +436,16 @@
             sleep(POLL_TIME);
         }
 
-        int firedFlags = mReceiver.getFiredFlags();
-        mReceiver.resetFiredFlags();
+        int firedFlags = mBluetoothReceiver.getFiredFlags();
+        mBluetoothReceiver.resetFiredFlags();
         fail(String.format("enable() timeout: state=%d (expected %d), flags=0x%x (expected 0x%x)",
                 state, BluetoothAdapter.STATE_ON, firedFlags, mask));
     }
 
     public void disable(BluetoothAdapter adapter) {
-        int mask = STATE_TURNING_OFF_FLAG | STATE_OFF_FLAG | SCAN_MODE_NONE_FLAG;
-        mReceiver.resetFiredFlags();
+        int mask = (BluetoothReceiver.STATE_TURNING_OFF_FLAG | BluetoothReceiver.STATE_OFF_FLAG
+                | BluetoothReceiver.SCAN_MODE_NONE_FLAG);
+        mBluetoothReceiver.resetFiredFlags();
 
         int state = adapter.getState();
         switch (state) {
@@ -412,8 +473,8 @@
             state = adapter.getState();
             if (state == BluetoothAdapter.STATE_OFF) {
                 assertFalse(adapter.isEnabled());
-                if ((mReceiver.getFiredFlags() & mask) == mask) {
-                    mReceiver.resetFiredFlags();
+                if ((mBluetoothReceiver.getFiredFlags() & mask) == mask) {
+                    mBluetoothReceiver.resetFiredFlags();
                     writeOutput(String.format("disable() completed in %d ms",
                             (System.currentTimeMillis() - s)));
                     return;
@@ -425,15 +486,15 @@
             sleep(POLL_TIME);
         }
 
-        int firedFlags = mReceiver.getFiredFlags();
-        mReceiver.resetFiredFlags();
+        int firedFlags = mBluetoothReceiver.getFiredFlags();
+        mBluetoothReceiver.resetFiredFlags();
         fail(String.format("disable() timeout: state=%d (expected %d), flags=0x%x (expected 0x%x)",
                 state, BluetoothAdapter.STATE_OFF, firedFlags, mask));
     }
 
     public void discoverable(BluetoothAdapter adapter) {
-        int mask = SCAN_MODE_CONNECTABLE_DISCOVERABLE_FLAG;
-        mReceiver.resetFiredFlags();
+        int mask = BluetoothReceiver.SCAN_MODE_CONNECTABLE_DISCOVERABLE_FLAG;
+        mBluetoothReceiver.resetFiredFlags();
 
         if (!adapter.isEnabled()) {
             fail("discoverable() bluetooth not enabled");
@@ -451,8 +512,8 @@
         while (System.currentTimeMillis() - s < SET_SCAN_MODE_TIMEOUT) {
             scanMode = adapter.getScanMode();
             if (scanMode == BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE) {
-                if ((mReceiver.getFiredFlags() & mask) == mask) {
-                    mReceiver.resetFiredFlags();
+                if ((mBluetoothReceiver.getFiredFlags() & mask) == mask) {
+                    mBluetoothReceiver.resetFiredFlags();
                     writeOutput(String.format("discoverable() completed in %d ms",
                             (System.currentTimeMillis() - s)));
                     return;
@@ -463,16 +524,16 @@
             sleep(POLL_TIME);
         }
 
-        int firedFlags = mReceiver.getFiredFlags();
-        mReceiver.resetFiredFlags();
+        int firedFlags = mBluetoothReceiver.getFiredFlags();
+        mBluetoothReceiver.resetFiredFlags();
         fail(String.format("discoverable() timeout: scanMode=%d (expected %d), flags=0x%x "
                 + "(expected 0x%x)", scanMode, BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE,
                 firedFlags, mask));
     }
 
     public void undiscoverable(BluetoothAdapter adapter) {
-        int mask = SCAN_MODE_CONNECTABLE_FLAG;
-        mReceiver.resetFiredFlags();
+        int mask = BluetoothReceiver.SCAN_MODE_CONNECTABLE_FLAG;
+        mBluetoothReceiver.resetFiredFlags();
 
         if (!adapter.isEnabled()) {
             fail("undiscoverable() bluetooth not enabled");
@@ -490,8 +551,8 @@
         while (System.currentTimeMillis() - s < SET_SCAN_MODE_TIMEOUT) {
             scanMode = adapter.getScanMode();
             if (scanMode == BluetoothAdapter.SCAN_MODE_CONNECTABLE) {
-                if ((mReceiver.getFiredFlags() & mask) == mask) {
-                    mReceiver.resetFiredFlags();
+                if ((mBluetoothReceiver.getFiredFlags() & mask) == mask) {
+                    mBluetoothReceiver.resetFiredFlags();
                     writeOutput(String.format("undiscoverable() completed in %d ms",
                             (System.currentTimeMillis() - s)));
                     return;
@@ -502,16 +563,16 @@
             sleep(POLL_TIME);
         }
 
-        int firedFlags = mReceiver.getFiredFlags();
-        mReceiver.resetFiredFlags();
+        int firedFlags = mBluetoothReceiver.getFiredFlags();
+        mBluetoothReceiver.resetFiredFlags();
         fail(String.format("undiscoverable() timeout: scanMode=%d (expected %d), flags=0x%x "
                 + "(expected 0x%x)", scanMode, BluetoothAdapter.SCAN_MODE_CONNECTABLE, firedFlags,
                 mask));
     }
 
     public void startScan(BluetoothAdapter adapter) {
-        int mask = DISCOVERY_STARTED_FLAG;
-        mReceiver.resetFiredFlags();
+        int mask = BluetoothReceiver.DISCOVERY_STARTED_FLAG;
+        mBluetoothReceiver.resetFiredFlags();
 
         if (!adapter.isEnabled()) {
             fail("startScan() bluetooth not enabled");
@@ -525,8 +586,8 @@
 
         long s = System.currentTimeMillis();
         while (System.currentTimeMillis() - s < START_DISCOVERY_TIMEOUT) {
-            if (adapter.isDiscovering() && ((mReceiver.getFiredFlags() & mask) == mask)) {
-                mReceiver.resetFiredFlags();
+            if (adapter.isDiscovering() && ((mBluetoothReceiver.getFiredFlags() & mask) == mask)) {
+                mBluetoothReceiver.resetFiredFlags();
                 writeOutput(String.format("startScan() completed in %d ms",
                         (System.currentTimeMillis() - s)));
                 return;
@@ -534,15 +595,15 @@
             sleep(POLL_TIME);
         }
 
-        int firedFlags = mReceiver.getFiredFlags();
-        mReceiver.resetFiredFlags();
+        int firedFlags = mBluetoothReceiver.getFiredFlags();
+        mBluetoothReceiver.resetFiredFlags();
         fail(String.format("startScan() timeout: isDiscovering=%b, flags=0x%x (expected 0x%x)",
                 adapter.isDiscovering(), firedFlags, mask));
     }
 
     public void stopScan(BluetoothAdapter adapter) {
-        int mask = DISCOVERY_FINISHED_FLAG;
-        mReceiver.resetFiredFlags();
+        int mask = BluetoothReceiver.DISCOVERY_FINISHED_FLAG;
+        mBluetoothReceiver.resetFiredFlags();
 
         if (!adapter.isEnabled()) {
             fail("stopScan() bluetooth not enabled");
@@ -557,8 +618,8 @@
 
         long s = System.currentTimeMillis();
         while (System.currentTimeMillis() - s < CANCEL_DISCOVERY_TIMEOUT) {
-            if (!adapter.isDiscovering() && ((mReceiver.getFiredFlags() & mask) == mask)) {
-                mReceiver.resetFiredFlags();
+            if (!adapter.isDiscovering() && ((mBluetoothReceiver.getFiredFlags() & mask) == mask)) {
+                mBluetoothReceiver.resetFiredFlags();
                 writeOutput(String.format("stopScan() completed in %d ms",
                         (System.currentTimeMillis() - s)));
                 return;
@@ -566,17 +627,19 @@
             sleep(POLL_TIME);
         }
 
-        int firedFlags = mReceiver.getFiredFlags();
-        mReceiver.resetFiredFlags();
+        int firedFlags = mBluetoothReceiver.getFiredFlags();
+        mBluetoothReceiver.resetFiredFlags();
         fail(String.format("stopScan() timeout: isDiscovering=%b, flags=0x%x (expected 0x%x)",
                 adapter.isDiscovering(), firedFlags, mask));
 
     }
 
-    public void pair(BluetoothAdapter adapter, BluetoothDevice device) {
-        int mask = PAIR_STATE_FLAG;
-        int pairMask = PAIR_STATE_BONDING | PAIR_STATE_BONDED;
-        mReceiver.resetFiredFlags();
+    public void pair(BluetoothAdapter adapter, BluetoothDevice device, int passkey, byte[] pin) {
+        int mask = PairReceiver.PAIR_FLAG;
+        int pairMask = PairReceiver.PAIR_STATE_BONDING | PairReceiver.PAIR_STATE_BONDED;
+
+        PairReceiver pairReceiver = getPairReceiver(mContext, device, passkey, pin);
+        mReceivers.add(pairReceiver);
 
         if (!adapter.isEnabled()) {
             fail("pair() bluetooth not enabled");
@@ -604,28 +667,32 @@
             state = device.getBondState();
             if (state == BluetoothDevice.BOND_BONDED) {
                 assertTrue(adapter.getBondedDevices().contains(device));
-                if ((mReceiver.getFiredFlags() & mask) == mask
-                        && (mReceiver.getPairFiredFlags() & pairMask) == pairMask) {
+                if ((pairReceiver.getFiredFlags() & mask) == mask
+                        && (pairReceiver.getPairFiredFlags() & pairMask) == pairMask) {
                     writeOutput(String.format("pair() completed in %d ms: device=%s",
                             (System.currentTimeMillis() - s), device));
+                    mReceivers.remove(pairReceiver);
+                    mContext.unregisterReceiver(pairReceiver);
                     return;
                 }
             }
             sleep(POLL_TIME);
         }
 
-        int firedFlags = mReceiver.getFiredFlags();
-        int pairFiredFlags = mReceiver.getPairFiredFlags();
-        mReceiver.resetFiredFlags();
+        int firedFlags = pairReceiver.getFiredFlags();
+        int pairFiredFlags = pairReceiver.getPairFiredFlags();
+        pairReceiver.resetFiredFlags();
         fail(String.format("pair() timeout: state=%d (expected %d), flags=0x%x (expected 0x%x), "
                 + "pairFlags=0x%x (expected 0x%x)", state, BluetoothDevice.BOND_BONDED, firedFlags,
                 mask, pairFiredFlags, pairMask));
     }
 
     public void unpair(BluetoothAdapter adapter, BluetoothDevice device) {
-        int mask = PAIR_STATE_FLAG;
-        int pairMask = PAIR_STATE_NONE;
-        mReceiver.resetFiredFlags();
+        int mask = PairReceiver.PAIR_FLAG;
+        int pairMask = PairReceiver.PAIR_STATE_NONE;
+
+        PairReceiver pairReceiver = getPairReceiver(mContext, device, 0, null);
+        mReceivers.add(pairReceiver);
 
         if (!adapter.isEnabled()) {
             fail("unpair() bluetooth not enabled");
@@ -653,29 +720,32 @@
         while (System.currentTimeMillis() - s < UNPAIR_TIMEOUT) {
             if (device.getBondState() == BluetoothDevice.BOND_NONE) {
                 assertFalse(adapter.getBondedDevices().contains(device));
-                if ((mReceiver.getFiredFlags() & mask) == mask
-                        && (mReceiver.getPairFiredFlags() & pairMask) == pairMask) {
+                if ((pairReceiver.getFiredFlags() & mask) == mask
+                       && (pairReceiver.getPairFiredFlags() & pairMask) == pairMask) {
                     writeOutput(String.format("unpair() completed in %d ms: device=%s",
                             (System.currentTimeMillis() - s), device));
+                    mReceivers.remove(pairReceiver);
+                    mContext.unregisterReceiver(pairReceiver);
                     return;
                 }
             }
         }
 
-        int firedFlags = mReceiver.getFiredFlags();
-        int pairFiredFlags = mReceiver.getPairFiredFlags();
-        mReceiver.resetFiredFlags();
+        int firedFlags = pairReceiver.getFiredFlags();
+        int pairFiredFlags = pairReceiver.getPairFiredFlags();
+        pairReceiver.resetFiredFlags();
         fail(String.format("unpair() timeout: state=%d (expected %d), flags=0x%x (expected 0x%x), "
                 + "pairFlags=0x%x (expected 0x%x)", state, BluetoothDevice.BOND_BONDED, firedFlags,
                 mask, pairFiredFlags, pairMask));
     }
 
     public void connectA2dp(BluetoothAdapter adapter, BluetoothDevice device) {
-        int mask = PROFILE_A2DP_FLAG;
-        int a2dpMask1 = A2DP_STATE_CONNECTING | A2DP_STATE_CONNECTED | A2DP_STATE_PLAYING;
-        int a2dpMask2 = a2dpMask1 ^ A2DP_STATE_CONNECTED;
-        int a2dpMask3 = a2dpMask1 ^ A2DP_STATE_PLAYING;
-        mReceiver.resetFiredFlags();
+        int mask = BluetoothReceiver.PROFILE_A2DP_FLAG;
+        int a2dpMask1 = (BluetoothReceiver.A2DP_STATE_CONNECTING
+                | BluetoothReceiver.A2DP_STATE_CONNECTED | BluetoothReceiver.A2DP_STATE_PLAYING);
+        int a2dpMask2 = a2dpMask1 ^ BluetoothReceiver.A2DP_STATE_CONNECTED;
+        int a2dpMask3 = a2dpMask1 ^ BluetoothReceiver.A2DP_STATE_PLAYING;
+        mBluetoothReceiver.resetFiredFlags();
 
         if (!adapter.isEnabled()) {
             fail("connectA2dp() bluetooth not enabled");
@@ -712,13 +782,13 @@
                 assertTrue(mA2dp.isSinkConnected(device));
                 // Check whether STATE_CONNECTING and (STATE_CONNECTED or STATE_PLAYING) intents
                 // have fired if we are checking if intents should be fired.
-                int firedFlags = mReceiver.getFiredFlags();
-                int a2dpFiredFlags = mReceiver.getA2dpFiredFlags();
-                if ((mReceiver.getFiredFlags() & mask) == mask
+                int firedFlags = mBluetoothReceiver.getFiredFlags();
+                int a2dpFiredFlags = mBluetoothReceiver.getA2dpFiredFlags();
+                if ((mBluetoothReceiver.getFiredFlags() & mask) == mask
                         && ((a2dpFiredFlags & a2dpMask1) == a2dpMask1
                                 || (a2dpFiredFlags & a2dpMask2) == a2dpMask2
                                 || (a2dpFiredFlags & a2dpMask3) == a2dpMask3)) {
-                    mReceiver.resetFiredFlags();
+                    mBluetoothReceiver.resetFiredFlags();
                     writeOutput(String.format("connectA2dp() completed in %d ms: device=%s",
                             (System.currentTimeMillis() - s), device));
                     return;
@@ -727,9 +797,9 @@
             sleep(POLL_TIME);
         }
 
-        int firedFlags = mReceiver.getFiredFlags();
-        int a2dpFiredFlags = mReceiver.getA2dpFiredFlags();
-        mReceiver.resetFiredFlags();
+        int firedFlags = mBluetoothReceiver.getFiredFlags();
+        int a2dpFiredFlags = mBluetoothReceiver.getA2dpFiredFlags();
+        mBluetoothReceiver.resetFiredFlags();
         fail(String.format("connectA2dp() timeout: state=%d (expected %d or %d), "
                 + "flags=0x%x (expected 0x%x), a2dpFlags=0x%x (expected 0x%x or 0x%x or 0x%x)",
                 state, BluetoothHeadset.STATE_CONNECTED, BluetoothA2dp.STATE_PLAYING, firedFlags,
@@ -737,9 +807,10 @@
     }
 
     public void disconnectA2dp(BluetoothAdapter adapter, BluetoothDevice device) {
-        int mask = PROFILE_A2DP_FLAG;
-        int a2dpMask = A2DP_STATE_DISCONNECTING | A2DP_STATE_DISCONNECTED;
-        mReceiver.resetFiredFlags();
+        int mask = BluetoothReceiver.PROFILE_A2DP_FLAG;
+        int a2dpMask = (BluetoothReceiver.A2DP_STATE_DISCONNECTING
+                | BluetoothReceiver.A2DP_STATE_DISCONNECTED);
+        mBluetoothReceiver.resetFiredFlags();
 
         if (!adapter.isEnabled()) {
             fail("disconnectA2dp() bluetooth not enabled");
@@ -777,9 +848,9 @@
             state = mA2dp.getSinkState(device);
             if (state == BluetoothA2dp.STATE_DISCONNECTED) {
                 assertFalse(mA2dp.isSinkConnected(device));
-                if ((mReceiver.getFiredFlags() & mask) == mask
-                        && (mReceiver.getA2dpFiredFlags() & a2dpMask) == a2dpMask) {
-                    mReceiver.resetFiredFlags();
+                if ((mBluetoothReceiver.getFiredFlags() & mask) == mask
+                        && (mBluetoothReceiver.getA2dpFiredFlags() & a2dpMask) == a2dpMask) {
+                    mBluetoothReceiver.resetFiredFlags();
                     writeOutput(String.format("disconnectA2dp() completed in %d ms: device=%s",
                             (System.currentTimeMillis() - s), device));
                     return;
@@ -788,18 +859,19 @@
             sleep(POLL_TIME);
         }
 
-        int firedFlags = mReceiver.getFiredFlags();
-        int a2dpFiredFlags = mReceiver.getA2dpFiredFlags();
-        mReceiver.resetFiredFlags();
+        int firedFlags = mBluetoothReceiver.getFiredFlags();
+        int a2dpFiredFlags = mBluetoothReceiver.getA2dpFiredFlags();
+        mBluetoothReceiver.resetFiredFlags();
         fail(String.format("disconnectA2dp() timeout: state=%d (expected %d), "
                 + "flags=0x%x (expected 0x%x), a2dpFlags=0x%x (expected 0x%x)", state,
                 BluetoothA2dp.STATE_DISCONNECTED, firedFlags, mask, a2dpFiredFlags, a2dpMask));
     }
 
     public void connectHeadset(BluetoothAdapter adapter, BluetoothDevice device) {
-        int mask = PROFILE_HEADSET_FLAG;
-        int headsetMask = HEADSET_STATE_CONNECTING | HEADSET_STATE_CONNECTED;
-        mReceiver.resetFiredFlags();
+        int mask = BluetoothReceiver.PROFILE_HEADSET_FLAG;
+        int headsetMask = (BluetoothReceiver.HEADSET_STATE_CONNECTING
+                | BluetoothReceiver.HEADSET_STATE_CONNECTED);
+        mBluetoothReceiver.resetFiredFlags();
 
         if (!adapter.isEnabled()) {
             fail("connectHeadset() bluetooth not enabled");
@@ -839,9 +911,9 @@
             state = mHeadset.getState(device);
             if (state == BluetoothHeadset.STATE_CONNECTED) {
                 assertTrue(mHeadset.isConnected(device));
-                if ((mReceiver.getFiredFlags() & mask) == mask
-                        && (mReceiver.getHeadsetFiredFlags() & headsetMask) == headsetMask) {
-                    mReceiver.resetFiredFlags();
+                if ((mBluetoothReceiver.getFiredFlags() & mask) == mask
+                        && (mBluetoothReceiver.getHeadsetFiredFlags() & headsetMask) == headsetMask) {
+                    mBluetoothReceiver.resetFiredFlags();
                     writeOutput(String.format("connectHeadset() completed in %d ms: device=%s",
                             (System.currentTimeMillis() - s), device));
                     return;
@@ -850,9 +922,9 @@
             sleep(POLL_TIME);
         }
 
-        int firedFlags = mReceiver.getFiredFlags();
-        int headsetFiredFlags = mReceiver.getHeadsetFiredFlags();
-        mReceiver.resetFiredFlags();
+        int firedFlags = mBluetoothReceiver.getFiredFlags();
+        int headsetFiredFlags = mBluetoothReceiver.getHeadsetFiredFlags();
+        mBluetoothReceiver.resetFiredFlags();
         fail(String.format("connectHeadset() timeout: state=%d (expected %d), "
                 + "flags=0x%x (expected 0x%x), headsetFlags=0x%s (expected 0x%x)", state,
                 BluetoothHeadset.STATE_CONNECTED, firedFlags, mask, headsetFiredFlags,
@@ -860,9 +932,9 @@
     }
 
     public void disconnectHeadset(BluetoothAdapter adapter, BluetoothDevice device) {
-        int mask = PROFILE_HEADSET_FLAG;
-        int headsetMask = HEADSET_STATE_DISCONNECTED;
-        mReceiver.resetFiredFlags();
+        int mask = BluetoothReceiver.PROFILE_HEADSET_FLAG;
+        int headsetMask = BluetoothReceiver.HEADSET_STATE_DISCONNECTED;
+        mBluetoothReceiver.resetFiredFlags();
 
         if (!adapter.isEnabled()) {
             fail("disconnectHeadset() bluetooth not enabled");
@@ -898,9 +970,9 @@
             state = mHeadset.getState(device);
             if (state == BluetoothHeadset.STATE_DISCONNECTED) {
                 assertFalse(mHeadset.isConnected(device));
-                if ((mReceiver.getFiredFlags() & mask) == mask
-                        && (mReceiver.getHeadsetFiredFlags() & headsetMask) == headsetMask) {
-                    mReceiver.resetFiredFlags();
+                if ((mBluetoothReceiver.getFiredFlags() & mask) == mask
+                        && (mBluetoothReceiver.getHeadsetFiredFlags() & headsetMask) == headsetMask) {
+                    mBluetoothReceiver.resetFiredFlags();
                     writeOutput(String.format("disconnectHeadset() completed in %d ms: device=%s",
                             (System.currentTimeMillis() - s), device));
                     return;
@@ -909,9 +981,9 @@
             sleep(POLL_TIME);
         }
 
-        int firedFlags = mReceiver.getFiredFlags();
-        int headsetFiredFlags = mReceiver.getHeadsetFiredFlags();
-        mReceiver.resetFiredFlags();
+        int firedFlags = mBluetoothReceiver.getFiredFlags();
+        int headsetFiredFlags = mBluetoothReceiver.getHeadsetFiredFlags();
+        mBluetoothReceiver.resetFiredFlags();
         fail(String.format("disconnectHeadset() timeout: state=%d (expected %d), "
                 + "flags=0x%x (expected 0x%x), headsetFlags=0x%s (expected 0x%x)", state,
                 BluetoothHeadset.STATE_DISCONNECTED, firedFlags, mask, headsetFiredFlags,
@@ -931,6 +1003,29 @@
         }
     }
 
+    private BluetoothReceiver getBluetoothReceiver(Context context) {
+        BluetoothReceiver receiver = new BluetoothReceiver();
+        IntentFilter filter = new IntentFilter();
+        filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
+        filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_STARTED);
+        filter.addAction(BluetoothAdapter.ACTION_SCAN_MODE_CHANGED);
+        filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
+        filter.addAction(BluetoothA2dp.ACTION_SINK_STATE_CHANGED);
+        filter.addAction(BluetoothHeadset.ACTION_STATE_CHANGED);
+        context.registerReceiver(receiver, filter);
+        return receiver;
+    }
+
+    private PairReceiver getPairReceiver(Context context, BluetoothDevice device, int passkey,
+            byte[] pin) {
+        PairReceiver receiver = new PairReceiver(device, passkey, pin);
+        IntentFilter filter = new IntentFilter();
+        filter.addAction(BluetoothDevice.ACTION_PAIRING_REQUEST);
+        filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
+        context.registerReceiver(receiver, filter);
+        return receiver;
+    }
+
     private void sleep(long time) {
         try {
             Thread.sleep(time);
diff --git a/include/ui/InputDispatcher.h b/include/ui/InputDispatcher.h
index 4955d47..b0b855e 100644
--- a/include/ui/InputDispatcher.h
+++ b/include/ui/InputDispatcher.h
@@ -109,9 +109,6 @@
     // (ignored for KeyEvents)
     float xOffset, yOffset;
 
-    // The window type of the input target.
-    int32_t windowType;
-
     // The subset of pointer ids to include in motion events dispatched to this input target
     // if FLAG_SPLIT is set.
     BitSet32 pointerIds;
@@ -1004,8 +1001,7 @@
     void addWindowTargetLocked(const InputWindow* window, int32_t targetFlags,
             BitSet32 pointerIds);
     void addMonitoringTargetsLocked();
-    bool shouldPokeUserActivityForCurrentInputTargetsLocked();
-    void pokeUserActivityLocked(nsecs_t eventTime, int32_t eventType);
+    void pokeUserActivityLocked(const EventEntry* eventEntry);
     bool checkInjectionPermission(const InputWindow* window, const InjectionState* injectionState);
     bool isWindowObscuredAtPointLocked(const InputWindow* window, int32_t x, int32_t y) const;
     bool isWindowFinishedWithPreviousInputLocked(const InputWindow* window);
diff --git a/libs/ui/InputDispatcher.cpp b/libs/ui/InputDispatcher.cpp
index 92daee1..303075f 100644
--- a/libs/ui/InputDispatcher.cpp
+++ b/libs/ui/InputDispatcher.cpp
@@ -340,6 +340,11 @@
             mInboundQueue.dequeue(entry);
             mPendingEvent = entry;
         }
+
+        // Poke user activity for this event.
+        if (mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER) {
+            pokeUserActivityLocked(mPendingEvent);
+        }
     }
 
     // Now we have an event to dispatch.
@@ -686,11 +691,6 @@
 
     // Dispatch the key.
     dispatchEventToCurrentInputTargetsLocked(currentTime, entry, false);
-
-    // Poke user activity.
-    if (shouldPokeUserActivityForCurrentInputTargetsLocked()) {
-        pokeUserActivityLocked(entry->eventTime, POWER_MANAGER_BUTTON_EVENT);
-    }
     return true;
 }
 
@@ -753,31 +753,6 @@
 
     // Dispatch the motion.
     dispatchEventToCurrentInputTargetsLocked(currentTime, entry, false);
-
-    // Poke user activity.
-    if (shouldPokeUserActivityForCurrentInputTargetsLocked()) {
-        int32_t eventType;
-        if (isPointerEvent) {
-            switch (entry->action) {
-            case AMOTION_EVENT_ACTION_DOWN:
-                eventType = POWER_MANAGER_TOUCH_EVENT;
-                break;
-            case AMOTION_EVENT_ACTION_UP:
-                eventType = POWER_MANAGER_TOUCH_UP_EVENT;
-                break;
-            default:
-                if (entry->eventTime - entry->downTime >= EVENT_IGNORE_DURATION) {
-                    eventType = POWER_MANAGER_TOUCH_EVENT;
-                } else {
-                    eventType = POWER_MANAGER_LONG_TOUCH_EVENT;
-                }
-                break;
-            }
-        } else {
-            eventType = POWER_MANAGER_BUTTON_EVENT;
-        }
-        pokeUserActivityLocked(entry->eventTime, eventType);
-    }
     return true;
 }
 
@@ -829,6 +804,8 @@
 
     assert(eventEntry->dispatchInProgress); // should already have been set to true
 
+    pokeUserActivityLocked(eventEntry);
+
     for (size_t i = 0; i < mCurrentInputTargets.size(); i++) {
         const InputTarget& inputTarget = mCurrentInputTargets.itemAt(i);
 
@@ -1338,7 +1315,6 @@
     target.flags = targetFlags;
     target.xOffset = - window->frameLeft;
     target.yOffset = - window->frameTop;
-    target.windowType = window->layoutParamsType;
     target.pointerIds = pointerIds;
 }
 
@@ -1351,7 +1327,6 @@
         target.flags = 0;
         target.xOffset = 0;
         target.yOffset = 0;
-        target.windowType = -1;
     }
 }
 
@@ -1418,19 +1393,32 @@
     }
 }
 
-bool InputDispatcher::shouldPokeUserActivityForCurrentInputTargetsLocked() {
-    for (size_t i = 0; i < mCurrentInputTargets.size(); i++) {
-        if (mCurrentInputTargets[i].windowType == InputWindow::TYPE_KEYGUARD) {
-            return false;
+void InputDispatcher::pokeUserActivityLocked(const EventEntry* eventEntry) {
+    int32_t eventType = POWER_MANAGER_BUTTON_EVENT;
+    if (eventEntry->type == EventEntry::TYPE_MOTION) {
+        const MotionEntry* motionEntry = static_cast<const MotionEntry*>(eventEntry);
+        if (motionEntry->source & AINPUT_SOURCE_CLASS_POINTER) {
+            switch (motionEntry->action) {
+            case AMOTION_EVENT_ACTION_DOWN:
+                eventType = POWER_MANAGER_TOUCH_EVENT;
+                break;
+            case AMOTION_EVENT_ACTION_UP:
+                eventType = POWER_MANAGER_TOUCH_UP_EVENT;
+                break;
+            default:
+                if (motionEntry->eventTime - motionEntry->downTime >= EVENT_IGNORE_DURATION) {
+                    eventType = POWER_MANAGER_TOUCH_EVENT;
+                } else {
+                    eventType = POWER_MANAGER_LONG_TOUCH_EVENT;
+                }
+                break;
+            }
         }
     }
-    return true;
-}
 
-void InputDispatcher::pokeUserActivityLocked(nsecs_t eventTime, int32_t eventType) {
     CommandEntry* commandEntry = postCommandLocked(
             & InputDispatcher::doPokeUserActivityLockedInterruptible);
-    commandEntry->eventTime = eventTime;
+    commandEntry->eventTime = eventEntry->eventTime;
     commandEntry->userActivityEventType = eventType;
 }
 
diff --git a/media/libstagefright/foundation/ALooperRoster.cpp b/media/libstagefright/foundation/ALooperRoster.cpp
index 7683113..8aa1b15 100644
--- a/media/libstagefright/foundation/ALooperRoster.cpp
+++ b/media/libstagefright/foundation/ALooperRoster.cpp
@@ -54,7 +54,10 @@
     Mutex::Autolock autoLock(mLock);
 
     ssize_t index = mHandlers.indexOfKey(handlerID);
-    CHECK_GE(index, 0);
+
+    if (index < 0) {
+        return;
+    }
 
     const HandlerInfo &info = mHandlers.valueAt(index);
 
@@ -84,7 +87,8 @@
 
     if (looper == NULL) {
         LOGW("failed to post message. "
-             "Target handler still registered, but object gone.");
+             "Target handler %d still registered, but object gone.",
+             msg->target());
 
         mHandlers.removeItemsAt(index);
         return;
@@ -111,7 +115,8 @@
 
         if (handler == NULL) {
             LOGW("failed to deliver message. "
-                 "Target handler registered, but object gone.");
+                 "Target handler %d registered, but object gone.",
+                 msg->target());
 
             mHandlers.removeItemsAt(index);
             return;
diff --git a/services/java/com/android/server/LocationManagerService.java b/services/java/com/android/server/LocationManagerService.java
index 84024b8..fe1b231 100644
--- a/services/java/com/android/server/LocationManagerService.java
+++ b/services/java/com/android/server/LocationManagerService.java
@@ -89,7 +89,7 @@
  */
 public class LocationManagerService extends ILocationManager.Stub implements Runnable {
     private static final String TAG = "LocationManagerService";
-    private static final boolean LOCAL_LOGV = false;
+    private static final boolean LOCAL_LOGV = true;
 
     // The last time a location was written, by provider name.
     private HashMap<String,Long> mLastWriteTime = new HashMap<String,Long>();
@@ -224,15 +224,18 @@
 
         @Override
         public String toString() {
+            String result;
             if (mListener != null) {
-                return "Receiver{"
+                result = "Receiver{"
                         + Integer.toHexString(System.identityHashCode(this))
                         + " Listener " + mKey + "}";
             } else {
-                return "Receiver{"
+                result = "Receiver{"
                         + Integer.toHexString(System.identityHashCode(this))
                         + " Intent " + mKey + "}";
             }
+            result += "mUpdateRecords: " + mUpdateRecords;
+            return result;
         }
 
         public boolean isListener() {
@@ -1004,7 +1007,7 @@
         public String toString() {
             return "UpdateRecord{"
                     + Integer.toHexString(System.identityHashCode(this))
-                    + " " + mProvider + " " + mReceiver + "}";
+                    + " mProvider: " + mProvider + " mUid: " + mUid + "}";
         }
         
         void dump(PrintWriter pw, String prefix) {
@@ -1119,9 +1122,6 @@
 
     private void requestLocationUpdatesLocked(String provider, long minTime, float minDistance,
             boolean singleShot, Receiver receiver) {
-        if (LOCAL_LOGV) {
-            Slog.v(TAG, "_requestLocationUpdates: listener = " + receiver);
-        }
 
         LocationProviderInterface p = mProvidersByName.get(provider);
         if (p == null) {
@@ -1159,6 +1159,9 @@
                 // Notify the listener that updates are currently disabled
                 receiver.callProviderEnabledLocked(provider, false);
             }
+            if (LOCAL_LOGV) {
+                Slog.v(TAG, "_requestLocationUpdates: provider = " + provider + " listener = " + receiver);
+            }
         } finally {
             Binder.restoreCallingIdentity(identity);
         }
diff --git a/services/java/com/android/server/PowerManagerService.java b/services/java/com/android/server/PowerManagerService.java
index b90b4bf..638bd45 100644
--- a/services/java/com/android/server/PowerManagerService.java
+++ b/services/java/com/android/server/PowerManagerService.java
@@ -1971,8 +1971,8 @@
                     / stepsToTarget;
             if (mSpew) {
                 String noticeMe = nominalCurrentValue == curValue ? "" : "  ******************";
-                Slog.i(TAG, "Setting target " + mask + ": cur=" + curValue
-                        + " target=" + targetValue + " delta=" + delta
+                Slog.i(TAG, "setTargetLocked mask=" + mask + " curValue=" + curValue
+                        + " target=" + target + " targetValue=" + targetValue + " delta=" + delta
                         + " nominalCurrentValue=" + nominalCurrentValue
                         + noticeMe);
             }
@@ -2010,20 +2010,20 @@
             }
             if (mSpew) Slog.d(TAG, "Animating curIntValue=" + curIntValue + ": " + mask);
             setLightBrightness(mask, curIntValue);
-            finishAnimation(more, curIntValue);
+            finishAnimationLocked(more, curIntValue);
             return more;
         }
 
-        void jumpToTarget() {
-            if (mSpew) Slog.d(TAG, "jumpToTarget targetValue=" + targetValue + ": " + mask);
+        void jumpToTargetLocked() {
+            if (mSpew) Slog.d(TAG, "jumpToTargetLocked targetValue=" + targetValue + ": " + mask);
             setLightBrightness(mask, targetValue);
             final int tv = targetValue;
             curValue = tv;
             targetValue = -1;
-            finishAnimation(false, tv);
+            finishAnimationLocked(false, tv);
         }
 
-        private void finishAnimation(boolean more, int curIntValue) {
+        private void finishAnimationLocked(boolean more, int curIntValue) {
             animating = more;
             if (!more) {
                 if (mask == SCREEN_BRIGHT_BIT && curIntValue == Power.BRIGHTNESS_OFF) {
@@ -2042,21 +2042,18 @@
                     }
                 }
             } else {
-                boolean animate;
-                boolean jump;
                 synchronized (mLocks) {
-                    jump = animating; // we haven't already run this animation
-                    animate = jump && targetValue == Power.BRIGHTNESS_OFF; // we're turning off
+                    // we're turning off
+                    final boolean animate = animating && targetValue == Power.BRIGHTNESS_OFF;
+                    if (animate) {
+                        // It's pretty scary to hold mLocks for this long, and we should
+                        // redesign this, but it works for now.
+                        nativeStartSurfaceFlingerAnimation(
+                                mScreenOffReason == WindowManagerPolicy.OFF_BECAUSE_OF_PROX_SENSOR
+                                ? 0 : mAnimationSetting);
+                    }
+                    mScreenBrightness.jumpToTargetLocked();
                 }
-                if (animate) {
-                    // TODO: I think it's possible that if you sleep & wake multiple times
-                    // quickly for different reasons, mScreenOffReason for the first animation
-                    // might get stomped on as it starts the second animation.
-                    nativeStartSurfaceFlingerAnimation(
-                            mScreenOffReason == WindowManagerPolicy.OFF_BECAUSE_OF_PROX_SENSOR
-                            ? 0 : mAnimationSetting);
-                }
-                mScreenBrightness.jumpToTarget();
             }
         }
     }
@@ -2785,8 +2782,10 @@
             }
 
             // update our animation state
-            mScreenBrightness.targetValue = brightness;
-            mScreenBrightness.jumpToTarget();
+            synchronized (mLocks) {
+                mScreenBrightness.targetValue = brightness;
+                mScreenBrightness.jumpToTargetLocked();
+            }
         }
     }
 
diff --git a/services/java/com/android/server/location/GpsLocationProvider.java b/services/java/com/android/server/location/GpsLocationProvider.java
index f9c1679..4a6b5f4 100755
--- a/services/java/com/android/server/location/GpsLocationProvider.java
+++ b/services/java/com/android/server/location/GpsLocationProvider.java
@@ -82,7 +82,7 @@
 
     private static final String TAG = "GpsLocationProvider";
 
-    private static final boolean DEBUG = false;
+    private static final boolean DEBUG = true;
     private static final boolean VERBOSE = false;
 
     // these need to match GpsPositionMode enum in gps.h
@@ -1113,7 +1113,7 @@
      * called from native code to update our status
      */
     private void reportStatus(int status) {
-        if (VERBOSE) Log.v(TAG, "reportStatus status: " + status);
+        if (DEBUG) Log.v(TAG, "reportStatus status: " + status);
 
         synchronized(mListeners) {
             boolean wasNavigating = mNavigating;
@@ -1240,6 +1240,7 @@
                 int result = mConnMgr.startUsingNetworkFeature(
                         ConnectivityManager.TYPE_MOBILE, Phone.FEATURE_ENABLE_SUPL);
                 if (result == Phone.APN_ALREADY_ACTIVE) {
+                    if (DEBUG) Log.d(TAG, "Phone.APN_ALREADY_ACTIVE");
                     if (mAGpsApn != null) {
                         native_agps_data_conn_open(mAGpsApn);
                         mAGpsDataConnectionState = AGPS_DATA_CONNECTION_OPEN;
@@ -1249,8 +1250,10 @@
                         native_agps_data_conn_failed();
                     }
                 } else if (result == Phone.APN_REQUEST_STARTED) {
+                    if (DEBUG) Log.d(TAG, "Phone.APN_ALREADYAPN_REQUEST_STARTED_ACTIVE");
                     // Nothing to do here
                 } else {
+                    if (DEBUG) Log.d(TAG, "startUsingNetworkFeature failed");
                     mAGpsDataConnectionState = AGPS_DATA_CONNECTION_CLOSED;
                     native_agps_data_conn_failed();
                 }
diff --git a/services/jni/com_android_server_location_GpsLocationProvider.cpp b/services/jni/com_android_server_location_GpsLocationProvider.cpp
index 1d93f82..f5e17f5 100755
--- a/services/jni/com_android_server_location_GpsLocationProvider.cpp
+++ b/services/jni/com_android_server_location_GpsLocationProvider.cpp
@@ -16,7 +16,7 @@
 
 #define LOG_TAG "GpsLocationProvider"
 
-//#define LOG_NDEBUG 0
+#define LOG_NDEBUG 0
 
 #include "JNIHelp.h"
 #include "jni.h"
@@ -106,6 +106,7 @@
 
 static void set_capabilities_callback(uint32_t capabilities)
 {
+    LOGD("set_capabilities_callback: %ld\n", capabilities);
     JNIEnv* env = AndroidRuntime::getJNIEnv();
     env->CallVoidMethod(mCallbacksObj, method_setEngineCapabilities, capabilities);
     checkAndClearExceptionFromCallback(env, __FUNCTION__);
diff --git a/voip/java/android/net/sip/SipManager.java b/voip/java/android/net/sip/SipManager.java
index ee0e3cd..2f03e34 100644
--- a/voip/java/android/net/sip/SipManager.java
+++ b/voip/java/android/net/sip/SipManager.java
@@ -126,22 +126,16 @@
      * Returns true if the SIP API is supported by the system.
      */
     public static boolean isApiSupported(Context context) {
-        return true;
-        /* TODO: uncomment this before ship
         return context.getPackageManager().hasSystemFeature(
                 PackageManager.FEATURE_SIP);
-         */
     }
 
     /**
      * Returns true if the system supports SIP-based VoIP.
      */
     public static boolean isVoipSupported(Context context) {
-        return true;
-        /* TODO: uncomment this before ship
         return context.getPackageManager().hasSystemFeature(
                 PackageManager.FEATURE_SIP_VOIP) && isApiSupported(context);
-         */
     }
 
     /**
diff --git a/voip/java/com/android/server/sip/SipSessionGroup.java b/voip/java/com/android/server/sip/SipSessionGroup.java
index d861fa5..578bd9b 100644
--- a/voip/java/com/android/server/sip/SipSessionGroup.java
+++ b/voip/java/com/android/server/sip/SipSessionGroup.java
@@ -82,6 +82,11 @@
     private static final boolean DEBUG = true;
     private static final boolean DEBUG_PING = DEBUG && false;
     private static final String ANONYMOUS = "anonymous";
+    // Limit the size of thread pool to 1 for the order issue when the phone is
+    // waken up from sleep and there are many packets to be processed in the SIP
+    // stack. Note: The default thread pool size in NIST SIP stack is -1 which is
+    // unlimited.
+    private static final String THREAD_POOL_SIZE = "1";
     private static final int EXPIRY_TIME = 3600; // in seconds
     private static final int CANCEL_CALL_TIMER = 3; // in seconds
     private static final long WAKE_LOCK_HOLDING_TIME = 500; // in milliseconds
@@ -129,6 +134,7 @@
         SipFactory sipFactory = SipFactory.getInstance();
         Properties properties = new Properties();
         properties.setProperty("javax.sip.STACK_NAME", getStackName());
+        properties.setProperty("javax.sip.THREAD_POOL_SIZE", THREAD_POOL_SIZE);
         String outboundProxy = myself.getProxyAddress();
         if (!TextUtils.isEmpty(outboundProxy)) {
             Log.v(TAG, "outboundProxy is " + outboundProxy);