Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

chore: move action instrumentation per-context #3908

Merged
merged 1 commit into from
Sep 17, 2020
Merged

chore: move action instrumentation per-context #3908

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
12 changes: 6 additions & 6 deletions src/debug/debugController.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -14,14 +14,17 @@
* limitations under the License.
*/

import { BrowserContext } from '../server/browserContext';
import { BrowserContext, ContextListener, contextListeners } from '../server/browserContext';
import * as frames from '../server/frames';
import { Page } from '../server/page';
import { ActionMetadata, ActionResult, InstrumentingAgent } from '../server/instrumentation';
import { isDebugMode } from '../utils/utils';
import * as debugScriptSource from '../generated/debugScriptSource';

export class DebugController implements InstrumentingAgent {
export function installDebugController() {
contextListeners.add(new DebugController());
}

class DebugController implements ContextListener {
private async ensureInstalledInFrame(frame: frames.Frame) {
try {
await frame.extendInjectedScript(debugScriptSource.source);
Expand All @@ -41,7 +44,4 @@ export class DebugController implements InstrumentingAgent {

async onContextDestroyed(context: BrowserContext): Promise<void> {
}

async onAfterAction(result: ActionResult, metadata?: ActionMetadata): Promise<void> {
}
}
73 changes: 31 additions & 42 deletions src/dispatchers/elementHandlerDispatcher.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -20,8 +20,7 @@ import * as channels from '../protocol/channels';
import { DispatcherScope, lookupNullableDispatcher } from './dispatcher';
import { JSHandleDispatcher, serializeResult, parseArgument } from './jsHandleDispatcher';
import { FrameDispatcher } from './frameDispatcher';
import { runAbortableTask } from '../server/progress';
import { ActionMetadata } from '../server/instrumentation';
import { runAction } from '../server/browserContext';

export function createHandle(scope: DispatcherScope, handle: js.JSHandle): JSHandleDispatcher {
return handle.asElement() ? new ElementHandleDispatcher(scope, handle.asElement()!) : new JSHandleDispatcher(scope, handle);
Expand Down Expand Up @@ -76,82 +75,72 @@ export class ElementHandleDispatcher extends JSHandleDispatcher implements chann
}

async hover(params: channels.ElementHandleHoverParams, metadata?: channels.Metadata): Promise<void> {
const actionMetadata: ActionMetadata = { ...metadata, type: 'hover', target: this._elementHandle, page: this._elementHandle._page };
return runAbortableTask(async progress => {
return await this._elementHandle.hover(progress, params);
}, this._elementHandle._page._timeoutSettings.timeout(params), actionMetadata);
return runAction(async controller => {
return await this._elementHandle.hover(controller, params);
}, { ...metadata, type: 'hover', target: this._elementHandle, page: this._elementHandle._page });
}

async click(params: channels.ElementHandleClickParams, metadata?: channels.Metadata): Promise<void> {
const actionMetadata: ActionMetadata = { ...metadata, type: 'click', target: this._elementHandle, page: this._elementHandle._page };
return runAbortableTask(async progress => {
return await this._elementHandle.click(progress, params);
}, this._elementHandle._page._timeoutSettings.timeout(params), actionMetadata);
return runAction(async controller => {
return await this._elementHandle.click(controller, params);
}, { ...metadata, type: 'click', target: this._elementHandle, page: this._elementHandle._page });
}

async dblclick(params: channels.ElementHandleDblclickParams, metadata?: channels.Metadata): Promise<void> {
const actionMetadata: ActionMetadata = { ...metadata, type: 'dblclick', target: this._elementHandle, page: this._elementHandle._page };
return runAbortableTask(async progress => {
return await this._elementHandle.dblclick(progress, params);
}, this._elementHandle._page._timeoutSettings.timeout(params), actionMetadata);
return runAction(async controller => {
return await this._elementHandle.dblclick(controller, params);
}, { ...metadata, type: 'dblclick', target: this._elementHandle, page: this._elementHandle._page });
}

async selectOption(params: channels.ElementHandleSelectOptionParams, metadata?: channels.Metadata): Promise<channels.ElementHandleSelectOptionResult> {
const actionMetadata: ActionMetadata = { ...metadata, type: 'selectOption', target: this._elementHandle, page: this._elementHandle._page };
return runAbortableTask(async progress => {
return runAction(async controller => {
const elements = (params.elements || []).map(e => (e as ElementHandleDispatcher)._elementHandle);
return { values: await this._elementHandle.selectOption(progress, elements, params.options || [], params) };
}, this._elementHandle._page._timeoutSettings.timeout(params), actionMetadata);
return { values: await this._elementHandle.selectOption(controller, elements, params.options || [], params) };
}, { ...metadata, type: 'selectOption', target: this._elementHandle, page: this._elementHandle._page });
}

async fill(params: channels.ElementHandleFillParams, metadata?: channels.Metadata): Promise<void> {
const actionMetadata: ActionMetadata = { ...metadata, type: 'fill', value: params.value, target: this._elementHandle, page: this._elementHandle._page };
return runAbortableTask(async progress => {
return await this._elementHandle.fill(progress, params.value, params);
}, this._elementHandle._page._timeoutSettings.timeout(params), actionMetadata);
return runAction(async controller => {
return await this._elementHandle.fill(controller, params.value, params);
}, { ...metadata, type: 'fill', value: params.value, target: this._elementHandle, page: this._elementHandle._page });
}

async selectText(params: channels.ElementHandleSelectTextParams): Promise<void> {
await this._elementHandle.selectText(params);
}

async setInputFiles(params: channels.ElementHandleSetInputFilesParams, metadata?: channels.Metadata): Promise<void> {
const actionMetadata: ActionMetadata = { ...metadata, type: 'setInputFiles', target: this._elementHandle, page: this._elementHandle._page };
return runAbortableTask(async progress => {
return await this._elementHandle.setInputFiles(progress, params.files, params);
}, this._elementHandle._page._timeoutSettings.timeout(params), actionMetadata);
return runAction(async controller => {
return await this._elementHandle.setInputFiles(controller, params.files, params);
}, { ...metadata, type: 'setInputFiles', target: this._elementHandle, page: this._elementHandle._page });
}

async focus(): Promise<void> {
await this._elementHandle.focus();
}

async type(params: channels.ElementHandleTypeParams, metadata?: channels.Metadata): Promise<void> {
const actionMetadata: ActionMetadata = { ...metadata, type: 'type', value: params.text, target: this._elementHandle, page: this._elementHandle._page };
return runAbortableTask(async progress => {
return await this._elementHandle.type(progress, params.text, params);
}, this._elementHandle._page._timeoutSettings.timeout(params), actionMetadata);
return runAction(async controller => {
return await this._elementHandle.type(controller, params.text, params);
}, { ...metadata, type: 'type', value: params.text, target: this._elementHandle, page: this._elementHandle._page });
}

async press(params: channels.ElementHandlePressParams, metadata?: channels.Metadata): Promise<void> {
const actionMetadata: ActionMetadata = { ...metadata, type: 'press', value: params.key, target: this._elementHandle, page: this._elementHandle._page };
return runAbortableTask(async progress => {
return await this._elementHandle.press(progress, params.key, params);
}, this._elementHandle._page._timeoutSettings.timeout(params), actionMetadata);
return runAction(async controller => {
return await this._elementHandle.press(controller, params.key, params);
}, { ...metadata, type: 'press', value: params.key, target: this._elementHandle, page: this._elementHandle._page });
}

async check(params: channels.ElementHandleCheckParams, metadata?: channels.Metadata): Promise<void> {
const actionMetadata: ActionMetadata = { ...metadata, type: 'check', target: this._elementHandle, page: this._elementHandle._page };
return runAbortableTask(async progress => {
return await this._elementHandle.check(progress, params);
}, this._elementHandle._page._timeoutSettings.timeout(params), actionMetadata);
return runAction(async controller => {
return await this._elementHandle.check(controller, params);
}, { ...metadata, type: 'check', target: this._elementHandle, page: this._elementHandle._page });
}

async uncheck(params: channels.ElementHandleUncheckParams, metadata?: channels.Metadata): Promise<void> {
const actionMetadata: ActionMetadata = { ...metadata, type: 'uncheck', target: this._elementHandle, page: this._elementHandle._page };
return runAbortableTask(async progress => {
return await this._elementHandle.uncheck(progress, params);
}, this._elementHandle._page._timeoutSettings.timeout(params), actionMetadata);
return runAction(async controller => {
return await this._elementHandle.uncheck(controller, params);
}, { ...metadata, type: 'uncheck', target: this._elementHandle, page: this._elementHandle._page });
}

async boundingBox(): Promise<channels.ElementHandleBoundingBoxResult> {
Expand Down
87 changes: 37 additions & 50 deletions src/dispatchers/frameDispatcher.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -20,8 +20,7 @@ import { Dispatcher, DispatcherScope, lookupNullableDispatcher, existingDispatch
import { ElementHandleDispatcher, createHandle } from './elementHandlerDispatcher';
import { parseArgument, serializeResult } from './jsHandleDispatcher';
import { ResponseDispatcher, RequestDispatcher } from './networkDispatchers';
import { ActionMetadata } from '../server/instrumentation';
import { ProgressController, runAbortableTask } from '../server/progress';
import { runAction } from '../server/browserContext';

export class FrameDispatcher extends Dispatcher<Frame, channels.FrameInitializer> implements channels.FrameChannel {
private _frame: Frame;
Expand Down Expand Up @@ -54,10 +53,9 @@ export class FrameDispatcher extends Dispatcher<Frame, channels.FrameInitializer
}

async goto(params: channels.FrameGotoParams, metadata?: channels.Metadata): Promise<channels.FrameGotoResult> {
const page = this._frame._page;
const actionMetadata: ActionMetadata = { ...metadata, type: 'goto', value: params.url, page };
const controller = new ProgressController(page._timeoutSettings.navigationTimeout(params), actionMetadata);
return { response: lookupNullableDispatcher<ResponseDispatcher>(await this._frame.goto(controller, params.url, params)) };
return await runAction(async controller => {
return { response: lookupNullableDispatcher<ResponseDispatcher>(await this._frame.goto(controller, params.url, params)) };
}, { ...metadata, type: 'goto', value: params.url, page: this._frame._page });
}

async frameElement(): Promise<channels.FrameFrameElementResult> {
Expand Down Expand Up @@ -102,10 +100,9 @@ export class FrameDispatcher extends Dispatcher<Frame, channels.FrameInitializer
}

async setContent(params: channels.FrameSetContentParams, metadata?: channels.Metadata): Promise<void> {
const page = this._frame._page;
const actionMetadata: ActionMetadata = { ...metadata, type: 'setContent', value: params.html, page };
const controller = new ProgressController(page._timeoutSettings.navigationTimeout(params), actionMetadata);
return await this._frame.setContent(controller, params.html, params);
return await runAction(async controller => {
return await this._frame.setContent(controller, params.html, params);
}, { ...metadata, type: 'setContent', value: params.html, page: this._frame._page });
}

async addScriptTag(params: channels.FrameAddScriptTagParams): Promise<channels.FrameAddScriptTagResult> {
Expand All @@ -117,24 +114,21 @@ export class FrameDispatcher extends Dispatcher<Frame, channels.FrameInitializer
}

async click(params: channels.FrameClickParams, metadata?: channels.Metadata): Promise<void> {
const actionMetadata: ActionMetadata = { ...metadata, type: 'click', target: params.selector, page: this._frame._page };
return runAbortableTask(async progress => {
return await this._frame.click(progress, params.selector, params);
}, this._frame._page._timeoutSettings.timeout(params), actionMetadata);
return runAction(async controller => {
return await this._frame.click(controller, params.selector, params);
}, { ...metadata, type: 'click', target: params.selector, page: this._frame._page });
}

async dblclick(params: channels.FrameDblclickParams, metadata?: channels.Metadata): Promise<void> {
const actionMetadata: ActionMetadata = { ...metadata, type: 'dblclick', target: params.selector, page: this._frame._page };
return runAbortableTask(async progress => {
return await this._frame.dblclick(progress, params.selector, params);
}, this._frame._page._timeoutSettings.timeout(params), actionMetadata);
return runAction(async controller => {
return await this._frame.dblclick(controller, params.selector, params);
}, { ...metadata, type: 'dblclick', target: params.selector, page: this._frame._page });
}

async fill(params: channels.FrameFillParams, metadata?: channels.Metadata): Promise<void> {
const actionMetadata: ActionMetadata = { ...metadata, type: 'fill', value: params.value, target: params.selector, page: this._frame._page };
return runAbortableTask(async progress => {
return await this._frame.fill(progress, params.selector, params.value, params);
}, this._frame._page._timeoutSettings.timeout(params), actionMetadata);
return runAction(async controller => {
return await this._frame.fill(controller, params.selector, params.value, params);
}, { ...metadata, type: 'fill', value: params.value, target: params.selector, page: this._frame._page });
}

async focus(params: channels.FrameFocusParams): Promise<void> {
Expand All @@ -160,53 +154,46 @@ export class FrameDispatcher extends Dispatcher<Frame, channels.FrameInitializer
}

async hover(params: channels.FrameHoverParams, metadata?: channels.Metadata): Promise<void> {
const actionMetadata: ActionMetadata = { ...metadata, type: 'hover', target: params.selector, page: this._frame._page };
return runAbortableTask(async progress => {
return await this._frame.hover(progress, params.selector, params);
}, this._frame._page._timeoutSettings.timeout(params), actionMetadata);
return runAction(async controller => {
return await this._frame.hover(controller, params.selector, params);
}, { ...metadata, type: 'hover', target: params.selector, page: this._frame._page });
}

async selectOption(params: channels.FrameSelectOptionParams, metadata?: channels.Metadata): Promise<channels.FrameSelectOptionResult> {
const actionMetadata: ActionMetadata = { ...metadata, type: 'selectOption', target: params.selector, page: this._frame._page };
return runAbortableTask(async progress => {
return runAction(async controller => {
const elements = (params.elements || []).map(e => (e as ElementHandleDispatcher)._elementHandle);
return { values: await this._frame.selectOption(progress, params.selector, elements, params.options || [], params) };
}, this._frame._page._timeoutSettings.timeout(params), actionMetadata);
return { values: await this._frame.selectOption(controller, params.selector, elements, params.options || [], params) };
}, { ...metadata, type: 'selectOption', target: params.selector, page: this._frame._page });
}

async setInputFiles(params: channels.FrameSetInputFilesParams, metadata?: channels.Metadata): Promise<void> {
const actionMetadata: ActionMetadata = { ...metadata, type: 'setInputFiles', target: params.selector, page: this._frame._page };
return runAbortableTask(async progress => {
return await this._frame.setInputFiles(progress, params.selector, params.files, params);
}, this._frame._page._timeoutSettings.timeout(params), actionMetadata);
return runAction(async controller => {
return await this._frame.setInputFiles(controller, params.selector, params.files, params);
}, { ...metadata, type: 'setInputFiles', target: params.selector, page: this._frame._page });
}

async type(params: channels.FrameTypeParams, metadata?: channels.Metadata): Promise<void> {
const actionMetadata: ActionMetadata = { ...metadata, type: 'type', value: params.text, target: params.selector, page: this._frame._page };
return runAbortableTask(async progress => {
return await this._frame.type(progress, params.selector, params.text, params);
}, this._frame._page._timeoutSettings.timeout(params), actionMetadata);
return runAction(async controller => {
return await this._frame.type(controller, params.selector, params.text, params);
}, { ...metadata, type: 'type', value: params.text, target: params.selector, page: this._frame._page });
}

async press(params: channels.FramePressParams, metadata?: channels.Metadata): Promise<void> {
const actionMetadata: ActionMetadata = { ...metadata, type: 'press', value: params.key, target: params.selector, page: this._frame._page };
return runAbortableTask(async progress => {
return await this._frame.press(progress, params.selector, params.key, params);
}, this._frame._page._timeoutSettings.timeout(params), actionMetadata);
return runAction(async controller => {
return await this._frame.press(controller, params.selector, params.key, params);
}, { ...metadata, type: 'press', value: params.key, target: params.selector, page: this._frame._page });
}

async check(params: channels.FrameCheckParams, metadata?: channels.Metadata): Promise<void> {
const actionMetadata: ActionMetadata = { ...metadata, type: 'check', target: params.selector, page: this._frame._page };
return runAbortableTask(async progress => {
return await this._frame.check(progress, params.selector, params);
}, this._frame._page._timeoutSettings.timeout(params), actionMetadata);
return runAction(async controller => {
return await this._frame.check(controller, params.selector, params);
}, { ...metadata, type: 'check', target: params.selector, page: this._frame._page });
}

async uncheck(params: channels.FrameUncheckParams, metadata?: channels.Metadata): Promise<void> {
const actionMetadata: ActionMetadata = { ...metadata, type: 'uncheck', target: params.selector, page: this._frame._page };
return runAbortableTask(async progress => {
return await this._frame.uncheck(progress, params.selector, params);
}, this._frame._page._timeoutSettings.timeout(params), actionMetadata);
return runAction(async controller => {
return await this._frame.uncheck(controller, params.selector, params);
}, { ...metadata, type: 'uncheck', target: params.selector, page: this._frame._page });
}

async waitForFunction(params: channels.FrameWaitForFunctionParams): Promise<channels.FrameWaitForFunctionResult> {
Expand Down
Loading