Update settings to hold the endpoint and key, and remote the hardcoded endpoint details

src/vs/base/browser/ui/checkbox/checkbox.ts

@@ -73,6 +73,10 @@ export class Checkbox extends Widget {
 		});
 	}
 
+	public get enabled(): boolean {
+		return this.domNode.getAttribute('aria-disabled') !== 'true';
+	}
+
 	public focus(): void {
 		this.domNode.focus();
 	}

src/vs/workbench/electron-browser/main.contribution.ts

@@ -197,10 +197,15 @@ let workbenchProperties: { [path: string]: IJSONSchema; } = {
 		'description': nls.localize('openDefaultSettings', "Controls if opening settings also opens an editor showing all default settings."),
 		'default': true
 	},
-	'workbench.settings.useExperimentalRemoteSearch': {
-		'type': 'boolean',
-		'description': nls.localize('useExperimentalRemoteSearch', "Controls whether to use the experimetal remote search engine for settings search."),
-		'default': false
+	'workbench.settings.experimentalFuzzySearchEndpoint': {
+		'type': 'string',
+		'description': nls.localize('experimentalFuzzySearchEndpoint', "Indicates the endpoint to use for the experimental settings search."),
+		'default': ''
+	},
+	'workbench.settings.experimentalFuzzySearchKey': {
+		'type': 'string',
+		'description': nls.localize('experimentalFuzzySearchKey', "Indicates the key to use for the experimental settings search."),
+		'default': ''
 	},
 	'workbench.sideBar.location': {
 		'type': 'string',

src/vs/workbench/parts/preferences/browser/media/preferences.css

@@ -93,6 +93,10 @@
 	margin: 5px 3px 5px 0px;
 }
 
+.settings-header-widget > .settings-search-controls > .prefs-fuzzy-search-toggle.hidden {
+	display: none;
+}
+
 .vs .settings-header-widget > .settings-search-controls > .prefs-fuzzy-search-toggle {
 	background: url('regex.svg') center center no-repeat;
 }

src/vs/workbench/parts/preferences/browser/preferencesEditor.ts

@@ -144,6 +144,8 @@ export class PreferencesEditor extends BaseEditor {
 			placeholder: nls.localize('SearchSettingsWidget.Placeholder', "Search Settings"),
 			focusKey: this.focusSettingsContextKey
 		}));
+		this.searchWidget.setFuzzyToggleVisible(this.searchProvider.remoteSearchEnabled);
+		this._register(this.searchProvider.onRemoteSearchEnablementChanged(enabled => this.searchWidget.setFuzzyToggleVisible(enabled)));
 		this._register(this.searchWidget.onDidChange(value => this.onInputChanged()));
 		this._register(this.searchWidget.onFocus(() => this.lastFocusedWidget = this.searchWidget));
 		this.lastFocusedWidget = this.searchWidget;
