Attachment #8951598 for bug #859051

Attachment #8951598: Bug859051.patch for bug #859051

View | Details | Raw Unified | Return to bug 859051
Collapse All | Expand All





# LOCALIZATION NOTE (netmonitor.tab.headers): This is the label displayed
# in the network details pane identifying the headers tab.
netmonitor.tab.headers=Headers

# LOCALIZATION NOTE (netmonitor.tab.cookies): This is the label displayed
# in the network details pane identifying the cookies tab.
netmonitor.tab.cookies=Cookies

# LOCALIZATION NOTE (netmonitor.tab.cache): This is the label displayed
# in the network details pane identifying the cache tab.
netmonitor.tab.cache=Cache

# LOCALIZATION NOTE (netmonitor.tab.params): This is the label displayed
# in the network details pane identifying the params tab.
netmonitor.tab.params=Params

# LOCALIZATION NOTE (netmonitor.tab.response): This is the label displayed
# in the network details pane identifying the response tab.
netmonitor.tab.response=Response


# the column status code, when the request is from a service worker
# %1$S is the status code, %2$S is the status text.
netmonitor.status.tooltip.worker = %1$S %2$S (service worker)

# LOCALIZATION NOTE (netmonitor.status.tooltip.cachedworker): This is the tooltip
# of the column status code, when the request is cached and is from a service worker
# %1$S is the status code, %2$S is the status text.
netmonitor.status.tooltip.cachedworker = %1$S %2$S (cached, service worker)

cacheEmptyText = No cache information
dataSize = Data Size
expires = Expires
fetchCount = Fetch Count
lastFetched = Last Fetched
lastModified = Last Modified
device = Device





}

.network-monitor .source-editor-mount {
  width: 100%;
  height: 100%;
}

.network-monitor .headers-summary-label,
.network-monitor .cache-summary-label,
.network-monitor .tree-container .objectBox {
  white-space: nowrap;
}

/* Summary tabpanel */

