If location services are turned off, have the BT chooser prompt the user to turn them on.

chrome/android/javatests/src/org/chromium/chrome/browser/BluetoothChooserDialogTest.java

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.chrome.browser;
 
 import android.Manifest;
 import android.app.Dialog;
+import android.content.Context;
+import android.content.Intent;
 import android.content.pm.PackageManager;
+import android.location.LocationManager;
 import android.test.MoreAsserts;
 import android.test.suitebuilder.annotation.SmallTest;
 import android.view.View;
 import android.widget.Button;
 import android.widget.ListView;
 
 import org.chromium.base.ThreadUtils;
 import org.chromium.chrome.R;
+import org.chromium.chrome.browser.preferences.LocationSettings;
 import org.chromium.chrome.test.ChromeActivityTestCaseBase;
 import org.chromium.components.security_state.ConnectionSecurityLevel;
 import org.chromium.content.browser.test.util.Criteria;
 import org.chromium.content.browser.test.util.CriteriaHelper;
 import org.chromium.content.browser.test.util.TouchCommon;
 import org.chromium.ui.base.ActivityWindowAndroid;
 import org.chromium.ui.base.AndroidPermissionDelegate;
 import org.chromium.ui.base.WindowAndroid;
 import org.chromium.ui.base.WindowAndroid.PermissionCallback;
 import org.chromium.ui.widget.TextViewWithClickableSpans;
 
 import java.util.concurrent.Callable;
 
 /**
  * Tests for the BluetoothChooserDialog class.
  */
 public class BluetoothChooserDialogTest extends ChromeActivityTestCaseBase<ChromeActivity> {
     /**
      * Works like the BluetoothChooserDialog class, but records calls to native methods instead of
      * calling back to C++.
      */
     static class BluetoothChooserDialogWithFakeNatives extends BluetoothChooserDialog {
         int mFinishedEventType = -1;
         String mFinishedDeviceId;
+        int mRestartSearchCount = 0;
 
         BluetoothChooserDialogWithFakeNatives(WindowAndroid windowAndroid, String origin,
                 int securityLevel, long nativeBluetoothChooserDialogPtr) {
             super(windowAndroid, origin, securityLevel, nativeBluetoothChooserDialogPtr);
         }
 
         @Override
         void nativeOnDialogFinished(
                 long nativeBluetoothChooserAndroid, int eventType, String deviceId) {
             assertEquals(nativeBluetoothChooserAndroid, mNativeBluetoothChooserDialogPtr);
             assertEquals(mFinishedEventType, -1);
             mFinishedEventType = eventType;
             mFinishedDeviceId = deviceId;
         }
 
         @Override
-        void nativeRestartSearch(long nativeBluetoothChooserAndroid) {}
+        void nativeRestartSearch(long nativeBluetoothChooserAndroid) {
+            mRestartSearchCount++;
+        }
 
         @Override
         void nativeShowBluetoothOverviewLink(long nativeBluetoothChooserAndroid) {}
 
         @Override
         void nativeShowBluetoothAdapterOffLink(long nativeBluetoothChooserAndroid) {}
 
         @Override
         void nativeShowNeedLocationPermissionLink(long nativeBluetoothChooserAndroid) {}
     }
 
     private ActivityWindowAndroid mWindowAndroid;
+    private TestLocationSettings mLocationSettings;
     private BluetoothChooserDialogWithFakeNatives mChooserDialog;
 
     public BluetoothChooserDialogTest() {
         super(ChromeActivity.class);
     }
 
     // ChromeActivityTestCaseBase:
 
     @Override
     protected void setUp() throws Exception {
         super.setUp();
+        mLocationSettings = new TestLocationSettings(getActivity());
+        LocationSettings.setInstanceForTesting(mLocationSettings);
         mChooserDialog = createDialog();
     }
 
     @Override
+    protected void tearDown() throws Exception {
+        LocationSettings.setInstanceForTesting(null);
+        super.tearDown();
+    }
+
+    @Override
     public void startMainActivity() throws InterruptedException {
         startMainActivityOnBlankPage();
     }
 
     private BluetoothChooserDialogWithFakeNatives createDialog() {
         return ThreadUtils.runOnUiThreadBlockingNoException(
                 new Callable<BluetoothChooserDialogWithFakeNatives>() {
                     @Override
                     public BluetoothChooserDialogWithFakeNatives call() {
                         mWindowAndroid = new ActivityWindowAndroid(getActivity());
@@ skipping 37 matching lines @@
 
         CriteriaHelper.pollUiThread(new Criteria() {
             @Override
             public boolean isSatisfied() {
                 return chooserDialog.mFinishedEventType != -1;
             }
         });
     }
 
     /**
-     * The messages include <link> ... </link> or <link1> ... </link1>, <link2> ... </link2>
-     * sections that are used to create clickable spans. For testing the messages, this function
-     * returns the raw string without the tags.
+     * The messages include <*link*> ... </*link*> sections that are used to create clickable spans.
+     * For testing the messages, this function returns the raw string without the tags.
      */
     private static String removeLinkTags(String message) {
-        return message.replaceAll("</?link1>", "").replaceAll(
-                "</?link2>", "").replaceAll("</?link>", "");
+        return message.replaceAll("</?[^>]*link[^>]*>", "");
     }
 
     @SmallTest
     public void testCancel() throws InterruptedException {
         ItemChooserDialog itemChooser = mChooserDialog.mItemChooserDialog;
         Dialog dialog = itemChooser.getDialogForTesting();
         assertTrue(dialog.isShowing());
 
         TextViewWithClickableSpans statusView =
                 (TextViewWithClickableSpans) dialog.findViewById(R.id.status);
@@ skipping 103 matching lines @@
         // Permission was requested.
         MoreAsserts.assertEquals(permissionDelegate.mPermissionsRequested,
                 new String[] {Manifest.permission.ACCESS_COARSE_LOCATION});
         assertNotNull(permissionDelegate.mCallback);
         // Grant permission.
         permissionDelegate.mLocationGranted = true;
         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
             @Override
             public void run() {
                 permissionDelegate.mCallback.onRequestPermissionsResult(
-                        new String[] {Manifest.permission.ACCESS_FINE_LOCATION},
+                        new String[] {Manifest.permission.ACCESS_COARSE_LOCATION},
                         new int[] {PackageManager.PERMISSION_GRANTED});
             }
         });
 
-        assertEquals(removeLinkTags(getActivity().getString(R.string.bluetooth_adapter_off_help)),
+        assertEquals(1, mChooserDialog.mRestartSearchCount);
+        assertEquals(removeLinkTags(getActivity().getString(R.string.bluetooth_searching)),
                 statusView.getText().toString());
 
         mChooserDialog.closeDialog();
+    }
+
+    @SmallTest
+    public void testNoLocationServices() throws InterruptedException {
+        ItemChooserDialog itemChooser = mChooserDialog.mItemChooserDialog;
+        Dialog dialog = itemChooser.getDialogForTesting();
+        assertTrue(dialog.isShowing());
+
+        final TextViewWithClickableSpans statusView =
+                (TextViewWithClickableSpans) dialog.findViewById(R.id.status);
+        final TextViewWithClickableSpans errorView =
+                (TextViewWithClickableSpans) dialog.findViewById(R.id.not_found_message);
+        final View items = dialog.findViewById(R.id.items);
+        final Button button = (Button) dialog.findViewById(R.id.positive);
+        final View progress = dialog.findViewById(R.id.progress);
+
+        final TestAndroidPermissionDelegate permissionDelegate =
+                new TestAndroidPermissionDelegate();
+        mWindowAndroid.setAndroidPermissionDelegate(permissionDelegate);
+
+        // Grant permissions, and turn off location services.
+        permissionDelegate.mLocationGranted = true;
+        mLocationSettings.mSystemLocationSettingsEnabled = false;
+
+        ThreadUtils.runOnUiThreadBlocking(new Runnable() {
+            @Override
+            public void run() {
+                mChooserDialog.notifyDiscoveryState(
+                        BluetoothChooserDialog.DISCOVERY_FAILED_TO_START);
+            }
+        });
+
+        assertEquals(removeLinkTags(
+                             getActivity().getString(R.string.bluetooth_need_location_services_on)),
+                errorView.getText().toString());
+        assertEquals(removeLinkTags(getActivity().getString(
+                             R.string.bluetooth_need_location_permission_help)),
+                statusView.getText().toString());
+        assertFalse(button.isEnabled());
+        assertEquals(View.VISIBLE, errorView.getVisibility());
+        assertEquals(View.GONE, items.getVisibility());
+        assertEquals(View.GONE, progress.getVisibility());
+
+        // Turn on Location Services.
+        mLocationSettings.mSystemLocationSettingsEnabled = true;
+        ThreadUtils.runOnUiThreadBlocking(new Runnable() {
+            @Override
+            public void run() {
+                mChooserDialog.mLocationModeBroadcastReceiver.onReceive(
+                        getActivity(), new Intent(LocationManager.MODE_CHANGED_ACTION));
+            }
+        });
+
+        assertEquals(1, mChooserDialog.mRestartSearchCount);
+        assertEquals(removeLinkTags(getActivity().getString(R.string.bluetooth_searching)),
+                statusView.getText().toString());
+
+        mChooserDialog.closeDialog();
     }
 
     // TODO(jyasskin): Test when the user denies Chrome the ability to ask for permission.
 
     private static class TestAndroidPermissionDelegate implements AndroidPermissionDelegate {
         boolean mLocationGranted = false;
         PermissionCallback mCallback = null;
         String[] mPermissionsRequested = null;
 
         @Override
@@ skipping 11 matching lines @@
         }
         @Override
         public void requestPermissions(String[] permissions, PermissionCallback callback) {
             mPermissionsRequested = permissions;
             if (permissions.length == 1
                     && permissions[0].equals(Manifest.permission.ACCESS_COARSE_LOCATION)) {
                 mCallback = callback;
             }
         }
     }
+
+    private static class TestLocationSettings extends LocationSettings {
+        public TestLocationSettings(Context context) {
+            super(context);
+        }
+
+        public boolean mSystemLocationSettingsEnabled = true;
+
+        @Override
+        public boolean isSystemLocationSettingEnabled() {
+            return mSystemLocationSettingsEnabled;
+        }
+    }
 }