Do not extend EventEmitter

src/vs/base/common/eventEmitter.ts

@@ -197,11 +197,11 @@ export class EventEmitter implements IEventEmitter {
 		}
 	}
 
-	protected _beginDeferredEmit(): void {
+	public beginDeferredEmit(): void {
 		this._deferredCnt = this._deferredCnt + 1;
 	}
 
-	protected _endDeferredEmit(): void {
+	public endDeferredEmit(): void {
 		this._deferredCnt = this._deferredCnt - 1;
 
 		if (this._deferredCnt === 0) {
@@ -210,11 +210,11 @@ export class EventEmitter implements IEventEmitter {
 	}
 
 	public deferredEmit<T>(callback: () => T): T {
-		this._beginDeferredEmit();
+		this.beginDeferredEmit();
 
 		let result: T = safeInvokeNoArg<T>(callback);
 
-		this._endDeferredEmit();
+		this.endDeferredEmit();
 
 		return result;
 	}

src/vs/base/parts/tree/browser/treeModel.ts

@@ -841,10 +841,10 @@ export class TreeModel extends Events.EventEmitter {
 
 	public refreshAll(elements: any[], recursive: boolean = true): WinJS.Promise {
 		try {
-			this._beginDeferredEmit();
+			this.beginDeferredEmit();
 			return this._refreshAll(elements, recursive);
 		} finally {
-			this._endDeferredEmit();
+			this.endDeferredEmit();
 		}
 	}
 

src/vs/editor/common/model/editableTextModel.ts

@@ -38,10 +38,10 @@ export class EditableTextModel extends TextModelWithDecorations implements edito
 	}
 
 	public onDidChangeRawContent(listener: (e: editorCommon.IModelRawContentChangedEvent) => void): IDisposable {
-		return this.addListener(editorCommon.EventType.ModelRawContentChanged, listener);
+		return this._eventEmitter.addListener(editorCommon.EventType.ModelRawContentChanged, listener);
 	}
 	public onDidChangeContent(listener: (e: editorCommon.IModelContentChangedEvent) => void): IDisposable {
-		return this.addListener(editorCommon.EventType.ModelContentChanged, listener);
+		return this._eventEmitter.addListener(editorCommon.EventType.ModelContentChanged, listener);
 	}
 
 	private _commandManager: EditStack;
@@ -91,10 +91,10 @@ export class EditableTextModel extends TextModelWithDecorations implements edito
 
 	public pushEditOperations(beforeCursorState: Selection[], editOperations: editorCommon.IIdentifiedSingleEditOperation[], cursorStateComputer: editorCommon.ICursorStateComputer): Selection[] {
 		try {
-			this._beginDeferredEmit();
+			this._eventEmitter.beginDeferredEmit();
 			return this._pushEditOperations(beforeCursorState, editOperations, cursorStateComputer);
 		} finally {
-			this._endDeferredEmit();
+			this._eventEmitter.endDeferredEmit();
 		}
 	}
 
@@ -273,12 +273,12 @@ export class EditableTextModel extends TextModelWithDecorations implements edito
 
 	public applyEdits(rawOperations: editorCommon.IIdentifiedSingleEditOperation[]): editorCommon.IIdentifiedSingleEditOperation[] {
 		try {
-			this._beginDeferredEmit();
+			this._eventEmitter.beginDeferredEmit();
 			let markersTracker = this._acquireMarkersTracker();
 			return this._applyEdits(markersTracker, rawOperations);
 		} finally {
 			this._releaseMarkersTracker();
-			this._endDeferredEmit();
+			this._eventEmitter.endDeferredEmit();
 		}
 	}
 
@@ -690,7 +690,7 @@ export class EditableTextModel extends TextModelWithDecorations implements edito
 			}
 
 			for (let i = 0, len = contentChangedEvents.length; i < len; i++) {
-				this.emit(editorCommon.EventType.ModelRawContentChanged, contentChangedEvents[i]);
+				this._eventEmitter.emit(editorCommon.EventType.ModelRawContentChanged, contentChangedEvents[i]);
 			}
 			const e: editorCommon.IModelContentChangedEvent = {
 				changes: contentChanges,
@@ -700,7 +700,7 @@ export class EditableTextModel extends TextModelWithDecorations implements edito
 				isRedoing: this._isRedoing,
 				isFlush: false
 			};
-			this.emit(editorCommon.EventType.ModelContentChanged, e);
+			this._eventEmitter.emit(editorCommon.EventType.ModelContentChanged, e);
 		}
 
 		// this._assertLineNumbersOK();
@@ -752,12 +752,12 @@ export class EditableTextModel extends TextModelWithDecorations implements edito
 
 	public undo(): Selection[] {
 		try {
-			this._beginDeferredEmit();
+			this._eventEmitter.beginDeferredEmit();
 			this._acquireMarkersTracker();
 			return this._undo();
 		} finally {
 			this._releaseMarkersTracker();
-			this._endDeferredEmit();
+			this._eventEmitter.endDeferredEmit();
 		}
 	}
 
@@ -777,12 +777,12 @@ export class EditableTextModel extends TextModelWithDecorations implements edito
 
 	public redo(): Selection[] {
 		try {
-			this._beginDeferredEmit();
+			this._eventEmitter.beginDeferredEmit();
 			this._acquireMarkersTracker();
 			return this._redo();
 		} finally {
 			this._releaseMarkersTracker();
-			this._endDeferredEmit();
+			this._eventEmitter.endDeferredEmit();
 		}
 	}
 

src/vs/editor/common/model/model.ts

@@ -12,7 +12,6 @@ import {
 import { EditableTextModel } from 'vs/editor/common/model/editableTextModel';
 import { TextModel } from 'vs/editor/common/model/textModel';
 import { IDisposable } from 'vs/base/common/lifecycle';
-import { BulkListenerCallback } from 'vs/base/common/eventEmitter';
 import { LanguageIdentifier } from 'vs/editor/common/modes';
 import { IRawTextSource, RawTextSource } from 'vs/editor/common/model/textSource';
 
@@ -24,20 +23,16 @@ var MODEL_ID = 0;
 export class Model extends EditableTextModel implements IModel {
 
 	public onDidChangeDecorations(listener: (e: IModelDecorationsChangedEvent) => void): IDisposable {
-		return this.addListener(EventType.ModelDecorationsChanged, listener);
+		return this._eventEmitter.addListener(EventType.ModelDecorationsChanged, listener);
 	}
 	public onDidChangeOptions(listener: (e: IModelOptionsChangedEvent) => void): IDisposable {
-		return this.addListener(EventType.ModelOptionsChanged, listener);
+		return this._eventEmitter.addListener(EventType.ModelOptionsChanged, listener);
 	}
 	public onWillDispose(listener: () => void): IDisposable {
-		return this.addListener(EventType.ModelDispose, listener);
+		return this._eventEmitter.addListener(EventType.ModelDispose, listener);
 	}
 	public onDidChangeLanguage(listener: (e: IModelLanguageChangedEvent) => void): IDisposable {
-		return this.addListener(EventType.ModelLanguageChanged, listener);
-	}
-
-	public addBulkListener(listener: BulkListenerCallback): IDisposable {
-		return super.addBulkListener(listener);
+		return this._eventEmitter.addListener(EventType.ModelLanguageChanged, listener);
 	}
 
 	public static createFromString(text: string, options: ITextModelCreationOptions = TextModel.DEFAULT_CREATION_OPTIONS, languageIdentifier: LanguageIdentifier = null, uri: URI = null): Model {
@@ -71,7 +66,7 @@ export class Model extends EditableTextModel implements IModel {
 
 	public dispose(): void {
 		this._isDisposing = true;
-		this.emit(EventType.ModelDispose);
+		this._eventEmitter.emit(EventType.ModelDispose);
 		super.dispose();
 		this._isDisposing = false;
 	}

src/vs/editor/common/model/textModel.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import { OrderGuaranteeEventEmitter } from 'vs/base/common/eventEmitter';
+import { OrderGuaranteeEventEmitter, BulkListenerCallback } from 'vs/base/common/eventEmitter';
 import * as strings from 'vs/base/common/strings';
 import { Position } from 'vs/editor/common/core/position';
 import { Range } from 'vs/editor/common/core/range';
@@ -16,6 +16,7 @@ import { PrefixSumComputer } from 'vs/editor/common/viewModel/prefixSumComputer'
 import { IndentRange, computeRanges } from 'vs/editor/common/model/indentRanges';
 import { TextModelSearch, SearchParams } from 'vs/editor/common/model/textModelSearch';
 import { TextSource, ITextSource, IRawTextSource, RawTextSource } from 'vs/editor/common/model/textSource';
+import { IDisposable } from 'vs/base/common/lifecycle';
 
 const LIMIT_FIND_COUNT = 999;
 export const LONG_LINE_BOUNDARY = 10000;
@@ -25,7 +26,7 @@ export interface ITextModelCreationData {
 	readonly options: editorCommon.TextModelResolvedOptions;
 }
 
-export class TextModel extends OrderGuaranteeEventEmitter implements editorCommon.ITextModel {
+export class TextModel implements editorCommon.ITextModel {
 	private static MODEL_SYNC_LIMIT = 5 * 1024 * 1024; // 5 MB
 	private static MODEL_TOKENIZATION_LIMIT = 20 * 1024 * 1024; // 20 MB
 
@@ -68,6 +69,12 @@ export class TextModel extends OrderGuaranteeEventEmitter implements editorCommo
 		};
 	}
 
+	public addBulkListener(listener: BulkListenerCallback): IDisposable {
+		return this._eventEmitter.addBulkListener(listener);
+	}
+
+	protected readonly _eventEmitter: OrderGuaranteeEventEmitter;
+
 	/*protected*/ _lines: ModelLine[];
 	protected _EOL: string;
 	protected _isDisposed: boolean;
@@ -90,7 +97,7 @@ export class TextModel extends OrderGuaranteeEventEmitter implements editorCommo
 
 	constructor(allowedEventTypes: string[], rawTextSource: IRawTextSource, creationOptions: editorCommon.ITextModelCreationOptions) {
 		allowedEventTypes.push(editorCommon.EventType.ModelRawContentChanged, editorCommon.EventType.ModelOptionsChanged, editorCommon.EventType.ModelContentChanged);
-		super(allowedEventTypes);
+		this._eventEmitter = new OrderGuaranteeEventEmitter(allowedEventTypes);
 
 		const textModelData = TextModel.resolveCreationData(rawTextSource, creationOptions);
 
@@ -152,7 +159,7 @@ export class TextModel extends OrderGuaranteeEventEmitter implements editorCommo
 			}
 		}
 
-		this.emit(editorCommon.EventType.ModelOptionsChanged, e);
+		this._eventEmitter.emit(editorCommon.EventType.ModelOptionsChanged, e);
 	}
 
 	public detectIndentation(defaultInsertSpaces: boolean, defaultTabSize: number): void {
@@ -295,7 +302,7 @@ export class TextModel extends OrderGuaranteeEventEmitter implements editorCommo
 		this._EOL = null;
 		this._BOM = null;
 
-		super.dispose();
+		this._eventEmitter.dispose();
 	}
 
 	private _createContentChangedFlushEvent(): editorCommon.IModelRawContentChangedFlushEvent {
@@ -322,7 +329,7 @@ export class TextModel extends OrderGuaranteeEventEmitter implements editorCommo
 			isFlush: isFlush
 		};
 		if (!this._isDisposing) {
-			this.emit(editorCommon.EventType.ModelContentChanged, e);
+			this._eventEmitter.emit(editorCommon.EventType.ModelContentChanged, e);
 		}
 	}
 
@@ -766,7 +773,7 @@ export class TextModel extends OrderGuaranteeEventEmitter implements editorCommo
 
 	protected _emitModelContentChangedFlushEvent(e: editorCommon.IModelRawContentChangedFlushEvent): void {
 		if (!this._isDisposing) {
-			this.emit(editorCommon.EventType.ModelRawContentChanged, e);
+			this._eventEmitter.emit(editorCommon.EventType.ModelRawContentChanged, e);
 		}
 	}
 

src/vs/editor/common/model/textModelWithDecorations.ts

@@ -199,12 +199,12 @@ export class TextModelWithDecorations extends TextModelWithMarkers implements ed
 		this._assertNotDisposed();
 
 		try {
-			this._beginDeferredEmit();
+			this._eventEmitter.beginDeferredEmit();
 			let decorationsTracker = this._acquireDecorationsTracker();
 			return this._changeDecorations(decorationsTracker, ownerId, callback);
 		} finally {
 			this._releaseDecorationsTracker();
-			this._endDeferredEmit();
+			this._eventEmitter.endDeferredEmit();
 		}
 	}
 
@@ -541,7 +541,7 @@ export class TextModelWithDecorations extends TextModelWithMarkers implements ed
 
 	private emitModelDecorationsChangedEvent(e: editorCommon.IModelDecorationsChangedEvent): void {
 		if (!this._isDisposing) {
-			this.emit(editorCommon.EventType.ModelDecorationsChanged, e);
+			this._eventEmitter.emit(editorCommon.EventType.ModelDecorationsChanged, e);
 		}
 	}
 

src/vs/editor/common/model/textModelWithTokens.ts

@@ -160,7 +160,7 @@ export class TextModelWithTokens extends TextModel implements editorCommon.IToke
 		if (!this._isDisposing) {
 			let e = eventBuilder.build();
 			if (e) {
-				this.emit(editorCommon.EventType.ModelTokensChanged, e);
+				this._eventEmitter.emit(editorCommon.EventType.ModelTokensChanged, e);
 			}
 		}
 
@@ -390,13 +390,13 @@ export class TextModelWithTokens extends TextModel implements editorCommon.IToke
 
 	private emitModelTokensChangedEvent(e: editorCommon.IModelTokensChangedEvent): void {
 		if (!this._isDisposing) {
-			this.emit(editorCommon.EventType.ModelTokensChanged, e);
+			this._eventEmitter.emit(editorCommon.EventType.ModelTokensChanged, e);
 		}
 	}
 
 	private _emitModelModeChangedEvent(e: editorCommon.IModelLanguageChangedEvent): void {
 		if (!this._isDisposing) {
-			this.emit(editorCommon.EventType.ModelLanguageChanged, e);
+			this._eventEmitter.emit(editorCommon.EventType.ModelLanguageChanged, e);
 		}
 	}