[Devtools] Added product entry tests for network

third_party/WebKit/LayoutTests/http/tests/inspector/page-mock.js

 var initialize_EmptyPageMock = function() {
 
 var id = 0;
 
 function nextId(prefix) {
     return (prefix || '') + (++id);
 }
 
 InspectorTest.connectToPage = function(targetName, pageMock, makeMainTarget) {
     var mockTarget = SDK.targetManager.createTarget(nextId('mock-target-'), targetName, pageMock.capabilities(), params => pageMock.createConnection(params));
     if (makeMainTarget) {
         SDK.targetManager._targets = SDK.targetManager._targets.filter(target => target !== mockTarget);
         SDK.targetManager._targets.unshift(mockTarget);
     }
     return mockTarget;
 }
 
 InspectorTest.PageMock = class {
     constructor(url) {
         this._url = url;
-        this._capabilities = SDK.Target.Capability.DOM | SDK.Target.Capability.JS | SDK.Target.Capability.Browser;
+        this._capabilities = SDK.Target.Capability.DOM | SDK.Target.Capability.JS | SDK.Target.Capability.Browser | SDK.Target.Capability.Network;
         /** @type {!Set<string>} */
         this._enabledDomains = new Set();
 
         this._mainFrame = {
             id: nextId(),
             loaderId: nextId(),
             mimeType: 'text/html',
             securityOrigin: this._url,
             url: this._url
         };
 
         this._executionContexts = [];
         this._executionContexts.push(this._createExecutionContext(this._mainFrame, false));
 
         this._scripts = [];
         this._scriptContents = new Map();
 
+        this._childFrames = [];
+        this._pageGetResourceTreeHasRan = false;
+
         this._dispatchMap = {
             'Debugger.enable': this._debuggerEnable,
             'Debugger.getScriptSource': this._debuggerGetScriptSource,
             'Debugger.setBlackboxPatterns': (id, params) => this._sendResponse(id, {}),
             'Runtime.enable': this._runtimeEnable,
             'Page.enable': this._pageEnable,
             'Page.getResourceTree': this._pageGetResourceTree,
+            'Network.enable': this._networkEnable
         };
     }
 
     capabilities() {
         return this._capabilities;
     }
 
     disableDOMCapability() {
         this._capabilities = this._capabilities & (~SDK.Target.Capability.DOM);
     }
@@ skipping 54 matching lines @@
         this._fireEvent('Page.domContentEventFired', {timestamp: Date.now() / 1000});
     }
 
     close() {
         if (this._connection) {
             this._connection.disconnect();
             this._connection = null;
         }
     }
 
+    /**
+     * @param {string} url
+     * @return {!Promise<string>} frameId
+     */
+    addFrame(url) {
+        console.assert(!this._pageGetResourceTreeHasRan, "Cannot add frames after getResourceTreeTree has ran.");

[dgozman, 2017/05/10 22:57:14]

InspectorTest.completeTest here so we see the test failing.

+        var frameId = nextId('page-');
+        this._childFrames.push({
+            id: frameId,
+            loaderId: this._mainFrame.loaderId,

[dgozman, 2017/05/10 22:57:14]

loaderId should be unique.

+            url: url,
+            securityOrigin: url,
+            mimeType: "text/html"
+        });
+        return frameId;
+    }
+
+
+    /**
+     * @param {string} url
+     * @param {!SDK.ResourceTreeFrame=} frame
+     * @return {!Promise<string>}

[dgozman, 2017/05/10 22:57:14]

Why return Promise? I think we should waitForRequest instead, using the same
helper you'd use for real backend test.

+     */
+    requestWillBeSent(url, frame) {

[dgozman, 2017/05/10 22:57:14]

Let's call this sendXHR and issue responseReceived and loadingFinished as well.

+        var requestId = nextId('network-');
+        return this._fireEvent('Network.requestWillBeSent', {
+            requestId: requestId,
+            frameId: (frame || this._mainFrame).id,
+            loaderId: this._mainFrame.loaderId,
+            documentURL: this._mainFrame.url,
+            request: {
+                url: url,
+                method: 'GET',
+                headers: {},
+                initialPriority: 'Medium',
+                referrerPolicy: 'origin'
+            },
+            timestamp: 0,
+            initiator: {
+                name: 'other'
+            },
+            type: "Other"
+        }).then(() => requestId);
+    }
+
+
     _createExecutionContext(frame, isContentScript) {
         return {
             id: nextId(),
             auxData: {isDefault: !isContentScript, frameId: frame.id },
             origin: frame.securityOrigin,
             name: '',
         };
     }
 
     // -------------------------------------------------------------------------
     // Command Handlers
     // -------------------------------------------------------------------------
 
+    _networkEnable(id, params) {
+        this._enabledDomains.add('Network');
+        this._sendResponse(id, {});
+    }
+
     _debuggerEnable(id, params) {
         this._enabledDomains.add('Debugger');
         this._sendResponse(id, {});
         for (var script of this._scripts)
             this._fireEvent('Debugger.scriptParsed', script);
     }
 
     _debuggerGetScriptSource(id, params) {
         if (!this._scriptContents.has(params.scriptId)) {
             this._sendResponse(id, undefined, {
@@ skipping 12 matching lines @@
         for (var context of this._executionContexts)
             this._fireEvent('Runtime.executionContextCreated', {context: context});
     }
 
     _pageEnable(id, params) {
         this._enabledDomains.add('Page');
         this._sendResponse(id, {});
     }
 
     _pageGetResourceTree(id, params) {
+        this._pageGetResourceTreeHasRan = true;
+        var childFrames = this._childFrames.map(frame => ({frame: frame, resources: []}));
         var result = {
             frameTree: {
                 frame: this._mainFrame,
+                childFrames: childFrames,
                 resources: []

[dgozman, 2017/05/10 22:57:14]

Let's report html resource. Or add TODO for it.

             }
         }
         this._sendResponse(id, result);
     }
 
     _isSupportedDomain(methodName) {
         var domain = methodName.split('.')[0];
         if (domain === 'Page')
             return !!(this._capabilities & SDK.Target.Capability.DOM);
         return true;
     }
 
     _dispatch(id, methodName, params, message) {
         var handler = this._isSupportedDomain(methodName) ? this._dispatchMap[methodName] : null;
         if (handler)
             return handler.call(this, id, params);
         this._sendResponse(id, undefined, {
             message: 'Can\'t handle command ' + methodName,
             code: Protocol.InspectorBackend.DevToolsStubErrorCode,
         });
     }
 
     _sendResponse(id, result, error) {
         var message = {
             id: id,
             result: result,
             error: error
         };
-        this._connection.sendMessageToDevTools(message);
+        return this._connection.sendMessageToDevTools(message);
     }
 
     _fireEvent(methodName, params) {
         var domain = methodName.split('.')[0];
         // Non-enabled domains can't send events.
         if (!this._enabledDomains.has(domain))
             return;
         var message = {
             method: methodName,
             params: params
         };
-        this._connection.sendMessageToDevTools(message);
+        return this._connection.sendMessageToDevTools(message);
     }
 }
 
 var MockPageConnection = class {
     /**
     * @param {!Protocol.InspectorBackend.Connection.Params} params
     */
     constructor(page, params) {
         this._page = page;
         this._onMessage = params.onMessage;
         this._onDisconnect = params.onDisconnect;
     }
 
     sendMessageToDevTools(message) {
-        setTimeout(() => this._onMessage.call(null, JSON.stringify(message)), 0);
+        return Promise.resolve().then(() => this._onMessage.call(null, JSON.stringify(message)));

[allada, 2017/05/10 22:25:01]

These were in non-deterministic order, so I went to setImmidiate instead.

     }
 
     /**
     * @override
     * @param {string} message
     */
     sendMessage(message) {
         var json = JSON.parse(message);
         this._page._dispatch(json.id, json.method, json.params, message);
     }
 
     /**
     * @override
     * @return {!Promise}
     */
     disconnect() {
         this._onDisconnect.call(null, 'force disconnect');
         this._onDisconnect = null;
         this._onMessage = null;
         return Promise.resolve();
     }
 };
 
 };