@@ -445,8 +447,8 @@ class PreferencesRenderers extends Disposable {
 
 		const searchModel = searchProvider.startSearch(filter, fuzzy);
 		this._filtersInProgress = [
-			this._filterPreferences(filter, searchModel, this._defaultPreferencesRenderer),
-			this._filterPreferences(filter, searchModel, this._editablePreferencesRenderer)];
+			this._filterPreferences(searchModel, searchProvider, this._defaultPreferencesRenderer),
+			this._filterPreferences(searchModel, searchProvider, this._editablePreferencesRenderer)];
 
 		return TPromise.join<IFilterResult>(this._filtersInProgress).then(filterResults => {
 			this._filtersInProgress = null;
@@ -477,14 +479,12 @@ class PreferencesRenderers extends Disposable {
 		return preferencesRenderer ? (<ISettingsEditorModel>preferencesRenderer.preferencesModel).settingsGroups : [];
 	}
 
-	private _filterPreferences(filter: string, searchModel: PreferencesSearchModel, preferencesRenderer: IPreferencesRenderer<ISetting>): TPromise<IFilterResult> {
+	private _filterPreferences(searchModel: PreferencesSearchModel, searchProvider: PreferencesSearchProvider, preferencesRenderer: IPreferencesRenderer<ISetting>): TPromise<IFilterResult> {
 		if (preferencesRenderer) {
-			const prefSearchP = filter ?
-				searchModel.filterPreferences(<ISettingsEditorModel>preferencesRenderer.preferencesModel) :
-				TPromise.wrap(null);
+			const prefSearchP = searchModel.filterPreferences(<ISettingsEditorModel>preferencesRenderer.preferencesModel);
 
 			return prefSearchP.then(filterResult => {
-				preferencesRenderer.filterPreferences(filterResult);
+				preferencesRenderer.filterPreferences(filterResult, searchProvider.remoteSearchEnabled);
 				return filterResult;
 			});
 		}

src/vs/workbench/parts/preferences/browser/preferencesRenderers.ts

@@ -45,7 +45,7 @@ export interface IPreferencesRenderer<T> extends IDisposable {
 
 	render(): void;
 	updatePreference(key: string, value: any, source: T): void;
-	filterPreferences(filterResult: IFilterResult): void;
+	filterPreferences(filterResult: IFilterResult, fuzzySearchAvailable: boolean): void;
 	focusPreference(setting: T): void;
 	clearFocus(setting: T): void;
 }
@@ -295,13 +295,13 @@ export class DefaultSettingsRenderer extends Disposable implements IPreferencesR
 		this.hiddenAreasRenderer.render();
 	}
 
-	public filterPreferences(filterResult: IFilterResult): void {
+	public filterPreferences(filterResult: IFilterResult, fuzzySearchAvailable: boolean): void {
 		this.filterResult = filterResult;
 		if (filterResult) {
 			this.filteredMatchesRenderer.render(filterResult, this.preferencesModel.settingsGroups);
 			this.settingsGroupTitleRenderer.render(filterResult.filteredGroups);
 			this.feedbackWidgetRenderer.render(filterResult);
-			this.settingsHeaderRenderer.render(filterResult);
+			this.settingsHeaderRenderer.render(filterResult, fuzzySearchAvailable);
 			this.settingHighlighter.clear(true);
 			this.editSettingActionRenderer.render(filterResult.filteredGroups, this._associatedPreferencesModel);
 		} else {
@@ -424,9 +424,9 @@ class DefaultSettingsHeaderRenderer extends Disposable {
 		this.onClick = this.settingsHeaderWidget.onClick;
 	}
 
-	public render(filterResult: IFilterResult) {
+	public render(filterResult: IFilterResult, fuzzySearchAvailable = false) {
 		const hasSettings = !filterResult || filterResult.filteredGroups.length > 0;
-		const promptFuzzy = filterResult && !filterResult.metadata;
+		const promptFuzzy = fuzzySearchAvailable && filterResult && !filterResult.metadata;
 		this.settingsHeaderWidget.toggleMessage(hasSettings, promptFuzzy);
 	}
 }

src/vs/workbench/parts/preferences/browser/preferencesSearch.ts

@@ -4,6 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { TPromise } from 'vs/base/common/winjs.base';
+import Event, { Emitter } from 'vs/base/common/event';
 import { ISettingsEditorModel, IFilterResult, ISetting, ISettingsGroup, IWorkbenchSettingsConfiguration, IFilterMetadata } from 'vs/workbench/parts/preferences/common/preferences';
 import { IRange, Range } from 'vs/editor/common/core/range';
 import { distinct } from 'vs/base/common/arrays';
@@ -14,13 +15,30 @@ import { IConfigurationRegistry, Extensions } from 'vs/platform/configuration/co
 import { IMatch, or, matchesContiguousSubString, matchesPrefix, matchesCamelCase, matchesWords } from 'vs/base/common/filters';
 import { IWorkspaceConfigurationService } from 'vs/workbench/services/configuration/common/configuration';
 
+export interface IEndpointDetails {
+	urlBase: string;
+	key: string;
+}
+
 export class PreferencesSearchProvider {
+	private _onRemoteSearchEnablementChanged = new Emitter<boolean>();
+	public onRemoteSearchEnablementChanged: Event<boolean> = this._onRemoteSearchEnablementChanged.event;
 
 	constructor( @IWorkspaceConfigurationService private configurationService: IWorkspaceConfigurationService) {
+		configurationService.onDidUpdateConfiguration(() => this._onRemoteSearchEnablementChanged.fire(this.remoteSearchEnabled));
 	}
 
 	get remoteSearchEnabled(): boolean {
-		return !!this.configurationService.getConfiguration<IWorkbenchSettingsConfiguration>().workbench.settings.useExperimentalRemoteSearch;
+		const endpoint = this.endpoint;
+		return !!endpoint.urlBase && !!endpoint.key;
+	}
+
+	get endpoint(): IEndpointDetails {
+		const workbenchSettings = this.configurationService.getConfiguration<IWorkbenchSettingsConfiguration>().workbench.settings;
+		return {
+			urlBase: workbenchSettings.experimentalFuzzySearchEndpoint,
+			key: workbenchSettings.experimentalFuzzySearchKey
+		};
 	}
 
 	startSearch(filter: string, remote: boolean): PreferencesSearchModel {
@@ -32,15 +50,19 @@ export class PreferencesSearchModel {
 	private _localProvider: LocalSearchProvider;
 	private _remoteProvider: RemoteSearchProvider;
 
-	constructor(private provider: PreferencesSearchProvider, filter: string, remote: boolean) {
+	constructor(private provider: PreferencesSearchProvider, private filter: string, remote: boolean) {
 		this._localProvider = new LocalSearchProvider(filter);
 
-		if (remote) {
-			this._remoteProvider = new RemoteSearchProvider(filter);
+		if (remote && filter) {
+			this._remoteProvider = new RemoteSearchProvider(filter, this.provider.endpoint);
 		}
 	}
 
 	filterPreferences(preferencesModel: ISettingsEditorModel): TPromise<IFilterResult> {
+		if (!this.filter) {
+			return TPromise.wrap(null);
+		}
+
 		if (this._remoteProvider) {
 			return this._remoteProvider.filterPreferences(preferencesModel).then(null, err => {
 				return this._localProvider.filterPreferences(preferencesModel);
@@ -86,9 +108,9 @@ class RemoteSearchProvider {
 	private _filter: string;
 	private _remoteSearchP: TPromise<IRemoteResult>;
 
-	constructor(filter: string) {
+	constructor(filter: string, endpoint: IEndpointDetails) {
 		this._filter = filter;
-		this._remoteSearchP = filter ? getSettingsFromBing(filter) : TPromise.wrap(null);
+		this._remoteSearchP = filter ? getSettingsFromBing(filter, endpoint) : TPromise.wrap(null);
 	}
 
 	filterPreferences(preferencesModel: ISettingsEditorModel): TPromise<IFilterResult> {
@@ -118,8 +140,8 @@ class RemoteSearchProvider {
 	}
 }
 
-function getSettingsFromBing(filter: string): TPromise<IRemoteResult> {
-	const url = prepareUrl(filter);
+function getSettingsFromBing(filter: string, endpoint: IEndpointDetails): TPromise<IRemoteResult> {
+	const url = prepareUrl(filter, endpoint);
 	console.log('fetching: ' + url);
 	const start = Date.now();
 	const p = fetch(url, {
@@ -161,11 +183,6 @@ function getSettingsFromBing(filter: string): TPromise<IRemoteResult> {
 	return TPromise.as(p as any);
 }
 
-const endpoint = {
-	key: 'F3F22B32DD89DDA74B1935ED0BE6FCBA',
-	urlBase: 'https://vscodesearch6.search.windows.net/indexes/vscodeindex/docs'
-};
-
 const API_VERSION = 'api-version=2015-02-28-Preview';
 const QUERY_TYPE = 'querytype=full';
 const SCORING_PROFILE = 'scoringProfile=ranking1';
@@ -177,7 +194,7 @@ function escapeSpecialChars(query: string): string {
 		.trim();
 }
 
-function prepareUrl(query: string): string {
+function prepareUrl(query: string, endpoint: IEndpointDetails): string {
 	query = escapeSpecialChars(query);
 	const userQuery = query;
 

src/vs/workbench/parts/preferences/browser/preferencesWidgets.ts

@@ -450,7 +450,7 @@ export class SearchWidget extends Widget {
 	}
 
 	public get fuzzyEnabled(): boolean {
-		return this.fuzzyToggle.checked;
+		return this.fuzzyToggle.checked && this.fuzzyToggle.enabled;
 	}
 
 	public set fuzzyEnabled(value: boolean) {
@@ -519,6 +519,16 @@ export class SearchWidget extends Widget {
 		this.styleCountElementForeground();
 	}
 
+	public setFuzzyToggleVisible(visible: boolean): void {
+		if (visible) {
+			this.fuzzyToggle.domNode.classList.remove('hidden');
+			this.fuzzyToggle.enable();
+		} else {
+			this.fuzzyToggle.domNode.classList.add('hidden');
+			this.fuzzyToggle.disable();
+		}
+	}
+
 	private styleCountElementForeground() {
 		const colorId = DOM.hasClass(this.countElement, 'no-results') ? errorForeground : badgeForeground;
 		const color = this.themeService.getTheme().getColor(colorId);

src/vs/workbench/parts/preferences/common/preferences.ts

@@ -20,7 +20,8 @@ export interface IWorkbenchSettingsConfiguration {
 	workbench: {
 		settings: {
 			openDefaultSettings: boolean;
-			useExperimentalRemoteSearch: boolean;
+			experimentalFuzzySearchEndpoint: string;
+			experimentalFuzzySearchKey: string;
 		}
 	};
 }
@@ -56,6 +57,7 @@ export interface IFilterResult {
 	filteredGroups: ISettingsGroup[];
 	allGroups: ISettingsGroup[];
 	matches: IRange[];
+	fuzzySearchAvailable?: boolean;
 	metadata?: IFilterMetadata;
 }