.network-monitor .tabpanel-summary-container {
  padding: 1px;


/* Headers tabpanel */

.network-monitor .headers-overview {
  background: var(--theme-toolbar-background);
}

.network-monitor .headers-summary,
.network-monitor .response-summary,
.network-monitor .cache-summary {
  display: flex;
  align-items: center;
}

.network-monitor .headers-summary .devtools-button {
  margin-inline-end: 6px;
}


-Line
+Link Here
-Line 0
+Link Here
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+ "use strict";
+ const { Component, createFactory } = require("devtools/client/shared/vendor/react");
+ const PropTypes = require("devtools/client/shared/vendor/react-prop-types");
+ const { connect } = require("devtools/client/shared/vendor/react-redux");
+ const dom = require("devtools/client/shared/vendor/react-dom-factories");
+ const { L10N } = require("../utils/l10n");
+ const { fetchCacheDescriptor, fetchNetworkUpdatePacket } = require("../utils/request-utils");
+ const { sortObjectKeys } = require("../utils/sort-utils");
+ const Actions = require("../actions/index");
+ // Component
+ const PropertiesView = createFactory(require("./PropertiesView"));
+ const { div, input } = dom;
+ const CACHE_EMPTY_TEXT = L10N.getStr("cacheEmptyText");
+ const DATA_SIZE = L10N.getStr("dataSize");
+ const EXPIRES = L10N.getStr("expires");
+ const FETCH_COUNT = L10N.getStr("fetchCount");
+ const LAST_FETCHED = L10N.getStr("lastFetched");
+ const LAST_MODIFIED = L10N.getStr("lastModified");
+ const DEVICE = L10N.getStr("device");
+ const SECTION_NAMES = [
+   DATA_SIZE,
+   LAST_FETCHED,
+   LAST_MODIFIED,
+   FETCH_COUNT,
+   EXPIRES,
+   DEVICE,
+ ];
+ /*
+  * Cache panel component
+  * This tab lists full details of any cache information of the response.
+  */
+ class CachePanel extends Component {
+   static get propTypes() {
+     return {
+       connector: PropTypes.object.isRequired,
+       openLink: PropTypes.func,
+       request: PropTypes.object.isRequired,
+     };
+   }
+   componentDidMount() {
+     let { connector, request } = this.props;
+     fetchNetworkUpdatePacket(connector.requestData, request, ["responseCache"]);
+   }
+   componentWillReceiveProps(nextProps) {
+     let { connector, request } = nextProps;
+     fetchNetworkUpdatePacket(connector.requestData, request, ["responseCache"]);
+   }
+   renderSummary(label, value) {
+     return (
+       div({ className: "tabpanel-summary-container cache-summary"},
+        div({
+          className: "tabpanel-summary-label cache-summary-label",
+        }, label + ':'),
+        input({
+          className: "tabpanel-summary-value textbox-input devtools-monospace",
+          readOnly: true,
+          value
+        }),
+      )
+     );
+   }
+   getProperties(responseCache) {
+    let responseCacheObj;
+     let cacheObj;
+     try {
+        responseCacheObj = Object.assign({}, responseCache);
+        responseCacheObj = responseCacheObj.cache;
+     } catch (e) {
+        return null;
+     }
+     try {
+       cacheObj = Object.assign({}, responseCacheObj);
+     } catch (e) {
+        return null;
+     }
+    return cacheObj;
+  }
+  getDate(timestamp) {
+    let d = new Date(parseInt(timestamp) * 1000);
+    return d.toLocaleDateString() + ' ' + d.toLocaleTimeString();
+  }
+   render() {
+     let {
+       request,
+       openLink,
+     } = this.props;
+     let { responseCache } = request;
+     let object = Object.assign({}, this.getProperties(responseCache));
+     let panelObject = {};
+     let summaryLastFetched = object.lastFetched ? this.renderSummary( LAST_FETCHED, this.getDate(object.lastFetched)): null;
+     let summaryFetchCount = object.fetchCount ? this.renderSummary(FETCH_COUNT, object.fetchCount): null;
+     let summaryDataSize = object.dataSize ? this.renderSummary(DATA_SIZE, object.dataSize): null;
+     let summaryLastModified = object.lastModified ? this.renderSummary(LAST_MODIFIED, this.getDate(object.lastModified)): null;
+     let summaryExpires = object.expires ? this.renderSummary(EXPIRES, this.getDate(object.expires)): null;
+     let summaryDevice = object.device ? this.renderSummary(DEVICE, object.device) : null;
+     return (
+       div({ className: "panel-container" },
+        div({ className: "cache-overview" } ,
+          summaryLastFetched,
+          summaryFetchCount,
+          summaryDataSize,
+          summaryLastModified,
+          summaryExpires,
+          summaryDevice
+        ),
+         PropertiesView({
+           panelObject,
+           sectionNames: SECTION_NAMES,
+           openLink,
+           enableInput: false,
+           enableFilter: false,
+         })
+       )
+     );
+   }
+ }
+ module.exports = CachePanel;





const { PANELS } = require("../constants");

// Components
const Tabbar = createFactory(require("devtools/client/shared/components/tabs/TabBar"));
const TabPanel = createFactory(require("devtools/client/shared/components/tabs/Tabs").TabPanel);
const CookiesPanel = createFactory(require("./CookiesPanel"));
const HeadersPanel = createFactory(require("./HeadersPanel"));
const ParamsPanel = createFactory(require("./ParamsPanel"));
const CachePanel = createFactory(require("./CachePanel"));
const ResponsePanel = createFactory(require("./ResponsePanel"));
const SecurityPanel = createFactory(require("./SecurityPanel"));
const StackTracePanel = createFactory(require("./StackTracePanel"));
const TimingsPanel = createFactory(require("./TimingsPanel"));

const CACHE_TITLE = L10N.getStr("netmonitor.tab.cache");
const COOKIES_TITLE = L10N.getStr("netmonitor.tab.cookies");
const HEADERS_TITLE = L10N.getStr("netmonitor.tab.headers");
const PARAMS_TITLE = L10N.getStr("netmonitor.tab.params");
const RESPONSE_TITLE = L10N.getStr("netmonitor.tab.response");
const SECURITY_TITLE = L10N.getStr("netmonitor.tab.security");
const STACK_TRACE_TITLE = L10N.getStr("netmonitor.tab.stackTrace");
const TIMINGS_TITLE = L10N.getStr("netmonitor.tab.timings");


        ParamsPanel({ connector, openLink, request }),
      ),
      TabPanel({
        id: PANELS.RESPONSE,
        title: RESPONSE_TITLE,
      },
        ResponsePanel({ request, openLink, connector }),
      ),
      request.fromCache && 
      TabPanel({
        id: PANELS.CACHE,
        title: CACHE_TITLE,
      },
        CachePanel({ request, openLink, connector }),
      ),
      TabPanel({
        id: PANELS.TIMINGS,
        title: TIMINGS_TITLE,
      },
        TimingsPanel({
          connector,
          request,
        }),

(-)a/devtools/client/netmonitor/src/components/moz.build (+1 lines)

Line	Link Here

Lines 1-14	Link Here

# This Source Code Form is subject to the terms of the Mozilla Public

# This Source Code Form is subject to the terms of the Mozilla Public

# License, v. 2.0. If a copy of the MPL was not distributed with this

# License, v. 2.0. If a copy of the MPL was not distributed with this

# file, You can obtain one at http://mozilla.org/MPL/2.0/.

# file, You can obtain one at http://mozilla.org/MPL/2.0/.

DevToolsModules(

DevToolsModules(

    'App.js',

    'App.js',

    'CachePanel.js',

    'CookiesPanel.js',

    'CookiesPanel.js',

    'CustomRequestPanel.js',

    'CustomRequestPanel.js',

    'HeadersPanel.js',

    'HeadersPanel.js',

    'HtmlPreview.js',

    'HtmlPreview.js',

    'MdnLink.js',

    'MdnLink.js',

    'MonitorPanel.js',

    'MonitorPanel.js',

    'NetworkDetailsPanel.js',

    'NetworkDetailsPanel.js',

    'ParamsPanel.js',

    'ParamsPanel.js',





  async updateRequest(id, data) {
    let {
      responseContent,
      responseCookies,
      responseHeaders,
      requestCookies,
      requestHeaders,
      requestPostData,
      responseCache,
    } = data;

    // fetch request detail contents in parallel
    let [
      responseContentObj,
      requestHeadersObj,
      responseHeadersObj,
      postDataObj,
      requestCookiesObj,
      responseCookiesObj,
      responseCacheObj,
    ] = await Promise.all([
      this.fetchResponseContent(responseContent),
      this.fetchRequestHeaders(requestHeaders),
      this.fetchResponseHeaders(responseHeaders),
      this.fetchPostData(requestPostData),
      this.fetchRequestCookies(requestCookies),
      this.fetchResponseCookies(responseCookies),
      this.fetchResponseCache(responseCache),
    ]);

    let payload = Object.assign({},
      data,
      responseContentObj,
      requestHeadersObj,
      responseHeadersObj,
      postDataObj,
      requestCookiesObj,
      responseCookiesObj,
      responseCacheObj,
    );

    if (this.actions.updateRequest) {
      await this.actions.updateRequest(id, payload, true);
    }

    return payload;
  }

        if (resCookies.length) {
          payload.responseCookies = resCookies;
        }
      }
    }
    return payload;
  }

  async fetchResponseCache(responseCache) {
    let payload = {};
    if (responseCache) {
      payload.responseCache = await this.getLongString(responseCache);
      payload.responseCacheAvailable = false;
    }
    return payload;
  }

  /**
   * Public API used by the Toolbox: Tells if there is still any pending request.
   *
   * @return {boolean} returns true if the payload queue is empty
   */
  isPayloadQueueEmpty() {
    return this.payloadQueue.size === 0;
  }

   */
  async onResponseCookies(response) {
    let payload = await this.updateRequest(response.from, {
      responseCookies: response
    });
    emit(EVENTS.RECEIVED_RESPONSE_COOKIES, response.from);
    return payload.responseCookies;
  }
  
  /**
   * 
   * @param {object} response 
   */
  async onResponseCache(response) {
    let payload = await this.updateRequest(response.from, {
      responseCache: response
    });
    emit(EVENTS.RECEIVED_RESPONSE_CACHE, response.from);
    return payload.responseCache;
  }

  /**
   * Handles additional information received via "getResponseContent" request.
   *
   * @param {object} response the message received from the server.
   */
  async onResponseContent(response) {
    let payload = await this.updateRequest(response.from, {





  // When response content begins, updates and finishes receiving.
  STARTED_RECEIVING_RESPONSE: "NetMonitor:NetworkEventUpdating:ResponseStart",
  UPDATING_RESPONSE_CONTENT: "NetMonitor:NetworkEventUpdating:ResponseContent",
  RECEIVED_RESPONSE_CONTENT: "NetMonitor:NetworkEventUpdated:ResponseContent",

  // When stack-trace finishes receiving.
  RECEIVED_EVENT_STACKTRACE: "NetMonitor:NetworkEventUpdated:StackTrace",

  UPDATING_RESPONSE_CACHE: "NetMonitor:NetwworkEventUpdating:ResponseCache",
  RECEIVED_RESPONSE_CACHE: "NetMonitor:NetworkEventUpdated:ResponseCache",

  // Fired once the connection is established
  CONNECTED: "connected",

  // When request payload (HTTP details data) are fetched from the backend.
  PAYLOAD_READY: "NetMonitor:PayloadReady",
};

const UPDATE_PROPS = [

  "requestPostData",
  "requestPostDataAvailable",
  "responseHeaders",
  "responseHeadersAvailable",
  "responseCookies",
  "responseCookiesAvailable",
  "responseContent",
  "responseContentAvailable",
  "responseCache",
  "responseCacheAvailable",
  "formDataSections",
  "stacktrace",
];

const PANELS = {
  COOKIES: "cookies",
  HEADERS: "headers",
  PARAMS: "params",
  RESPONSE: "response",
  CACHE: "cache",
  SECURITY: "security",
  STACK_TRACE: "stack-trace",
  TIMINGS: "timings",
};

const RESPONSE_HEADERS = [
  "Cache-Control",
  "Connection",





      requestPostData,
      connector.getLongString,
    );

    updateRequest(request.id, { formDataSections }, true);
  }
}

