use I prefix for header style interfaces instead of Impl suffix

lib/api-client-factory.ts

@@ -1,10 +1,10 @@
-import { HTTPClient } from "./http-client-factory";
+import { IHTTPClient } from "./http-client-factory";
 
-export interface APIClientFactory {
-  create(httpClient: HTTPClient): APIClient;
+export interface IAPIClientFactory {
+  create(httpClient: IHTTPClient): IAPIClient;
 }
 
-export interface APIClient {
+export interface IAPIClient {
   version(): Promise<VersionInfo>;
   listTabs(): Promise<Tab[]>;
   newTab(url?: string): Promise<Tab>;
@@ -30,16 +30,16 @@ export interface VersionInfo {
   "WebKit-Version": string;
 }
 
-export default class APIClientFactoryImpl implements APIClientFactory {
-  create(httpClient: HTTPClient): APIClient {
-    return new APIClientImpl(httpClient);
+export default class APIClientFactory implements IAPIClientFactory {
+  create(httpClient: IHTTPClient): IAPIClient {
+    return new APIClient(httpClient);
   }
 }
 
-class APIClientImpl implements APIClient {
-  httpClient: HTTPClient;
+class APIClient implements IAPIClient {
+  httpClient: IHTTPClient;
 
-  constructor(httpClient: HTTPClient) {
+  constructor(httpClient: IHTTPClient) {
     this.httpClient = httpClient;
   }
 

lib/browser-resolver.ts

@@ -1,6 +1,6 @@
 import * as os from "os";
 
-export interface BrowserResolver {
+export interface IBrowserResolver {
   resolve(browserType: string, options?: ResolveOptions): ExecutableInfo;
 }
 
@@ -29,7 +29,7 @@ const APP_NAMES = {
   }
 };
 
-export default class BrowserResolverImpl implements BrowserResolver {
+export default class BrowserResolver implements IBrowserResolver {
   get platform() {
     switch (os.platform()) {
       case "darwin": return "darwin";
@@ -92,7 +92,7 @@ export default class BrowserResolverImpl implements BrowserResolver {
 
   resolveChromeApplication(browserType: string): string {
     if (this.platform !== "darwin") {
-      // TODO other platforms
+      // TODO other platforms, can use exact or build variants
       return;
     }
     if (browserType === "canary") {

lib/browser-spawner.ts

@@ -5,23 +5,24 @@ import * as path from "path";
 
 const PORT_FILENAME = "DevToolsActivePort";
 
-export interface BrowserSpawner {
-  spawn(executablePath: string, dataDir: string, isContentShell: boolean): Promise<BrowserProcess>;
+export interface IBrowserSpawner {
+  spawn(executablePath: string, dataDir: string, isContentShell: boolean): Promise<IBrowserProcess>;
 }
 
-export interface BrowserProcess extends Disposable {
+export interface IBrowserProcess extends Disposable {
   remoteDebuggingPort: number;
-  // throws if process has exited or there was an error
+  dataDir: string;
+  /** throws if process has exited or there has been an error */
   validate();
 }
 
-export default class BrowserSpawnerImpl implements BrowserSpawner {
-  async spawn(executablePath: string, dataDir: string, isContentShell: boolean): Promise<BrowserProcess> {
+export default class BrowserSpawner implements IBrowserSpawner {
+  async spawn(executablePath: string, dataDir: string, isContentShell: boolean): Promise<IBrowserProcess> {
     let portFile = path.join(dataDir, PORT_FILENAME);
     // delete port file before launching
     await tryDeleteFile(portFile);
     let args = this.getArguments(dataDir, isContentShell);
-    let process: BrowserProcess = new BrowserProcessImpl(executablePath, args);
+    let process: IBrowserProcess = new BrowserProcess(executablePath, args);
     try {
       let port: number = 0;
       let tries = 0;
@@ -34,6 +35,7 @@ export default class BrowserSpawnerImpl implements BrowserSpawner {
         process.validate();
         if (port > 0) {
           process.remoteDebuggingPort = port;
+          process.dataDir = dataDir;
           break;
         }
       }
@@ -81,12 +83,13 @@ export default class BrowserSpawnerImpl implements BrowserSpawner {
   }
 }
 
-class BrowserProcessImpl implements BrowserProcess {
+class BrowserProcess implements IBrowserProcess {
   process: ChildProcess;
   pid: number;
   lastError: Error;
   hasExited: boolean = false;
   remoteDebuggingPort: number = 0;
+  dataDir: string;
 
   constructor(executablePath, args) {
     let process = spawn(executablePath, args);

lib/debugging-protocol-factory.ts

@@ -1,13 +1,13 @@
 import { EventNotifier } from "./common";
-import { WebSocketDelegate } from "./web-socket-opener";
+import { IWebSocketDelegate } from "./web-socket-opener";
 import { EventEmitter } from "events";
 import * as Protocol from "./protocol";
 
-export interface DebuggingProtocolClientFactory {
+export interface IDebuggingProtocolClientFactory {
   create();
 }
 
-export interface DebuggingProtocolClient extends EventNotifier, WebSocketDelegate {
+export interface IDebuggingProtocolClient extends EventNotifier, IWebSocketDelegate {
   send(command: string, params?: any): Promise<any>;
   domains(protocol: Protocol.Protocol): any;
 }
@@ -42,13 +42,13 @@ interface Message extends EventMessage, SuccessResponseMessage, ErrorResponseMes
 
 interface CommandResponseMessage extends SuccessResponseMessage, ErrorResponseMessage {}
 
-export default class DebuggingProtocolFactoryImpl implements DebuggingProtocolClientFactory {
-  create(): DebuggingProtocolClient {
-    return new DebuggingProtocolImpl();
+export default class DebuggingProtocolFactory implements IDebuggingProtocolClientFactory {
+  create(): IDebuggingProtocolClient {
+    return new DebuggingProtocol();
   }
 }
 
-class DebuggingProtocolImpl extends EventEmitter implements DebuggingProtocolClient {
+class DebuggingProtocol extends EventEmitter implements IDebuggingProtocolClient {
   seq = 0;
   pendingRequests = new Map<number, CommandRequest>();
   socket: {
@@ -115,10 +115,10 @@ class DebuggingProtocolImpl extends EventEmitter implements DebuggingProtocolCli
 }
 
 class Domain {
-  private _client: DebuggingProtocolClient;
+  private _client: IDebuggingProtocolClient;
   private _domain: Protocol.Domain;
 
-  constructor(client: DebuggingProtocolClient, domain: Protocol.Domain) {
+  constructor(client: IDebuggingProtocolClient, domain: Protocol.Domain) {
     this._client = client;
     this._domain = domain;
     if (domain.commands) {

lib/http-client-factory.ts

@@ -1,21 +1,21 @@
 import { EventNotifier, eventPromise } from "./common";
 import { get, ClientRequest, IncomingMessage } from "http";
 
-export interface HTTPClientFactory {
-  create(host: string, port: number): HTTPClient;
+export interface IHTTPClientFactory {
+  create(host: string, port: number): IHTTPClient;
 }
 
-export interface HTTPClient {
+export interface IHTTPClient {
   get(path: string): Promise<string>;
 }
 
-export default class HTTPClientFactoryImpl implements HTTPClientFactory {
-  create(host: string, port: number): HTTPClient {
-    return new HTTPClientImpl(host, port);
+export default class HTTPClientFactory implements IHTTPClientFactory {
+  create(host: string, port: number): IHTTPClient {
+    return new HTTPClient(host, port);
   }
 }
 
-class HTTPClientImpl implements HTTPClient {
+class HTTPClient implements IHTTPClient {
   host: string;
   port: number;
 

lib/index.ts

@@ -4,9 +4,8 @@ export * from "./browser-spawner";
 export * from "./debugging-protocol-factory";
 export * from "./http-client-factory";
 export * from "./http-client-factory";
-export * from "./session";
 export * from "./web-socket-opener";
 export * from "./tmpdir-creator";
-
-export { default as ProtocolCodegen } from "./protocol-codegen";
+export * from "./session";
 export { default as createSession } from "./session";
+export { default as ProtocolCodegen } from "./protocol-codegen";

lib/session.ts

@@ -1,56 +1,56 @@
 import {
-  default as DefaultBrowserResolver,
-  BrowserResolver,
-  ResolveOptions
+  default as BrowserResolver,
+  IBrowserResolver,
+  IResolveOptions
 } from "./browser-resolver";
 import {
-  default as DefaultBrowserSpawner,
-  BrowserSpawner,
-  BrowserProcess
+  default as BrowserSpawner,
+  IBrowserSpawner,
+  IBrowserProcess
 } from "./browser-spawner";
 import {
-  default as DefaultTmpDirCreator,
-  TmpDirCreator
+  default as TmpDirCreator,
+  ITmpDirCreator
 } from "./tmpdir-creator";
 import {
-  default as DefaultHTTPClientFactory,
-  HTTPClientFactory,
-  HTTPClient
+  default as HTTPClientFactory,
+  IHTTPClientFactory,
+  IHTTPClient
 } from "./http-client-factory";
 import {
-  default as DefaultAPIClientFactory,
-  APIClientFactory,
-  APIClient
+  default as APIClientFactory,
+  IAPIClientFactory,
+  IAPIClient
 } from "./api-client-factory";
 import {
-  default as DefaultWebSocketOpener,
-  WebSocketOpener
+  default as WebSocketOpener,
+  IWebSocketOpener
 } from "./web-socket-opener";
 import {
-  default as DefaultDebuggingProtocolClientFactory,
-  DebuggingProtocolClientFactory,
-  DebuggingProtocolClient
+  default as DebuggingProtocolClientFactory,
+  IDebuggingProtocolClientFactory,
+  IDebuggingProtocolClient
 } from "./debugging-protocol-factory";
 import { Disposable } from "./common";
 
 /**
  * The session is a factory for the various debugging tools/clients that disposes them at the end.
  */
-export interface Session extends Disposable {
-  spawnBrowser(browserType: string, options?: ResolveOptions): Promise<BrowserProcess>;
-  createAPIClient(host, port): APIClient;
-  openDebuggingProtocol(webSocketDebuggerUrl: string): Promise<DebuggingProtocolClient>;
+export interface ISession extends Disposable {
+  spawnBrowser(browserType: string, options?: IResolveOptions): Promise<IBrowserProcess>;
+  createAPIClient(host, port): IAPIClient;
+  openDebuggingProtocol(webSocketDebuggerUrl: string): Promise<IDebuggingProtocolClient>;
 }
 
-export default async function createSession<T>(cb: (session: Session) => T | PromiseLike<T>): Promise<T> {
-  let session = new SessionImpl(
-    new DefaultBrowserResolver(),
-    new DefaultTmpDirCreator(),
-    new DefaultBrowserSpawner(),
-    new DefaultHTTPClientFactory(),
-    new DefaultAPIClientFactory(),
-    new DefaultWebSocketOpener(),
-    new DefaultDebuggingProtocolClientFactory()
+export default async function createSession<T>(cb: (session: ISession) => T | PromiseLike<T>): Promise<T> {
+  let session = new Session(
+    new BrowserResolver(),
+    new TmpDirCreator(),
+    new BrowserSpawner(),
+    new HTTPClientFactory(),
+    new APIClientFactory(),
+    new WebSocketOpener(),
+    new DebuggingProtocolClientFactory()
   );
   try {
     return await cb(session);
@@ -59,25 +59,25 @@ export default async function createSession<T>(cb: (session: Session) => T | Pro
   }
 }
 
-class SessionImpl {
+class Session {
   disposables: Disposable[] = [];
 
-  browserResolver: BrowserResolver;
-  tmpDirCreator: TmpDirCreator;
-  browserSpawner: BrowserSpawner;
-  httpClientFactory: HTTPClientFactory;
-  apiClientFactory: APIClientFactory;
-  webSocketOpener: WebSocketOpener;
-  debuggingProtocolFactory: DebuggingProtocolClientFactory;
+  browserResolver: IBrowserResolver;
+  tmpDirCreator: ITmpDirCreator;
+  browserSpawner: IBrowserSpawner;
+  httpClientFactory: IHTTPClientFactory;
+  apiClientFactory: IAPIClientFactory;
+  webSocketOpener: IWebSocketOpener;
+  debuggingProtocolFactory: IDebuggingProtocolClientFactory;
 
   constructor(
-    browserResolver: BrowserResolver,
-    tmpDirCreator: TmpDirCreator,
-    browserSpawner: BrowserSpawner,
-    httpClientFactory: HTTPClientFactory,
-    apiClientFactory: APIClientFactory,
-    webSocketOpener: WebSocketOpener,
-    debuggingProtocolFactory: DebuggingProtocolClientFactory
+    browserResolver: IBrowserResolver,
+    tmpDirCreator: ITmpDirCreator,
+    browserSpawner: IBrowserSpawner,
+    httpClientFactory: IHTTPClientFactory,
+    apiClientFactory: IAPIClientFactory,
+    webSocketOpener: IWebSocketOpener,
+    debuggingProtocolFactory: IDebuggingProtocolClientFactory
   ) {
     this.browserResolver = browserResolver;
     this.tmpDirCreator = tmpDirCreator;
@@ -88,7 +88,7 @@ class SessionImpl {
     this.debuggingProtocolFactory = debuggingProtocolFactory;
   }
 
-  async spawnBrowser(browserType: string, options?: ResolveOptions): Promise<BrowserProcess> {
+  async spawnBrowser(browserType: string, options?: IResolveOptions): Promise<IBrowserProcess> {
     let browser = this.browserResolver.resolve(browserType, options);
     let tmpDir = await this.tmpDirCreator.create();
     this.disposables.push(tmpDir);
@@ -97,11 +97,11 @@ class SessionImpl {
     return process;
   }
 
-  createAPIClient(host: string, port: number): APIClient {
+  createAPIClient(host: string, port: number): IAPIClient {
     return this.apiClientFactory.create(this.httpClientFactory.create(host, port));
   }
 
-  async openDebuggingProtocol(webSocketDebuggerUrl: string): Promise<DebuggingProtocolClient> {
+  async openDebuggingProtocol(webSocketDebuggerUrl: string): Promise<IDebuggingProtocolClient> {
     let debuggingProtocol = this.debuggingProtocolFactory.create();
     let connection = await this.webSocketOpener.open(webSocketDebuggerUrl, debuggingProtocol);
     this.disposables.push(connection);

lib/tmpdir-creator.ts

@@ -4,25 +4,25 @@ import * as path from "path";
 import * as mktemp from "mktemp";
 import * as rimraf from "rimraf";
 
-export interface TmpDirCreator {
-  create(): Promise<TmpDir>;
+export interface ITmpDirCreator {
+  create(): Promise<ITmpDir>;
 }
 
-export interface TmpDir extends Disposable {
+export interface ITmpDir extends Disposable {
   path: string;
 }
 
-export default class TmpDirCreatorImpl implements TmpDirCreator {
+export default class TmpDirCreator implements ITmpDirCreator {
   async create(): Promise<Disposable> {
     let templatePath = path.join(tmpdir(), "tmpXXXXXX");
     let tmpDirPath = await new Promise<string>((resolve, reject) => {
       mktemp.createDir(templatePath, (err, path) => err ? reject(err) : resolve(path));
     });
-    return new TmpDirImpl(tmpDirPath);
+    return new TmpDir(tmpDirPath);
   }
 }
 
-class TmpDirImpl implements TmpDir {
+class TmpDir implements ITmpDir {
   path: string;
 
   constructor(path: string) {