Merge "Revert "Refactor WifiScanner support for oneshot scans"" into mm-wireless-dev

8 files changed, 134 insertions, 642 deletions

diff --git a/tests/wifitests/src/com/android/server/wifi/BaseWifiScannerImplTest.java b/tests/wifitests/src/com/android/server/wifi/BaseWifiScannerImplTest.java
index 9a21843f4..0ff439152 100644
--- a/tests/wifitests/src/com/android/server/wifi/BaseWifiScannerImplTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/BaseWifiScannerImplTest.java
@@ -25,6 +25,7 @@ import static com.android.server.wifi.ScanTestUtil.setupMockChannels;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.anyInt;
 import static org.mockito.Mockito.eq;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
@@ -139,7 +140,7 @@ public abstract class BaseWifiScannerImplTest {
         WifiNative.ScanEventHandler eventHandler2 = mock(WifiNative.ScanEventHandler.class);
 
         // scan start succeeds
-        when(mWifiNative.scan(any(Set.class))).thenReturn(true);
+        when(mWifiNative.scan(anyInt(), any(Set.class))).thenReturn(true);
 
         assertTrue(mScanner.startSingleScan(settings, eventHandler));
         assertFalse("second scan while first scan running should fail immediately",
@@ -163,13 +164,12 @@ public abstract class BaseWifiScannerImplTest {
         InOrder order = inOrder(eventHandler, mWifiNative);
 
         // scan fails
-        when(mWifiNative.scan(any(Set.class))).thenReturn(false);
+        when(mWifiNative.scan(anyInt(), any(Set.class))).thenReturn(false);
 
         // start scan
         assertTrue(mScanner.startSingleScan(settings, eventHandler));
 
-        mLooper.dispatchAll();
-        order.verify(eventHandler).onScanStatus(WifiNative.WIFI_SCAN_DISABLED);
+        // TODO expect failure callback once implemented
 
         verifyNoMoreInteractions(eventHandler);
     }
@@ -213,7 +213,7 @@ public abstract class BaseWifiScannerImplTest {
         InOrder order = inOrder(eventHandler, mWifiNative);
 
         // scans succeed
-        when(mWifiNative.scan(any(Set.class))).thenReturn(true);
+        when(mWifiNative.scan(anyInt(), any(Set.class))).thenReturn(true);
 
         // start first scan
         assertTrue(mScanner.startSingleScan(settings, eventHandler));
@@ -257,7 +257,7 @@ public abstract class BaseWifiScannerImplTest {
         InOrder order = inOrder(eventHandler, mWifiNative);
 
         // scan succeeds
-        when(mWifiNative.scan(any(Set.class))).thenReturn(true);
+        when(mWifiNative.scan(anyInt(), any(Set.class))).thenReturn(true);
 
         // start scan
         assertTrue(mScanner.startSingleScan(settings, eventHandler));
@@ -270,7 +270,8 @@ public abstract class BaseWifiScannerImplTest {
     protected void expectSuccessfulSingleScan(InOrder order,
             WifiNative.ScanEventHandler eventHandler, Set<Integer> expectedScan,
             ScanResults results, boolean expectFullResults) {
-        order.verify(mWifiNative).scan(eq(expectedScan));
+        order.verify(mWifiNative).scan(eq(WifiNative.SCAN_WITHOUT_CONNECTION_SETUP),
+                eq(expectedScan));
 
         when(mWifiNative.getScanResults()).thenReturn(results.getScanDetailArrayList());
 
@@ -285,7 +286,7 @@ public abstract class BaseWifiScannerImplTest {
             }
         }
 
-        order.verify(eventHandler).onScanStatus(WifiNative.WIFI_SCAN_RESULTS_AVAILABLE);
+        order.verify(eventHandler).onScanResultsAvailable();
         assertScanDataEquals(results.getScanData(), mScanner.getLatestSingleScanResults());
     }
 }
diff --git a/tests/wifitests/src/com/android/server/wifi/HalWifiScannerTest.java b/tests/wifitests/src/com/android/server/wifi/HalWifiScannerTest.java
index d253ff723..162fc2c0c 100644
--- a/tests/wifitests/src/com/android/server/wifi/HalWifiScannerTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/HalWifiScannerTest.java
@@ -16,10 +16,13 @@
 
 package com.android.server.wifi;
 
+import android.os.Handler;
 import android.test.suitebuilder.annotation.SmallTest;
 
 import org.junit.Before;
 
+import java.lang.reflect.Field;
+
 /**
  * Unit tests for {@link com.android.server.wifi.HalWifiScannerImpl}.
  */
@@ -29,5 +32,14 @@ public class HalWifiScannerTest extends BaseWifiScannerImplTest {
     @Before
     public void setUp() throws Exception {
         mScanner = new HalWifiScannerImpl(WifiNative.getWlanNativeInterface(), mLooper.getLooper());
+
+        // TODO remove this once HalWifiScannerImpl wifi monitor registration is enabled
+        Field eventHandlerField = HalWifiScannerImpl.class.getDeclaredField("mEventHandler");
+        eventHandlerField.setAccessible(true);
+        Handler eventHandler = (Handler) eventHandlerField.get(mScanner);
+        WifiMonitor.getInstance().registerHandler(mWifiNative.getInterfaceName(),
+                WifiMonitor.SCAN_FAILED_EVENT, eventHandler);
+        WifiMonitor.getInstance().registerHandler(mWifiNative.getInterfaceName(),
+                WifiMonitor.SCAN_RESULTS_EVENT, eventHandler);
     }
 }
diff --git a/tests/wifitests/src/com/android/server/wifi/MultiClientSchedulerTest.java b/tests/wifitests/src/com/android/server/wifi/MultiClientSchedulerTest.java
index 94ce31d38..97da4a473 100644
--- a/tests/wifitests/src/com/android/server/wifi/MultiClientSchedulerTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/MultiClientSchedulerTest.java
@@ -16,8 +16,6 @@
 
 package com.android.server.wifi;
 
-import static com.android.server.wifi.ScanTestUtil.NativeScanSettingsBuilder;
-import static com.android.server.wifi.ScanTestUtil.assertNativeScanSettingsEquals;
 import static com.android.server.wifi.ScanTestUtil.channelsToSpec;
 import static com.android.server.wifi.ScanTestUtil.createRequest;
 import static com.android.server.wifi.ScanTestUtil.getAllChannels;
@@ -46,6 +44,7 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
+import java.util.Set;
 
 /**
  * Unit tests for {@link com.android.server.wifi.MultiClientScheduler}.
@@ -460,23 +459,43 @@ public class MultiClientSchedulerTest {
         mScheduler.updateSchedule(requests);
         WifiNative.ScanSettings schedule = mScheduler.getSchedule();
 
-        int expectedPeriod = computeExpectedPeriod(settings.periodInMs);
-        NativeScanSettingsBuilder expectedBuilder = new NativeScanSettingsBuilder()
-                .withBasePeriod(expectedPeriod)
-                .withMaxApPerScan(settings.numBssidsPerScan == 0
-                        ? DEFAULT_MAX_AP_PER_SCAN
-                        : settings.numBssidsPerScan)
-                .withMaxScansToCache(settings.maxScansToCache == 0
-                        ? DEFAULT_MAX_BATCH
-                        : settings.maxScansToCache);
+        assertEquals("base_period_ms", computeExpectedPeriod(settings.periodInMs),
+                schedule.base_period_ms);
+        assertBuckets(schedule, 1);
 
-        if (settings.band == WifiScanner.WIFI_BAND_UNSPECIFIED) {
-            expectedBuilder.addBucketWithChannels(expectedPeriod, settings.reportEvents,
-                    getAllChannels(settings));
+        if (settings.numBssidsPerScan == 0) {
+            assertEquals("bssids per scan", DEFAULT_MAX_AP_PER_SCAN, schedule.max_ap_per_scan);
         } else {
-            expectedBuilder.addBucketWithBand(expectedPeriod, settings.reportEvents, settings.band);
+            assertEquals("bssids per scan", settings.numBssidsPerScan, schedule.max_ap_per_scan);
+        }
+        if (settings.maxScansToCache == 0) {
+            assertEquals("scans to cache", DEFAULT_MAX_BATCH,
+                    schedule.report_threshold_num_scans);
+        } else {
+            assertEquals("scans to cache", settings.maxScansToCache,
+                    schedule.report_threshold_num_scans);
+        }
+        assertEquals("reportEvents", settings.reportEvents, schedule.buckets[0].report_events);
+        assertEquals("period", computeExpectedPeriod(settings.periodInMs),
+                schedule.buckets[0].period_ms);
+        if (settings.band == WifiScanner.WIFI_BAND_UNSPECIFIED) {
+            assertEquals("band", settings.band, schedule.buckets[0].band);
+            Set<Integer> expectedChannels = new HashSet<>();
+            for (ChannelSpec channel : getAllChannels(settings)) {
+                expectedChannels.add(channel.frequency);
+            }
+            Set<Integer> actualChannels = new HashSet<>();
+            for (ChannelSpec channel : getAllChannels(schedule.buckets[0])) {
+                actualChannels.add(channel.frequency);
+            }
+            assertEquals("channels", expectedChannels, actualChannels);
+        }
+        else {
+            assertEquals("band", settings.band, schedule.buckets[0].band);
+            assertEquals("num_channels", 0, schedule.buckets[0].num_channels);
+            assertTrue("channels", schedule.buckets[0].channels == null
+                    || schedule.buckets[0].channels.length == 0);
         }
-        assertNativeScanSettingsEquals(expectedBuilder.build(), schedule);
     }
 
     private void assertBuckets(WifiNative.ScanSettings schedule, int numBuckets) {
diff --git a/tests/wifitests/src/com/android/server/wifi/ScanResults.java b/tests/wifitests/src/com/android/server/wifi/ScanResults.java
index b6007b26c..d418451fc 100644
--- a/tests/wifitests/src/com/android/server/wifi/ScanResults.java
+++ b/tests/wifitests/src/com/android/server/wifi/ScanResults.java
@@ -28,9 +28,7 @@ import java.math.BigInteger;
 import java.nio.charset.Charset;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collections;
 import java.util.Comparator;
-import java.util.List;
 import java.util.Random;
 
 /**
@@ -41,29 +39,6 @@ public class ScanResults {
     private final ScanData mScanData;
     private final ScanResult[] mScanResults;
 
-    private ScanResults(ArrayList<ScanDetail> scanDetails, ScanData scanData,
-            ScanResult[] scanResults) {
-        mScanDetails.addAll(scanDetails);
-        mScanData = scanData;
-        mScanResults = scanResults;
-    }
-
-    public static ScanResults merge(ScanResults... others) {
-        ArrayList<ScanDetail> scanDetails = new ArrayList<>();
-        ArrayList<ScanResult> scanDataResults = new ArrayList<>();
-        ArrayList<ScanResult> rawScanResults = new ArrayList<>();
-        for (ScanResults other : others) {
-            scanDetails.addAll(other.getScanDetailArrayList());
-            scanDataResults.addAll(Arrays.asList(other.getScanData().getResults()));
-            rawScanResults.addAll(Arrays.asList(other.getRawScanResults()));
-        }
-        Collections.sort(scanDataResults, SCAN_RESULT_RSSI_COMPARATOR);
-        int id = others[0].getScanData().getId();
-        return new ScanResults(scanDetails, new ScanData(id, 0, scanDataResults
-                        .toArray(new ScanResult[scanDataResults.size()])),
-                rawScanResults.toArray(new ScanResult[rawScanResults.size()]));
-    }
-
     private static String generateBssid(Random r) {
         return String.format("%02X:%02X:%02X:%02X:%02X:%02X",
                 r.nextInt(256), r.nextInt(256), r.nextInt(256),
@@ -127,14 +102,11 @@ public class ScanResults {
             int rssi = r.nextInt(40) - 99; // -99 to -60
             ScanResult.InformationElement ie[] = new ScanResult.InformationElement[1];
             ie[0] = generateSsidIe(ssid);
-            List<String> anqpLines = new ArrayList<>();
-            NetworkDetail nd = new NetworkDetail(bssid, ie, anqpLines, freq);
+            NetworkDetail nd = new NetworkDetail(bssid, ie, new ArrayList<String>(), freq);
             ScanDetail detail = new ScanDetail(nd, WifiSsid.createFromAsciiEncoded(ssid),
                     bssid, "", rssi, freq,
                     Long.MAX_VALUE); /* needed so that scan results aren't rejected because
                                         there older than scan start */
-            detail.getScanResult().informationElements = ie;
-            detail.getScanResult().anqpLines = anqpLines;
             results[i] = detail;
         }
         return results;
diff --git a/tests/wifitests/src/com/android/server/wifi/ScanTestUtil.java b/tests/wifitests/src/com/android/server/wifi/ScanTestUtil.java
index cc583e420..3b06c0386 100644
--- a/tests/wifitests/src/com/android/server/wifi/ScanTestUtil.java
+++ b/tests/wifitests/src/com/android/server/wifi/ScanTestUtil.java
@@ -18,7 +18,6 @@ package com.android.server.wifi;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.when;
 
 import android.net.wifi.ScanResult;
@@ -28,6 +27,8 @@ import android.net.wifi.WifiScanner.ScanData;
 import android.net.wifi.WifiScanner.ScanSettings;
 import android.net.wifi.WifiSsid;
 
+import com.android.server.wifi.WifiNative.BucketSettings;
+
 import java.lang.reflect.Field;
 import java.util.Arrays;
 import java.util.HashSet;
@@ -114,10 +115,6 @@ public class ScanTestUtil {
             mSettings.report_threshold_num_scans = maxScans;
             return this;
         }
-        public NativeScanSettingsBuilder withMaxPercentToCache(int percent) {
-            mSettings.report_threshold_percent = percent;
-            return this;
-        }
 
         public NativeScanSettingsBuilder addBucketWithBand(
                 int period, int reportEvents, int band) {
@@ -131,11 +128,6 @@ public class ScanTestUtil {
 
         public NativeScanSettingsBuilder addBucketWithChannels(
                 int period, int reportEvents, int... channels) {
-            return addBucketWithChannels(period, reportEvents, channelsToSpec(channels));
-        }
-
-        public NativeScanSettingsBuilder addBucketWithChannels(
-                int period, int reportEvents, ChannelSpec... channels) {
             WifiNative.BucketSettings bucket = new WifiNative.BucketSettings();
             bucket.bucket = mSettings.num_buckets;
             bucket.band = WifiScanner.WIFI_BAND_UNSPECIFIED;
@@ -143,7 +135,7 @@ public class ScanTestUtil {
             bucket.channels = new WifiNative.ChannelSettings[channels.length];
             for (int i = 0; i < channels.length; ++i) {
                 bucket.channels[i] = new WifiNative.ChannelSettings();
-                bucket.channels[i].frequency = channels[i].frequency;
+                bucket.channels[i].frequency = channels[i];
             }
             bucket.period_ms = period;
             bucket.report_events = reportEvents;
@@ -162,26 +154,6 @@ public class ScanTestUtil {
         }
     }
 
-    public static WifiNative.ScanSettings computeSingleScanNativeSettings(
-            WifiScanner.ScanSettings requestSettings) {
-        return createSingleScanNativeSettings(requestSettings.reportEvents,
-                getAllChannels(requestSettings));
-    }
-
-    public static WifiNative.ScanSettings createSingleScanNativeSettings(
-            int reportEvents, ChannelSpec... channels) {
-        // TODO requests using bands  should be scheduled using the band, but are currently
-        // converted to channels before scheduling. This should probably change
-        return new NativeScanSettingsBuilder()
-                .withBasePeriod(0)
-                .withMaxApPerScan(0)
-                .withMaxPercentToCache(0)
-                .withMaxScansToCache(0)
-                .addBucketWithChannels(0,
-                        reportEvents | WifiScanner.REPORT_EVENT_AFTER_EACH_SCAN, channels)
-                .build();
-    }
-
     public static Set<Integer> createFreqSet(int... elements) {
         Set<Integer> set = new HashSet<>();
         for (int e : elements) {
@@ -265,46 +237,7 @@ public class ScanTestUtil {
         return channelSpecs;
     }
 
-    public static void assertNativeScanSettingsEquals(WifiNative.ScanSettings expected,
-            WifiNative.ScanSettings actual) {
-        assertEquals("bssids per scan", expected.max_ap_per_scan, actual.max_ap_per_scan);
-        assertEquals("scans to cache", expected.report_threshold_num_scans,
-                actual.report_threshold_num_scans);
-        assertEquals("percent to cache", expected.report_threshold_percent,
-                actual.report_threshold_percent);
-        assertEquals("base period", expected.base_period_ms, actual.base_period_ms);
-
-        assertEquals("number of buckets", expected.num_buckets, actual.num_buckets);
-        assertNotNull("buckets was null", actual.buckets);
-        for (int i = 0; i < expected.buckets.length; ++i) {
-            assertNotNull("buckets[" + i + "] was null", actual.buckets[i]);
-            assertEquals("buckets[" + i + "].period",
-                    expected.buckets[i].period_ms, actual.buckets[i].period_ms);
-            assertEquals("buckets[" + i + "].reportEvents",
-                    expected.buckets[i].report_events, actual.buckets[i].report_events);
-
-            assertEquals("buckets[" + i + "].band",
-                    expected.buckets[i].band, actual.buckets[i].band);
-            if (expected.buckets[i].band == WifiScanner.WIFI_BAND_UNSPECIFIED) {
-                Set<Integer> expectedChannels = new HashSet<>();
-                for (ChannelSpec channel : getAllChannels(expected.buckets[i])) {
-                    expectedChannels.add(channel.frequency);
-                }
-                Set<Integer> actualChannels = new HashSet<>();
-                for (ChannelSpec channel : getAllChannels(actual.buckets[i])) {
-                    actualChannels.add(channel.frequency);
-                }
-                assertEquals("channels", expectedChannels, actualChannels);
-            } else {
-                assertEquals("buckets[" + i + "].num_channels", 0, actual.buckets[i].num_channels);
-                assertTrue("buckets[" + i + "].channels",
-                        actual.buckets[i].channels == null
-                        || actual.buckets[i].channels.length == 0);
-            }
-        }
-    }
-
-    public static ChannelSpec[] getAllChannels(WifiNative.BucketSettings bucket) {
+    public static ChannelSpec[] getAllChannels(BucketSettings bucket) {
         if (bucket.band == WifiScanner.WIFI_BAND_UNSPECIFIED) {
             ChannelSpec[] channels = new ChannelSpec[bucket.num_channels];
             for (int i = 0; i < bucket.num_channels; i++) {
diff --git a/tests/wifitests/src/com/android/server/wifi/SupplicantWifiScannerTest.java b/tests/wifitests/src/com/android/server/wifi/SupplicantWifiScannerTest.java
index 94b9dc330..b08e52dc8 100644
--- a/tests/wifitests/src/com/android/server/wifi/SupplicantWifiScannerTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/SupplicantWifiScannerTest.java
@@ -22,6 +22,7 @@ import static com.android.server.wifi.ScanTestUtil.createFreqSet;
 
 import static org.junit.Assert.assertEquals;
 import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.anyInt;
 import static org.mockito.Mockito.eq;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
@@ -31,12 +32,14 @@ import static org.mockito.Mockito.when;
 import android.net.wifi.ScanResult;
 import android.net.wifi.WifiScanner;
 import android.net.wifi.WifiSsid;
+import android.os.Handler;
 import android.test.suitebuilder.annotation.SmallTest;
 
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.InOrder;
 
+import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.Set;
 
@@ -50,6 +53,15 @@ public class SupplicantWifiScannerTest extends BaseWifiScannerImplTest {
     public void setup() throws Exception {
         mScanner = new SupplicantWifiScannerImpl(mContext, WifiNative.getWlanNativeInterface(),
                 mLooper.getLooper());
+
+        // TODO remove this once SupplicantWifiScannerImpl wifi monitor registration is enabled
+        Field eventHandlerField = SupplicantWifiScannerImpl.class.getDeclaredField("mEventHandler");
+        eventHandlerField.setAccessible(true);
+        Handler eventHandler = (Handler) eventHandlerField.get(mScanner);
+        WifiMonitor.getInstance().registerHandler(mWifiNative.getInterfaceName(),
+                WifiMonitor.SCAN_FAILED_EVENT, eventHandler);
+        WifiMonitor.getInstance().registerHandler(mWifiNative.getInterfaceName(),
+                WifiMonitor.SCAN_RESULTS_EVENT, eventHandler);
     }
 
     @Test
@@ -320,7 +332,7 @@ public class SupplicantWifiScannerTest extends BaseWifiScannerImplTest {
         InOrder order = inOrder(eventHandler, mWifiNative);
 
         // All scans fail
-        when(mWifiNative.scan(any(Set.class))).thenReturn(false);
+        when(mWifiNative.scan(anyInt(), any(Set.class))).thenReturn(false);
 
         // Start scan
         mScanner.startBatchedScan(settings, eventHandler);
@@ -355,7 +367,7 @@ public class SupplicantWifiScannerTest extends BaseWifiScannerImplTest {
         InOrder order = inOrder(eventHandler, mWifiNative);
 
         // All scan starts succeed
-        when(mWifiNative.scan(any(Set.class))).thenReturn(true);
+        when(mWifiNative.scan(anyInt(), any(Set.class))).thenReturn(true);
 
         // Start scan
         mScanner.startBatchedScan(settings, eventHandler);
@@ -400,7 +412,7 @@ public class SupplicantWifiScannerTest extends BaseWifiScannerImplTest {
         InOrder order = inOrder(eventHandler, mWifiNative);
 
         // All scan starts succeed
-        when(mWifiNative.scan(any(Set.class))).thenReturn(true);
+        when(mWifiNative.scan(anyInt(), any(Set.class))).thenReturn(true);
 
         // Start scan
         mScanner.startBatchedScan(settings, eventHandler);
@@ -455,7 +467,7 @@ public class SupplicantWifiScannerTest extends BaseWifiScannerImplTest {
         InOrder order = inOrder(eventHandler, mWifiNative);
 
         // All scan starts succeed
-        when(mWifiNative.scan(any(Set.class))).thenReturn(true);
+        when(mWifiNative.scan(anyInt(), any(Set.class))).thenReturn(true);
 
         // Start scan
         mScanner.startBatchedScan(settings, eventHandler);
@@ -465,7 +477,8 @@ public class SupplicantWifiScannerTest extends BaseWifiScannerImplTest {
         // alarm for next period
         assertEquals(1, mAlarmManager.getPendingCount());
 
-        order.verify(mWifiNative).scan(eq(expectedPeriods[0].getScanFreqs()));
+        order.verify(mWifiNative).scan(eq(WifiNative.SCAN_WITHOUT_CONNECTION_SETUP),
+                eq(expectedPeriods[0].getScanFreqs()));
 
         mScanner.pauseBatchedScan();
 
@@ -531,7 +544,7 @@ public class SupplicantWifiScannerTest extends BaseWifiScannerImplTest {
         InOrder order = inOrder(eventHandler, mWifiNative);
 
         // All scan starts succeed
-        when(mWifiNative.scan(any(Set.class))).thenReturn(true);
+        when(mWifiNative.scan(anyInt(), any(Set.class))).thenReturn(true);
 
         // Start scan
         mScanner.startBatchedScan(settings, eventHandler);
@@ -570,7 +583,7 @@ public class SupplicantWifiScannerTest extends BaseWifiScannerImplTest {
         InOrder order = inOrder(eventHandler, mWifiNative);
 
         // All scans succeed
-        when(mWifiNative.scan(any(Set.class))).thenReturn(true);
+        when(mWifiNative.scan(anyInt(), any(Set.class))).thenReturn(true);
 
         // Start scan
         mScanner.startBatchedScan(settings, eventHandler);
@@ -630,7 +643,7 @@ public class SupplicantWifiScannerTest extends BaseWifiScannerImplTest {
             ArrayList<ScanDetail> nativeResults, WifiScanner.ScanData[] expectedScanResults,
             ScanResult[] fullResults, int periodId) {
         // Verify scan started
-        order.verify(mWifiNative).scan(eq(scanFreqs));
+        order.verify(mWifiNative).scan(eq(WifiNative.SCAN_WITHOUT_CONNECTION_SETUP), eq(scanFreqs));
 
         // Setup scan results
         when(mWifiNative.getScanResults()).thenReturn(nativeResults);
@@ -647,7 +660,7 @@ public class SupplicantWifiScannerTest extends BaseWifiScannerImplTest {
 
         if (expectedScanResults != null) {
             // Verify scan results delivered
-            order.verify(eventHandler).onScanStatus(WifiNative.WIFI_SCAN_RESULTS_AVAILABLE);
+            order.verify(eventHandler).onScanStatus();
             assertScanDatasEquals("period[" + periodId + "].", expectedScanResults,
                     mScanner.getLatestBatchedScanResults(true));
         }
@@ -656,26 +669,22 @@ public class SupplicantWifiScannerTest extends BaseWifiScannerImplTest {
     private void expectFailedScanStart(InOrder order, WifiNative.ScanEventHandler eventHandler,
             Set<Integer> scanFreqs) {
         // Verify scan started
-        order.verify(mWifiNative).scan(eq(scanFreqs));
-
-        // TODO verify failure event
+        order.verify(mWifiNative).scan(eq(WifiNative.SCAN_WITHOUT_CONNECTION_SETUP), eq(scanFreqs));
     }
 
     private void expectFailedEventScan(InOrder order, WifiNative.ScanEventHandler eventHandler,
             Set<Integer> scanFreqs) {
         // Verify scan started
-        order.verify(mWifiNative).scan(eq(scanFreqs));
+        order.verify(mWifiNative).scan(eq(WifiNative.SCAN_WITHOUT_CONNECTION_SETUP), eq(scanFreqs));
 
         // Notify scan has failed
         mWifiMonitor.sendMessage(mWifiNative.getInterfaceName(), WifiMonitor.SCAN_FAILED_EVENT);
         assertEquals("dispatch message after results event", 1, mLooper.dispatchAll());
-
-        // TODO verify failure event
     }
 
     private void dispatchOnlyAlarm() {
         assertEquals("dispatch only one alarm", 1, mAlarmManager.dispatchAll());
-        mLooper.dispatchAll();
+        assertEquals("dispatch only one message", 1, mLooper.dispatchAll());
     }
 
     private static class ScanPeriod {
diff --git a/tests/wifitests/src/com/android/server/wifi/WifiScanningServiceTest.java b/tests/wifitests/src/com/android/server/wifi/WifiScanningServiceTest.java
index 42d89525a..4093936b6 100644
--- a/tests/wifitests/src/com/android/server/wifi/WifiScanningServiceTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/WifiScanningServiceTest.java
@@ -16,21 +16,12 @@
 
 package com.android.server.wifi;
 
-import static com.android.server.wifi.ScanTestUtil.NativeScanSettingsBuilder;
-import static com.android.server.wifi.ScanTestUtil.assertNativeScanSettingsEquals;
-import static com.android.server.wifi.ScanTestUtil.assertScanDatasEquals;
-import static com.android.server.wifi.ScanTestUtil.channelsToSpec;
-import static com.android.server.wifi.ScanTestUtil.computeSingleScanNativeSettings;
 import static com.android.server.wifi.ScanTestUtil.createRequest;
-import static com.android.server.wifi.ScanTestUtil.createSingleScanNativeSettings;
 import static com.android.server.wifi.ScanTestUtil.installWlanWifiNative;
 import static com.android.server.wifi.ScanTestUtil.setupMockChannels;
 
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
 import static org.mockito.Mockito.any;
-import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.validateMockitoUsage;
@@ -57,7 +48,6 @@ import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.ArgumentCaptor;
-import org.mockito.InOrder;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
@@ -99,16 +89,13 @@ public class WifiScanningServiceTest {
     }
 
 
-    /**
-     * Internal BroadcastReceiver that WifiScanningServiceImpl uses to listen for broadcasts
-     * this is initialized by calling startServiceAndLoadDriver
-     */
-    BroadcastReceiver mBroadcastReceiver;
+    ArgumentCaptor<BroadcastReceiver> mBroadcastReceiverCaptor =
+            ArgumentCaptor.forClass(BroadcastReceiver.class);
 
     private void sendWifiScanAvailable(int scanAvailable) {
         Intent intent = new Intent(WifiManager.WIFI_SCAN_AVAILABLE);
         intent.putExtra(WifiManager.EXTRA_SCAN_AVAILABLE, scanAvailable);
-        mBroadcastReceiver.onReceive(mContext, intent);
+        mBroadcastReceiverCaptor.getValue().onReceive(mContext, intent);
     }
 
     private WifiScanner.ScanSettings generateValidScanSettings() {
@@ -125,96 +112,45 @@ public class WifiScanningServiceTest {
         return controlChannel;
     }
 
-    private Message verifyHandleMessageAndGetMessage(InOrder order, Handler handler) {
+    private Message sendRequest(BidirectionalAsyncChannel controlChannel, Handler handler,
+            Message msg) {
+        controlChannel.sendMessage(msg);
+        mLooper.dispatchAll();
         ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
-        order.verify(handler).handleMessage(messageCaptor.capture());
+        verify(handler).handleMessage(messageCaptor.capture());
         return messageCaptor.getValue();
     }
 
-    private void verifyScanResultsRecieved(InOrder order, Handler handler, int listenerId,
-            WifiScanner.ScanData... expected) {
-        Message scanResultMessage = verifyHandleMessageAndGetMessage(order, handler);
-        assertScanResultsMessage(listenerId, expected, scanResultMessage);
-    }
-
-    private void assertScanResultsMessage(int listenerId, WifiScanner.ScanData[] expected,
-            Message scanResultMessage) {
-        assertEquals("what", WifiScanner.CMD_SCAN_RESULT, scanResultMessage.what);
-        assertEquals("listenerId", listenerId, scanResultMessage.arg2);
-        assertScanDatasEquals(expected,
-                ((WifiScanner.ParcelableScanData) scanResultMessage.obj).getResults());
-    }
-
-    private void sendBackgroundScanRequest(BidirectionalAsyncChannel controlChannel,
-            int scanRequestId, WifiScanner.ScanSettings settings) {
-        controlChannel.sendMessage(Message.obtain(null, WifiScanner.CMD_START_BACKGROUND_SCAN, 0,
-                        scanRequestId, settings));
-    }
-
-    private void sendSingleScanRequest(BidirectionalAsyncChannel controlChannel,
-            int scanRequestId, WifiScanner.ScanSettings settings) {
-        controlChannel.sendMessage(Message.obtain(null, WifiScanner.CMD_START_SINGLE_SCAN, 0,
-                        scanRequestId, settings));
-    }
-
-    private void verifySuccessfulResponse(InOrder order, Handler handler, int arg2) {
-        Message response = verifyHandleMessageAndGetMessage(order, handler);
-        assertSuccessfulResponse(arg2, response);
-    }
-
-    private void assertSuccessfulResponse(int arg2, Message response) {
-        if (response.what == WifiScanner.CMD_OP_FAILED) {
-            WifiScanner.OperationResult result = (WifiScanner.OperationResult) response.obj;
-            fail("response indicates failure, reason=" + result.reason
-                    + ", description=" + result.description);
-        } else {
-            assertEquals("response.what", WifiScanner.CMD_OP_SUCCEEDED, response.what);
-            assertEquals("response.arg2", arg2, response.arg2);
-        }
+    private void sendAndAssertSuccessfulyBackgroundScan(BidirectionalAsyncChannel controlChannel,
+            Handler handler, int scanRequestId, WifiScanner.ScanSettings settings) {
+        Message response = sendRequest(controlChannel, handler,
+                Message.obtain(null, WifiScanner.CMD_START_BACKGROUND_SCAN, 0, scanRequestId,
+                        settings));
+        assertEquals("response.what", WifiScanner.CMD_OP_SUCCEEDED, response.what);
+        assertEquals("response.arg2", scanRequestId, response.arg2);
+        assertEquals("response.obj", null, response.obj);
     }
 
-    private void verifyFailedResponse(InOrder order, Handler handler, int arg2,
+    private void sendAndAssertFailedBackgroundScan(BidirectionalAsyncChannel controlChannel,
+            Handler handler, int scanRequestId, WifiScanner.ScanSettings settings,
             int expectedErrorReason, String expectedErrorDescription) {
-        Message response = verifyHandleMessageAndGetMessage(order, handler);
-        assertFailedResponse(arg2, expectedErrorReason, expectedErrorDescription, response);
+        Message response = sendRequest(controlChannel, handler,
+                Message.obtain(null, WifiScanner.CMD_START_BACKGROUND_SCAN, 0, scanRequestId,
+                        settings));
+        assertFailedResponse(scanRequestId, expectedErrorReason, expectedErrorDescription,
+                response);
     }
 
     private void assertFailedResponse(int arg2, int expectedErrorReason,
             String expectedErrorDescription, Message response) {
-        if (response.what == WifiScanner.CMD_OP_SUCCEEDED) {
-            fail("response indicates success");
-        } else {
-            assertEquals("response.what", WifiScanner.CMD_OP_FAILED, response.what);
-            assertEquals("response.arg2", arg2, response.arg2);
-            WifiScanner.OperationResult result = (WifiScanner.OperationResult) response.obj;
-            assertEquals("response.obj.reason",
-                    expectedErrorReason, result.reason);
-            assertEquals("response.obj.description",
-                    expectedErrorDescription, result.description);
-        }
+        assertEquals("response.what", WifiScanner.CMD_OP_FAILED, response.what);
+        assertEquals("response.arg2", arg2, response.arg2);
+        assertEquals("response.obj.reason",
+                expectedErrorReason, ((WifiScanner.OperationResult) response.obj).reason);
+        assertEquals("response.obj.description",
+                expectedErrorDescription, ((WifiScanner.OperationResult) response.obj).description);
     }
 
-    private WifiNative.ScanEventHandler verifyStartSingleScan(InOrder order,
-            WifiNative.ScanSettings expected) {
-        ArgumentCaptor<WifiNative.ScanSettings> scanSettingsCaptor =
-                ArgumentCaptor.forClass(WifiNative.ScanSettings.class);
-        ArgumentCaptor<WifiNative.ScanEventHandler> scanEventHandlerCaptor =
-                ArgumentCaptor.forClass(WifiNative.ScanEventHandler.class);
-        order.verify(mWifiScannerImpl).startSingleScan(scanSettingsCaptor.capture(),
-                scanEventHandlerCaptor.capture());
-        assertNativeScanSettingsEquals(expected, scanSettingsCaptor.getValue());
-        return scanEventHandlerCaptor.getValue();
-    }
-
-    private void verifyStartBackgroundScan(InOrder order, WifiNative.ScanSettings expected) {
-        ArgumentCaptor<WifiNative.ScanSettings> scanSettingsCaptor =
-                ArgumentCaptor.forClass(WifiNative.ScanSettings.class);
-        order.verify(mWifiScannerImpl).startBatchedScan(scanSettingsCaptor.capture(),
-                any(WifiNative.ScanEventHandler.class));
-        assertNativeScanSettingsEquals(expected, scanSettingsCaptor.getValue());
-    }
-
-    private static final int MAX_AP_PER_SCAN = 16;
     private void startServiceAndLoadDriver() {
         mWifiScanningServiceImpl.startService();
         when(mWifiScannerImpl.getScanCapabilities(any(WifiNative.ScanCapabilities.class)))
@@ -222,7 +158,7 @@ public class WifiScanningServiceTest {
                         public boolean answer(WifiNative.ScanCapabilities capabilities) {
                             capabilities.max_scan_cache_size = Integer.MAX_VALUE;
                             capabilities.max_scan_buckets = 8;
-                            capabilities.max_ap_cache_per_scan = MAX_AP_PER_SCAN;
+                            capabilities.max_ap_cache_per_scan = 16;
                             capabilities.max_rssi_sample_size = 8;
                             capabilities.max_scan_reporting_threshold = 10;
                             capabilities.max_hotlist_bssids = 0;
@@ -230,12 +166,8 @@ public class WifiScanningServiceTest {
                             return true;
                         }
                     });
-        ArgumentCaptor<BroadcastReceiver> broadcastReceiverCaptor =
-                ArgumentCaptor.forClass(BroadcastReceiver.class);
         verify(mContext)
-                .registerReceiver(broadcastReceiverCaptor.capture(), any(IntentFilter.class));
-        mBroadcastReceiver = broadcastReceiverCaptor.getValue();
-
+                .registerReceiver(mBroadcastReceiverCaptor.capture(), any(IntentFilter.class));
         sendWifiScanAvailable(WifiManager.WIFI_STATE_ENABLED);
         mLooper.dispatchAll();
     }
@@ -253,10 +185,8 @@ public class WifiScanningServiceTest {
 
         Handler handler = mock(Handler.class);
         BidirectionalAsyncChannel controlChannel = connectChannel(handler);
-        InOrder order = inOrder(handler);
-        sendBackgroundScanRequest(controlChannel, 122, generateValidScanSettings());
-        mLooper.dispatchAll();
-        verifyFailedResponse(order, handler, 122, WifiScanner.REASON_UNSPECIFIED, "not available");
+        sendAndAssertFailedBackgroundScan(controlChannel, handler, 122, generateValidScanSettings(),
+                WifiScanner.REASON_UNSPECIFIED, "not available");
     }
 
     @Test
@@ -266,12 +196,10 @@ public class WifiScanningServiceTest {
 
         Handler handler = mock(Handler.class);
         BidirectionalAsyncChannel controlChannel = connectChannel(handler);
-        InOrder order = inOrder(handler);
         when(mWifiScannerImpl.startBatchedScan(any(WifiNative.ScanSettings.class),
                         any(WifiNative.ScanEventHandler.class))).thenReturn(true);
-        sendBackgroundScanRequest(controlChannel, 192, generateValidScanSettings());
-        mLooper.dispatchAll();
-        verifySuccessfulResponse(order, handler, 192);
+        sendAndAssertSuccessfulyBackgroundScan(controlChannel, handler, 192,
+                generateValidScanSettings());
     }
 
     @Test
@@ -280,368 +208,9 @@ public class WifiScanningServiceTest {
 
         Handler handler = mock(Handler.class);
         BidirectionalAsyncChannel controlChannel = connectChannel(handler);
-        InOrder order = inOrder(handler, mWifiScannerImpl);
-        controlChannel.sendMessage(Message.obtain(null, Protocol.BASE_WIFI_MANAGER));
-        mLooper.dispatchAll();
-        verifyFailedResponse(order, handler, 0, WifiScanner.REASON_INVALID_REQUEST,
-                "Invalid request");
-    }
-
-    private void doSuccessfulSingleScan(WifiScanner.ScanSettings requestSettings,
-            WifiNative.ScanSettings nativeSettings, ScanResults results) {
-        int requestId = 12;
-        startServiceAndLoadDriver();
-
-        Handler handler = mock(Handler.class);
-        BidirectionalAsyncChannel controlChannel = connectChannel(handler);
-        InOrder order = inOrder(handler, mWifiScannerImpl);
-
-        when(mWifiScannerImpl.startSingleScan(any(WifiNative.ScanSettings.class),
-                        any(WifiNative.ScanEventHandler.class))).thenReturn(true);
-
-        sendSingleScanRequest(controlChannel, requestId, requestSettings);
-
-        mLooper.dispatchAll();
-        WifiNative.ScanEventHandler eventHandler = verifyStartSingleScan(order, nativeSettings);
-        verifySuccessfulResponse(order, handler, requestId);
-
-        when(mWifiScannerImpl.getLatestSingleScanResults())
-                .thenReturn(results.getScanData());
-        eventHandler.onScanStatus(WifiNative.WIFI_SCAN_RESULTS_AVAILABLE);
-
-        mLooper.dispatchAll();
-        verifyScanResultsRecieved(order, handler, 12, results.getScanData());
-        verifyNoMoreInteractions(handler);
-    }
-
-    @Test
-    public void sendSingleScanBandRequest() throws Exception {
-        WifiScanner.ScanSettings requestSettings = createRequest(WifiScanner.WIFI_BAND_BOTH, 0,
-                0, 20, WifiScanner.REPORT_EVENT_AFTER_EACH_SCAN);
-        doSuccessfulSingleScan(requestSettings, computeSingleScanNativeSettings(requestSettings),
-                ScanResults.create(0, 2400, 5150, 5175));
-    }
-
-    @Test
-    public void sendSingleScanChannelsRequest() throws Exception {
-        WifiScanner.ScanSettings requestSettings = createRequest(channelsToSpec(2400), 0,
-                0, 20, WifiScanner.REPORT_EVENT_AFTER_EACH_SCAN);
-        doSuccessfulSingleScan(requestSettings, computeSingleScanNativeSettings(requestSettings),
-                ScanResults.create(0, 2400, 2400, 2400));
+        Message response = sendRequest(controlChannel, handler,
+                Message.obtain(null, Protocol.BASE_WIFI_MANAGER));
+        assertFailedResponse(0, WifiScanner.REASON_INVALID_REQUEST, "Invalid request", response);
     }
 
-    @Test
-    public void sendSingleScanRequestWhichFailsToStart() throws Exception {
-        WifiScanner.ScanSettings requestSettings = createRequest(WifiScanner.WIFI_BAND_BOTH, 0,
-                0, 20, WifiScanner.REPORT_EVENT_AFTER_EACH_SCAN);
-        int requestId = 33;
-
-        startServiceAndLoadDriver();
-
-        Handler handler = mock(Handler.class);
-        BidirectionalAsyncChannel controlChannel = connectChannel(handler);
-        InOrder order = inOrder(handler, mWifiScannerImpl);
-
-        // scan fails
-        when(mWifiScannerImpl.startSingleScan(any(WifiNative.ScanSettings.class),
-                        any(WifiNative.ScanEventHandler.class))).thenReturn(false);
-
-        sendSingleScanRequest(controlChannel, requestId, requestSettings);
-
-        mLooper.dispatchAll();
-        // Scan is successfully queue, but then fails to execute
-        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
-        order.verify(handler, times(2)).handleMessage(messageCaptor.capture());
-        assertSuccessfulResponse(requestId, messageCaptor.getAllValues().get(0));
-        assertFailedResponse(requestId, WifiScanner.REASON_UNSPECIFIED,
-                "Failed to start single scan", messageCaptor.getAllValues().get(1));
-    }
-
-    @Test
-    public void sendSingleScanRequestWhichFailsAfterStart() throws Exception {
-        WifiScanner.ScanSettings requestSettings = createRequest(WifiScanner.WIFI_BAND_BOTH, 0,
-                0, 20, WifiScanner.REPORT_EVENT_AFTER_EACH_SCAN);
-        int requestId = 33;
-
-        startServiceAndLoadDriver();
-
-        Handler handler = mock(Handler.class);
-        BidirectionalAsyncChannel controlChannel = connectChannel(handler);
-        InOrder order = inOrder(handler, mWifiScannerImpl);
-
-        // successful start
-        when(mWifiScannerImpl.startSingleScan(any(WifiNative.ScanSettings.class),
-                        any(WifiNative.ScanEventHandler.class))).thenReturn(true);
-
-        sendSingleScanRequest(controlChannel, requestId, requestSettings);
-
-        // Scan is successfully queue
-        mLooper.dispatchAll();
-        WifiNative.ScanEventHandler eventHandler =
-                verifyStartSingleScan(order, computeSingleScanNativeSettings(requestSettings));
-        verifySuccessfulResponse(order, handler, requestId);
-
-        // but then fails to execute
-        eventHandler.onScanStatus(WifiNative.WIFI_SCAN_DISABLED);
-        mLooper.dispatchAll();
-        verifyFailedResponse(order, handler, requestId,
-                WifiScanner.REASON_UNSPECIFIED, "Scan was interrupted");
-    }
-
-    // TODO Add more single scan tests
-    // * disable wifi while scanning
-    // * disable wifi while scanning with pending scan
-
-    @Test
-    public void sendSingleScanRequestAfterPreviousCompletes() {
-        WifiScanner.ScanSettings requestSettings1 = createRequest(channelsToSpec(2400), 0,
-                0, 20, WifiScanner.REPORT_EVENT_AFTER_EACH_SCAN);
-        int requestId1 = 12;
-        ScanResults results1 = ScanResults.create(0, 2400);
-
-
-        WifiScanner.ScanSettings requestSettings2 = createRequest(channelsToSpec(2450, 5175), 0,
-                0, 20, WifiScanner.REPORT_EVENT_AFTER_EACH_SCAN);
-        int requestId2 = 13;
-        ScanResults results2 = ScanResults.create(0, 2450);
-
-
-        startServiceAndLoadDriver();
-
-        when(mWifiScannerImpl.startSingleScan(any(WifiNative.ScanSettings.class),
-                        any(WifiNative.ScanEventHandler.class))).thenReturn(true);
-
-        Handler handler = mock(Handler.class);
-        BidirectionalAsyncChannel controlChannel = connectChannel(handler);
-        InOrder order = inOrder(handler, mWifiScannerImpl);
-
-        // Run scan 1
-        sendSingleScanRequest(controlChannel, requestId1, requestSettings1);
-
-        mLooper.dispatchAll();
-        WifiNative.ScanEventHandler eventHandler1 = verifyStartSingleScan(order,
-                computeSingleScanNativeSettings(requestSettings1));
-        verifySuccessfulResponse(order, handler, requestId1);
-
-        // dispatch scan 1 results
-        when(mWifiScannerImpl.getLatestSingleScanResults())
-                .thenReturn(results1.getScanData());
-        eventHandler1.onScanStatus(WifiNative.WIFI_SCAN_RESULTS_AVAILABLE);
-
-        mLooper.dispatchAll();
-        verifyScanResultsRecieved(order, handler, requestId1, results1.getScanData());
-
-        // Run scan 2
-        sendSingleScanRequest(controlChannel, requestId2, requestSettings2);
-
-        mLooper.dispatchAll();
-        WifiNative.ScanEventHandler eventHandler2 = verifyStartSingleScan(order,
-                computeSingleScanNativeSettings(requestSettings2));
-        verifySuccessfulResponse(order, handler, requestId2);
-
-        // dispatch scan 2 results
-        when(mWifiScannerImpl.getLatestSingleScanResults())
-                .thenReturn(results2.getScanData());
-        eventHandler2.onScanStatus(WifiNative.WIFI_SCAN_RESULTS_AVAILABLE);
-
-        mLooper.dispatchAll();
-        verifyScanResultsRecieved(order, handler, requestId2, results2.getScanData());
-    }
-
-    @Test
-    public void sendSingleScanRequestWhilePreviousScanRunning() {
-        WifiScanner.ScanSettings requestSettings1 = createRequest(channelsToSpec(2400), 0,
-                0, 20, WifiScanner.REPORT_EVENT_AFTER_EACH_SCAN);
-        int requestId1 = 12;
-        ScanResults results1 = ScanResults.create(0, 2400);
-
-        WifiScanner.ScanSettings requestSettings2 = createRequest(channelsToSpec(2450, 5175), 0,
-                0, 20, WifiScanner.REPORT_EVENT_AFTER_EACH_SCAN);
-        int requestId2 = 13;
-        ScanResults results2 = ScanResults.create(0, 2450);
-
-
-        startServiceAndLoadDriver();
-
-        when(mWifiScannerImpl.startSingleScan(any(WifiNative.ScanSettings.class),
-                        any(WifiNative.ScanEventHandler.class))).thenReturn(true);
-
-        Handler handler = mock(Handler.class);
-        BidirectionalAsyncChannel controlChannel = connectChannel(handler);
-        InOrder handlerOrder = inOrder(handler);
-        InOrder nativeOrder = inOrder(mWifiScannerImpl);
-
-        // Run scan 1
-        sendSingleScanRequest(controlChannel, requestId1, requestSettings1);
-
-        mLooper.dispatchAll();
-        WifiNative.ScanEventHandler eventHandler1 = verifyStartSingleScan(nativeOrder,
-                computeSingleScanNativeSettings(requestSettings1));
-        verifySuccessfulResponse(handlerOrder, handler, requestId1);
-
-        // Queue scan 2 (will not run because previous is in progress)
-        sendSingleScanRequest(controlChannel, requestId2, requestSettings2);
-        mLooper.dispatchAll();
-        verifySuccessfulResponse(handlerOrder, handler, requestId2);
-
-        // dispatch scan 1 results
-        when(mWifiScannerImpl.getLatestSingleScanResults())
-                .thenReturn(results1.getScanData());
-        eventHandler1.onScanStatus(WifiNative.WIFI_SCAN_RESULTS_AVAILABLE);
-
-        mLooper.dispatchAll();
-        verifyScanResultsRecieved(handlerOrder, handler, requestId1, results1.getScanData());
-
-        // now that the first scan completed we expect the second one to start
-        WifiNative.ScanEventHandler eventHandler2 = verifyStartSingleScan(nativeOrder,
-                computeSingleScanNativeSettings(requestSettings2));
-
-        // dispatch scan 2 results
-        when(mWifiScannerImpl.getLatestSingleScanResults())
-                .thenReturn(results2.getScanData());
-        eventHandler2.onScanStatus(WifiNative.WIFI_SCAN_RESULTS_AVAILABLE);
-
-        mLooper.dispatchAll();
-        verifyScanResultsRecieved(handlerOrder, handler, requestId2, results2.getScanData());
-    }
-
-
-
-    @Test
-    public void sendMultipleSingleScanRequestWhilePreviousScanRunning() {
-        WifiScanner.ScanSettings requestSettings1 = createRequest(channelsToSpec(2400), 0,
-                0, 20, WifiScanner.REPORT_EVENT_AFTER_EACH_SCAN);
-        int requestId1 = 12;
-        ScanResults results1 = ScanResults.create(0, 2400);
-
-        WifiScanner.ScanSettings requestSettings2 = createRequest(channelsToSpec(2450, 5175), 0,
-                0, 20, WifiScanner.REPORT_EVENT_AFTER_EACH_SCAN);
-        int requestId2 = 13;
-        ScanResults results2 = ScanResults.create(0, 2450, 5175, 2450);
-
-        WifiScanner.ScanSettings requestSettings3 = createRequest(channelsToSpec(5150), 0,
-                0, 20, WifiScanner.REPORT_EVENT_AFTER_EACH_SCAN);
-        int requestId3 = 15;
-        ScanResults results3 = ScanResults.create(0, 5150, 5150, 5150, 5150);
-
-        WifiNative.ScanSettings nativeSettings2and3 = createSingleScanNativeSettings(
-                WifiScanner.REPORT_EVENT_AFTER_EACH_SCAN, channelsToSpec(2450, 5175, 5150));
-        ScanResults results2and3 = ScanResults.merge(results2, results3);
-
-
-        startServiceAndLoadDriver();
-
-        when(mWifiScannerImpl.startSingleScan(any(WifiNative.ScanSettings.class),
-                        any(WifiNative.ScanEventHandler.class))).thenReturn(true);
-
-        Handler handler = mock(Handler.class);
-        BidirectionalAsyncChannel controlChannel = connectChannel(handler);
-        InOrder handlerOrder = inOrder(handler);
-        InOrder nativeOrder = inOrder(mWifiScannerImpl);
-
-        // Run scan 1
-        sendSingleScanRequest(controlChannel, requestId1, requestSettings1);
-
-        mLooper.dispatchAll();
-        WifiNative.ScanEventHandler eventHandler1 = verifyStartSingleScan(nativeOrder,
-                computeSingleScanNativeSettings(requestSettings1));
-        verifySuccessfulResponse(handlerOrder, handler, requestId1);
-
-        // Queue scan 2 (will not run because previous is in progress)
-        sendSingleScanRequest(controlChannel, requestId2, requestSettings2);
-        mLooper.dispatchAll();
-        verifySuccessfulResponse(handlerOrder, handler, requestId2);
-
-        // Queue scan 3 (will not run because previous is in progress)
-        sendSingleScanRequest(controlChannel, requestId3, requestSettings3);
-        mLooper.dispatchAll();
-        verifySuccessfulResponse(handlerOrder, handler, requestId3);
-
-        // dispatch scan 1 results
-        when(mWifiScannerImpl.getLatestSingleScanResults())
-                .thenReturn(results1.getScanData());
-        eventHandler1.onScanStatus(WifiNative.WIFI_SCAN_RESULTS_AVAILABLE);
-
-        mLooper.dispatchAll();
-        verifyScanResultsRecieved(handlerOrder, handler, requestId1, results1.getScanData());
-
-        // now that the first scan completed we expect the second and third ones to start
-        WifiNative.ScanEventHandler eventHandler2and3 = verifyStartSingleScan(nativeOrder,
-                nativeSettings2and3);
-
-        // dispatch scan 2 and 3 results
-        when(mWifiScannerImpl.getLatestSingleScanResults())
-                .thenReturn(results2and3.getScanData());
-        eventHandler2and3.onScanStatus(WifiNative.WIFI_SCAN_RESULTS_AVAILABLE);
-
-        mLooper.dispatchAll();
-
-        // unfortunatally the order that these events are dispatched is dependant on the order which
-        // they are iterated through internally
-        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
-        handlerOrder.verify(handler, times(2)).handleMessage(messageCaptor.capture());
-        int firstListenerId = messageCaptor.getAllValues().get(0).arg2;
-        assertTrue(firstListenerId + " was neither " + requestId2 + " nor " + requestId3,
-                firstListenerId == requestId2 || firstListenerId == requestId3);
-        if (firstListenerId == requestId2) {
-            assertScanResultsMessage(requestId2,
-                    new WifiScanner.ScanData[] {results2.getScanData()},
-                    messageCaptor.getAllValues().get(0));
-            assertScanResultsMessage(requestId3,
-                    new WifiScanner.ScanData[] {results3.getScanData()},
-                    messageCaptor.getAllValues().get(1));
-        } else {
-            assertScanResultsMessage(requestId3,
-                    new WifiScanner.ScanData[] {results3.getScanData()},
-                    messageCaptor.getAllValues().get(0));
-            assertScanResultsMessage(requestId2,
-                    new WifiScanner.ScanData[] {results2.getScanData()},
-                    messageCaptor.getAllValues().get(1));
-        }
-    }
-
-    private void doSuccessfulBackgroundScan(WifiScanner.ScanSettings requestSettings,
-            WifiNative.ScanSettings nativeSettings) {
-        startServiceAndLoadDriver();
-
-        Handler handler = mock(Handler.class);
-        BidirectionalAsyncChannel controlChannel = connectChannel(handler);
-        InOrder order = inOrder(handler, mWifiScannerImpl);
-
-        when(mWifiScannerImpl.startBatchedScan(any(WifiNative.ScanSettings.class),
-                        any(WifiNative.ScanEventHandler.class))).thenReturn(true);
-
-        sendBackgroundScanRequest(controlChannel, 12, requestSettings);
-        mLooper.dispatchAll();
-        verifyStartBackgroundScan(order, nativeSettings);
-        verifySuccessfulResponse(order, handler, 12);
-        verifyNoMoreInteractions(handler);
-    }
-
-    @Test
-    public void sendBackgroundScanBandRequest() throws Exception {
-        WifiScanner.ScanSettings requestSettings = createRequest(WifiScanner.WIFI_BAND_BOTH, 20000,
-                0, 20, WifiScanner.REPORT_EVENT_AFTER_EACH_SCAN);
-        WifiNative.ScanSettings nativeSettings = new NativeScanSettingsBuilder()
-                .withBasePeriod(20000)
-                .withMaxApPerScan(MAX_AP_PER_SCAN)
-                .withMaxScansToCache(WifiScanningScheduler.DEFAULT_MAX_SCANS_TO_BATCH)
-                .addBucketWithBand(20000, WifiScanner.REPORT_EVENT_AFTER_EACH_SCAN,
-                        WifiScanner.WIFI_BAND_BOTH)
-                .build();
-        doSuccessfulBackgroundScan(requestSettings, nativeSettings);
-    }
-
-    @Test
-    public void sendBackgroundScanChannelsRequest() throws Exception {
-        WifiScanner.ScanSettings requestSettings = createRequest(channelsToSpec(5150), 20000,
-                0, 20, WifiScanner.REPORT_EVENT_AFTER_EACH_SCAN);
-        WifiNative.ScanSettings nativeSettings = new NativeScanSettingsBuilder()
-                .withBasePeriod(20000)
-                .withMaxApPerScan(MAX_AP_PER_SCAN)
-                .withMaxScansToCache(WifiScanningScheduler.DEFAULT_MAX_SCANS_TO_BATCH)
-                .addBucketWithChannels(20000, WifiScanner.REPORT_EVENT_AFTER_EACH_SCAN, 5150)
-                .build();
-        doSuccessfulBackgroundScan(requestSettings, nativeSettings);
-    }
 }
diff --git a/tests/wifitests/src/com/android/server/wifi/WifiStateMachineTest.java b/tests/wifitests/src/com/android/server/wifi/WifiStateMachineTest.java
index 567b05b4e..fe8eae8ac 100644
--- a/tests/wifitests/src/com/android/server/wifi/WifiStateMachineTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/WifiStateMachineTest.java
@@ -41,7 +41,6 @@ import android.net.wifi.ScanResult;
 import android.net.wifi.SupplicantState;
 import android.net.wifi.WifiConfiguration;
 import android.net.wifi.WifiManager;
-import android.net.wifi.WifiScanner;
 import android.net.wifi.WifiSsid;
 import android.net.wifi.p2p.IWifiP2pManager;
 import android.os.BatteryStats;
@@ -75,7 +74,6 @@ import com.android.server.wifi.p2p.WifiP2pServiceImpl;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
-import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.Mockito;
 import org.mockito.MockitoAnnotations;
@@ -86,7 +84,6 @@ import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -227,8 +224,6 @@ public class WifiStateMachineTest {
         when(context.getSystemService(Context.CONNECTIVITY_SERVICE)).thenReturn(
                 mock(ConnectivityManager.class));
 
-        when(context.getSystemService(Context.WIFI_SCANNING_SERVICE)).thenReturn(mWifiScanner);
-
         return context;
     }
 
@@ -293,20 +288,16 @@ public class WifiStateMachineTest {
         ScanDetail detail = new ScanDetail(nd, sWifiSsid, sBSSID, "", rssi, sFreq,
                 Long.MAX_VALUE /* needed so that scan results aren't rejected because
                                   there older than scan start */);
-        detail.getScanResult().informationElements = ie;
-        detail.getScanResult().anqpLines = new ArrayList<String>();
         return detail;
     }
 
-    private ScanResult[] getMockScanResults() {
+    private ArrayList<ScanDetail> getMockScanResults() {
         ScanResults sr = ScanResults.create(0, 2412, 2437, 2462, 5180, 5220, 5745, 5825);
-        // copy generated results and add space on the end for one more
-        ScanResult[] results = Arrays.copyOf(sr.getScanData().getResults(),
-                sr.getScanData().getResults().length + 1);
+        ArrayList<ScanDetail> list = sr.getScanDetailArrayList();
 
         int rssi = -65;
-        results[results.length - 1] = getGoogleGuestScanDetail(rssi).getScanResult();
-        return results;
+        list.add(getGoogleGuestScanDetail(rssi));
+        return list;
     }
 
     static final String   sSSID = "\"GoogleGuest\"";
@@ -324,7 +315,6 @@ public class WifiStateMachineTest {
     MockWifiMonitor mWifiMonitor;
 
     @Mock WifiNative mWifiNative;
-    @Mock WifiScanner mWifiScanner;
     @Mock SupplicantStateTracker mSupplicantStateTracker;
     @Mock WifiMetrics mWifiMetrics;
 
@@ -552,27 +542,14 @@ public class WifiStateMachineTest {
         mWsm.startScan(-1, 0, null, null);
         wait(200);
 
-        ArgumentCaptor<WifiScanner.ScanSettings> scanSettingsCaptor =
-                ArgumentCaptor.forClass(WifiScanner.ScanSettings.class);
-        ArgumentCaptor<WifiScanner.ScanListener> scanListenerCaptor =
-                ArgumentCaptor.forClass(WifiScanner.ScanListener.class);
-        verify(mWifiScanner).startScan(scanSettingsCaptor.capture(), scanListenerCaptor.capture());
-        assertEquals("band", WifiScanner.WIFI_BAND_BOTH_WITH_DFS,
-                scanSettingsCaptor.getValue().band);
-        assertEquals("reportEvents", WifiScanner.REPORT_EVENT_AFTER_EACH_SCAN
-                | WifiScanner.REPORT_EVENT_FULL_SCAN_RESULT,
-                scanSettingsCaptor.getValue().reportEvents);
-
-        ScanResult[] results = getMockScanResults();
-        for (ScanResult result : results) {
-            scanListenerCaptor.getValue().onFullResult(result);
-        }
-        scanListenerCaptor.getValue().onResults(
-                new WifiScanner.ScanData[] {new WifiScanner.ScanData(0, 0, results)});
+        verify(mWifiNative).scan(WifiNative.SCAN_WITHOUT_CONNECTION_SETUP, null);
+
+        when(mWifiNative.getScanResults()).thenReturn(getMockScanResults());
+        mWsm.sendMessage(WifiMonitor.SCAN_RESULTS_EVENT);
 
         wait(200);
-        List<ScanResult> reportedResults = mWsm.syncGetScanResultsList();
-        assertEquals(8, reportedResults.size());
+        List<ScanResult> results = mWsm.syncGetScanResultsList();
+        assertEquals(8, results.size());
     }
 
     @Test