async function fetchCacheDescriptor(props) {
  let {
    connector,
    request = {},
  } = props;

  let {
    id,
  } = request;
  let responseCache = await connector.requestData(id, "responseCache");
  return responseCache;
}

/**
 * This helper function is used for additional processing of
 * incoming network update packets. It's used by Network and
 * Console panel reducers.
 */
function processNetworkUpdates(request = {}) {
  let result = {};
  for (let [key, value] of Object.entries(request)) {

    }
  }
  return result;
}

module.exports = {
  decodeUnicodeBase64,
  getFormDataSections,
  fetchCacheDescriptor,
  fetchHeaders,
  fetchNetworkUpdatePacket,
  formDataURI,
  writeHeaderText,
  decodeUnicodeUrl,
  getAbbreviatedMimeType,
  getEndTime,
  getFormattedProtocol,





  this._response = {
    headers: [],
    cookies: [],
    content: {},
  };

  this._timings = {};
  this._stackTrace = {};
  this._cache = {};

  // Keep track of LongStringActors owned by this NetworkEventActor.
  this._longStringActors = new Set();
}

NetworkEventActor.prototype =
{
  _request: null,

      from: this.actorID,
      headers: this._response.headers,
      headersSize: this._response.headersSize,
      rawHeaders: this._response.rawHeaders,
    };
  },

  /**
   * The "getResponseCache" packet type handler.
   * 
   * @return object
   *         The cache packet - network cache information.
   */
  onGetResponseCache: function() {
    return {
      from: this.actorID,
      cache: this._response.responseCache,
    };
  },

  /**
   * The "getResponseCookies" packet type handler.
   *
   * @return object
   *         The response packet - network response cookies.
   */
  onGetResponseCookies: function () {
    return {
      from: this.actorID,

      encoding: content.encoding,
      transferredSize: content.transferredSize,
      discardResponseBody,
    };

    this.conn.send(packet);
  },

  addResponseCache: function(content) {
    this._response.responseCache = content.responseCache;
    let packet = {
      from: this.actorID,
      type: "networkEventUpdate",
      updateType: "responseCache",
    };

    this.conn.send(packet);
  },

  addResponseCache: function(content) {
    this._response.responseCache = content.responseCache;
    let packet = {
      from: this.actorID,
      type: "networkEventUpdate",
      updateType: "responseCache",
    };

    this.conn.send(packet);
  },

  /**
   * Add network event timing information.
   *
   * @param number total
   *        The total time of the network event.
   * @param object timings
   *        Timing details about the network event.
   */

NetworkEventActor.prototype.requestTypes =
{
  "release": NetworkEventActor.prototype.onRelease,
  "getRequestHeaders": NetworkEventActor.prototype.onGetRequestHeaders,
  "getRequestCookies": NetworkEventActor.prototype.onGetRequestCookies,
  "getRequestPostData": NetworkEventActor.prototype.onGetRequestPostData,
  "getResponseHeaders": NetworkEventActor.prototype.onGetResponseHeaders,
  "getResponseCookies": NetworkEventActor.prototype.onGetResponseCookies,
  "getResponseCache": NetworkEventActor.prototype.onGetResponseCache,
  "getResponseContent": NetworkEventActor.prototype.onGetResponseContent,
  "getEventTimings": NetworkEventActor.prototype.onGetEventTimings,
  "getSecurityInfo": NetworkEventActor.prototype.onGetSecurityInfo,
  "getStackTrace": NetworkEventActor.prototype.onGetStackTrace,
};





        break;
      case "responseContent":
        networkInfo.response.content = {
          mimeType: packet.mimeType,
        };
        networkInfo.response.bodySize = packet.contentSize;
        networkInfo.response.transferredSize = packet.transferredSize;
        networkInfo.discardResponseBody = packet.discardResponseBody;

        break;
      case "eventTimings":
        networkInfo.totalTime = packet.totalTime;
        break;
      case "securityInfo":
        networkInfo.securityInfo = packet.state;
        break;
      case "responseCache":
        networkInfo.response.responseCache = packet.responseCache;
        break;
    }

    this.emit("networkEventUpdate", {
      packet: packet,
      networkInfo
    });
  },


    let packet = {
      to: actor,
      type: "getResponseContent",
    };
    return this._client.request(packet, onResponse);
  },

  /**
   * Retrieve the response cache from the given NetworkEventActor
   * 
   * @param string actor
   *        The NetworkEventActor ID.
   * @param function onResponse
   *        The function invoked when the response is recieved.
   * @return request
   *         Request object that implements both Promise and EventEmitter interfaces.
   */
  getResponseCache: function (actor, onResponse) {
    let packet = {
      to: actor,
      type: "getResponseCache",
    };
    return this._client.request(packet, onResponse);
  },

  /**
   * Retrieve the timing information for the given NetworkEventActor.
   *
   * @param string actor
   *        The NetworkEventActor ID.
   * @param function onResponse
   *        The function invoked when the response is received.
   * @return request
   *         Request object that implements both Promise and EventEmitter interfaces





 *  Austin Andrews
 *  Christoph Dorn
 *  Steven Roussey (AppCenter Inc, Network54)
 *  Mihai Sucan (Mozilla Corp.)
 */

"use strict";

const {components, Cc, Ci, Cu} = require("chrome");
loader.lazyImporter(this, "NetUtil", "resource://gre/modules/NetUtil.jsm");
const DevToolsUtils = require("devtools/shared/DevToolsUtils");
const Services = require("Services");
const { LocalizationHelper } = require("devtools/shared/l10n");
const L10N = new LocalizationHelper("devtools/client/locales/netmonitor.properties");

// The cache used in the `nsIURL` function.
const gNSURLStore = new Map();

      case "svg":
      case "xml":
        return true;

      default:
        return false;
    }
  },
  /**
   * Gets a cache entry for a request.
   * 
   * @param Object request
   * @param Object response
   * @param Function onCacheDescriptorAvailable
   */
  getCacheEntry: function(request, response, onCacheDescriptorAvailable) {
    let CacheService = Cc["@mozilla.org/network/cache-service;1"];
    let CacheStorageService = Cc["@mozilla.org/network/cache-storage-service;1"];
    if (CacheStorageService) {
      let cacheService = CacheStorageService.getService(Ci.nsICacheStorageService);
      let loadContext = Services.loadContextInfo.default;
      let cacheSession = cacheService.diskCacheStorage(loadContext, false);
      cacheSession.asyncOpenURI(this.nsIURL(request.URI.spec), "", Ci.nsICacheStorage.OPEN_NORMALLY, 
      {
        onCacheEntryCheck: function(entry, appcache) {
          return Ci.nsICacheEntryOpenCallback.ENTRY_WANTED;
        },
        onCacheEntryAvailable: function(descriptor, isnew, appcache, status) {
          if (descriptor) {
            let cdescriptor = {
              dataSize: descriptor.storageDataSize,
              expires: descriptor.expirationTime,
              fetchCount: descriptor.fetchCount,
              lastFetched: descriptor.lastFetched,
              lastModified: descriptor.lastModified,
            };
            if (descriptor.deviceID) {
              cdescriptor["device"] = descriptor.deviceID;
            }
            onCacheDescriptorAvailable(cdescriptor);
          } else {
            onCacheDescriptorAvailable(null);
          }
          
        },
      });
    } else { // CacheStorageService does not exist.
      let oldICache = Ci["ns" + "ICache"];
      let cacheService = CacheService.getService(Ci.nsICacheService);
      let cacheSession = cacheService.createSession("HTTP", oldICache.STORE_ANYWHERE, true);

      cacheSession.asyncOpenCacheEntry(this.nsIURL(request.URI.spec), oldICache.ACCESS_READ, {
        onCacheEntryAvailable: function(descriptor, accessGranted, status) {
          if (descriptor) {
            let cdescriptor = {
              dataSize: descriptor.storageDataSize,
              expires: descriptor.expirationTime,
              fetchCount: descriptor.fetchCount,
              lastFetched: descriptor.lastFetched,
              lastModified: descriptor.lastModified,
            };
            if (descriptor.deviceID) {
              cdescriptor["device"] = descriptor.deviceID;
            }
            onCacheDescriptorAvailable(cdescriptor);
          } else {
            onCacheDescriptorAvailable(null);
          }
        }
      })
    }
  },

  /**
   * Takes a securityInfo object of nsIRequest, the nsIRequest itself and
   * extracts security information from them.
   *
   * @param object securityInfo
   *        The securityInfo object of a request. If null channel is assumed
   *        to be insecure.

(-)a/devtools/shared/webconsole/network-monitor.js (-1 / +11 lines)

Line	Link Here

Lines 929-948 NetworkMonitor.prototype = {	Link Here

929

      // Service worker requests emits cached-reponse notification on non-e10s,

929

      // Service worker requests emits cached-reponse notification on non-e10s,

930

      // and we fake one on e10s.

930

      // and we fake one on e10s.

931

      let fromServiceWorker = this.interceptedChannels.has(channel);

931

      let fromServiceWorker = this.interceptedChannels.has(channel);

932

      this.interceptedChannels.delete(channel);

932

      this.interceptedChannels.delete(channel);

933

934

      // If this is a cached response, there never was a request event

934

      // If this is a cached response, there never was a request event

935

      // so we need to construct one here so the frontend gets all the

935

      // so we need to construct one here so the frontend gets all the

936

      // expected events.

936

      // expected events.

937

938

939

937

      let httpActivity = this._createNetworkEvent(channel, {

940

      let httpActivity = this._createNetworkEvent(channel, {

938

        fromCache: !fromServiceWorker,

941

        fromCache: !fromServiceWorker,

939

        fromServiceWorker: fromServiceWorker

942

        fromServiceWorker: fromServiceWorker

940

});

943

});

944

945

      NetworkHelper.getCacheEntry(channel, response, function(descriptor) {

946

        httpActivity.owner.addResponseCache({

947

          responseCache: descriptor,

948

});

949

});

950

941

      httpActivity.owner.addResponseStart({

951

      httpActivity.owner.addResponseStart({

942

        httpVersion: response.httpVersion,

952

        httpVersion: response.httpVersion,

943

        remoteAddress: "",

953

        remoteAddress: "",

944

        remotePort: "",

954

        remotePort: "",

945

        status: response.status,

955

        status: response.status,

946

        statusText: response.statusText,

956

        statusText: response.statusText,

947

        headersSize: 0,

957

        headersSize: 0,

948

      }, "", true);

958

      }, "", true);

Lines 1899-1915 NetworkEventActorProxy.prototype = {	Link Here

1899

    return this;

1909

    return this;

1900

}),

1910

}),

1901

};

1911

};

1902

1912

1903

(function () {

1913

(function () {

1904

  // Listeners for new network event data coming from the NetworkMonitor.

1914

  // Listeners for new network event data coming from the NetworkMonitor.

1905

  let methods = ["addRequestHeaders", "addRequestCookies", "addRequestPostData",

1915

  let methods = ["addRequestHeaders", "addRequestCookies", "addRequestPostData",

1906

                 "addResponseStart", "addSecurityInfo", "addResponseHeaders",

1916

                 "addResponseStart", "addSecurityInfo", "addResponseHeaders",

1907

                 "addResponseCookies", "addResponseContent", "addEventTimings"];

1917

                 "addResponseCookies", "addResponseContent", "addResponseCache", "addEventTimings"];

1908

  let factory = NetworkEventActorProxy.methodFactory;

1918

  let factory = NetworkEventActorProxy.methodFactory;

1909

  for (let method of methods) {

1919

  for (let method of methods) {

1910

    NetworkEventActorProxy.prototype[method] = factory(method);

1920

    NetworkEventActorProxy.prototype[method] = factory(method);

1911

1921

1912

})();

1922

})();

1913

1923

1914

/**

1924

/**

1915

 * This is triggered by the child calling `setupInParent` when the child's network monitor

1925

 * This is triggered by the child calling `setupInParent` when the child's network monitor

Return to bug 859051

Bugzilla

Quick Search

Attachment #8951598: Bug859051.patch for bug #859051