Home | History | Annotate | Download | only in net_internals 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 /**
      6  * Dictionary of constants (Initialized soon after loading by data from browser,
      7  * updated on load log).  The *Types dictionaries map strings to numeric IDs,
      8  * while the *TypeNames are the other way around.
      9  */
     10 var EventType = null;
     11 var EventTypeNames = null;
     12 var EventPhase = null;
     13 var EventSourceType = null;
     14 var EventSourceTypeNames = null;
     15 var LogLevelType = null;
     16 var ClientInfo = null;
     17 var NetError = null;
     18 var QuicError = null;
     19 var QuicRstStreamError = null;
     20 var LoadFlag = null;
     21 var LoadState = null;
     22 var AddressFamily = null;
     23 
     24 /**
     25  * Dictionary of all constants, used for saving log files.
     26  */
     27 var Constants = null;
     28 
     29 /**
     30  * Object to communicate between the renderer and the browser.
     31  * @type {!BrowserBridge}
     32  */
     33 var g_browser = null;
     34 
     35 /**
     36  * This class is the root view object of the page.  It owns all the other
     37  * views, and manages switching between them.  It is also responsible for
     38  * initializing the views and the BrowserBridge.
     39  */
     40 var MainView = (function() {
     41   'use strict';
     42 
     43   // We inherit from WindowView
     44   var superClass = WindowView;
     45 
     46   /**
     47    * Main entry point. Called once the page has loaded.
     48    *  @constructor
     49    */
     50   function MainView() {
     51     assertFirstConstructorCall(MainView);
     52 
     53     if (hasTouchScreen())
     54       document.body.classList.add('touch');
     55 
     56     // This must be initialized before the tabs, so they can register as
     57     // observers.
     58     g_browser = BrowserBridge.getInstance();
     59 
     60     // This must be the first constants observer, so other constants observers
     61     // can safely use the globals, rather than depending on walking through
     62     // the constants themselves.
     63     g_browser.addConstantsObserver(new ConstantsObserver());
     64 
     65     // Create the tab switcher.
     66     this.initTabs_();
     67 
     68     // Cut out a small vertical strip at the top of the window, to display
     69     // a high level status (i.e. if we are capturing events, or displaying a
     70     // log file). Below it we will position the main tabs and their content
     71     // area.
     72     this.topBarView_ = TopBarView.getInstance(this);
     73     var verticalSplitView = new VerticalSplitView(
     74         this.topBarView_, this.tabSwitcher_);
     75 
     76     superClass.call(this, verticalSplitView);
     77 
     78     // Trigger initial layout.
     79     this.resetGeometry();
     80 
     81     window.onhashchange = this.onUrlHashChange_.bind(this);
     82 
     83     // Select the initial view based on the current URL.
     84     window.onhashchange();
     85 
     86     // Tell the browser that we are ready to start receiving log events.
     87     this.topBarView_.switchToSubView('capture');
     88     g_browser.sendReady();
     89   }
     90 
     91   cr.addSingletonGetter(MainView);
     92 
     93   // Tracks if we're viewing a loaded log file, so views can behave
     94   // appropriately.  Global so safe to call during construction.
     95   var isViewingLoadedLog = false;
     96 
     97   MainView.isViewingLoadedLog = function() {
     98     return isViewingLoadedLog;
     99   };
    100 
    101   MainView.prototype = {
    102     // Inherit the superclass's methods.
    103     __proto__: superClass.prototype,
    104 
    105     // This is exposed both so the log import/export code can enumerate all the
    106     // tabs, and for testing.
    107     tabSwitcher: function() {
    108       return this.tabSwitcher_;
    109     },
    110 
    111     /**
    112      * Prevents receiving/sending events to/from the browser, so loaded data
    113      * will not be mixed with current Chrome state.  Also hides any interactive
    114      * HTML elements that send messages to the browser.  Cannot be undone
    115      * without reloading the page.  Must be called before passing loaded data
    116      * to the individual views.
    117      *
    118      * @param {string} opt_fileName The name of the log file that has been
    119      *     loaded, if we're loading a log file.
    120      */
    121     onLoadLog: function(opt_fileName) {
    122       isViewingLoadedLog = true;
    123 
    124       this.stopCapturing();
    125       if (opt_fileName != undefined) {
    126         // If there's a file name, a log file was loaded, so swap out the status
    127         // bar to indicate we're no longer capturing events.  Also disable
    128         // hiding cookies, so if the log dump has them, they'll be displayed.
    129         this.topBarView_.switchToSubView('loaded').setFileName(opt_fileName);
    130         $(ExportView.PRIVACY_STRIPPING_CHECKBOX_ID).checked = false;
    131         SourceTracker.getInstance().setPrivacyStripping(false);
    132       } else {
    133         // Otherwise, the "Stop Capturing" button was presumably pressed.
    134         // Don't disable hiding cookies, so created log dumps won't have them,
    135         // unless the user toggles the option.
    136         this.topBarView_.switchToSubView('halted');
    137       }
    138     },
    139 
    140     switchToViewOnlyMode: function() {
    141       // Since this won't be dumped to a file, we don't want to remove
    142       // cookies and credentials.
    143       log_util.createLogDumpAsync('', log_util.loadLogFile, false);
    144     },
    145 
    146     stopCapturing: function() {
    147       g_browser.disable();
    148       document.styleSheets[0].insertRule(
    149           '.hide-when-not-capturing { display: none; }', 0);
    150     },
    151 
    152     initTabs_: function() {
    153       this.tabIdToHash_ = {};
    154       this.hashToTabId_ = {};
    155 
    156       this.tabSwitcher_ = new TabSwitcherView(
    157           $(TopBarView.TAB_DROPDOWN_MENU_ID),
    158           this.onTabSwitched_.bind(this));
    159 
    160       // Helper function to add a tab given the class for a view singleton.
    161       var addTab = function(viewClass) {
    162         var tabId = viewClass.TAB_ID;
    163         var tabHash = viewClass.TAB_HASH;
    164         var tabName = viewClass.TAB_NAME;
    165         var view = viewClass.getInstance();
    166 
    167         if (!tabId || !view || !tabHash || !tabName) {
    168           throw Error('Invalid view class for tab');
    169         }
    170 
    171         if (tabHash.charAt(0) != '#') {
    172           throw Error('Tab hashes must start with a #');
    173         }
    174 
    175         this.tabSwitcher_.addTab(tabId, view, tabName);
    176         this.tabIdToHash_[tabId] = tabHash;
    177         this.hashToTabId_[tabHash] = tabId;
    178       }.bind(this);
    179 
    180       // Populate the main tabs.  Even tabs that don't contain information for
    181       // the running OS should be created, so they can load log dumps from other
    182       // OSes.
    183       addTab(CaptureView);
    184       addTab(ExportView);
    185       addTab(ImportView);
    186       addTab(ProxyView);
    187       addTab(EventsView);
    188       addTab(WaterfallView);
    189       addTab(TimelineView);
    190       addTab(DnsView);
    191       addTab(SocketsView);
    192       addTab(SpdyView);
    193       addTab(QuicView);
    194       addTab(HttpPipelineView);
    195       addTab(HttpCacheView);
    196       addTab(ModulesView);
    197       addTab(TestView);
    198       addTab(CrosLogVisualizerView);
    199       addTab(HSTSView);
    200       addTab(LogsView);
    201       addTab(BandwidthView);
    202       addTab(PrerenderView);
    203       addTab(CrosView);
    204 
    205       this.tabSwitcher_.showMenuItem(LogsView.TAB_ID, cr.isChromeOS);
    206       this.tabSwitcher_.showMenuItem(CrosView.TAB_ID, cr.isChromeOS);
    207       this.tabSwitcher_.showMenuItem(CrosLogVisualizerView.TAB_ID,
    208                                      cr.isChromeOS);
    209     },
    210 
    211     /**
    212      * This function is called by the tab switcher when the current tab has been
    213      * changed. It will update the current URL to reflect the new active tab,
    214      * so the back can be used to return to previous view.
    215      */
    216     onTabSwitched_: function(oldTabId, newTabId) {
    217       // Update data needed by newly active tab, as it may be
    218       // significantly out of date.
    219       if (g_browser)
    220         g_browser.checkForUpdatedInfo();
    221 
    222       // Change the URL to match the new tab.
    223 
    224       var newTabHash = this.tabIdToHash_[newTabId];
    225       var parsed = parseUrlHash_(window.location.hash);
    226       if (parsed.tabHash != newTabHash) {
    227         window.location.hash = newTabHash;
    228       }
    229     },
    230 
    231     onUrlHashChange_: function() {
    232       var parsed = parseUrlHash_(window.location.hash);
    233 
    234       if (!parsed)
    235         return;
    236 
    237       if (!parsed.tabHash) {
    238         // Default to the export tab.
    239         parsed.tabHash = ExportView.TAB_HASH;
    240       }
    241 
    242       var tabId = this.hashToTabId_[parsed.tabHash];
    243 
    244       if (tabId) {
    245         this.tabSwitcher_.switchToTab(tabId);
    246         if (parsed.parameters) {
    247           var view = this.tabSwitcher_.getTabView(tabId);
    248           view.setParameters(parsed.parameters);
    249         }
    250       }
    251     },
    252 
    253   };
    254 
    255   /**
    256    * Takes the current hash in form of "#tab&param1=value1&param2=value2&..."
    257    * and parses it into a dictionary.
    258    *
    259    * Parameters and values are decoded with decodeURIComponent().
    260    */
    261   function parseUrlHash_(hash) {
    262     var parameters = hash.split('&');
    263 
    264     var tabHash = parameters[0];
    265     if (tabHash == '' || tabHash == '#') {
    266       tabHash = undefined;
    267     }
    268 
    269     // Split each string except the first around the '='.
    270     var paramDict = null;
    271     for (var i = 1; i < parameters.length; i++) {
    272       var paramStrings = parameters[i].split('=');
    273       if (paramStrings.length != 2)
    274         continue;
    275       if (paramDict == null)
    276         paramDict = {};
    277       var key = decodeURIComponent(paramStrings[0]);
    278       var value = decodeURIComponent(paramStrings[1]);
    279       paramDict[key] = value;
    280     }
    281 
    282     return {tabHash: tabHash, parameters: paramDict};
    283   }
    284 
    285   return MainView;
    286 })();
    287 
    288 function ConstantsObserver() {}
    289 
    290 /**
    291  * Loads all constants from |constants|.  On failure, global dictionaries are
    292  * not modifed.
    293  * @param {Object} receivedConstants The map of received constants.
    294  */
    295 ConstantsObserver.prototype.onReceivedConstants = function(receivedConstants) {
    296   if (!areValidConstants(receivedConstants))
    297     return;
    298 
    299   Constants = receivedConstants;
    300 
    301   EventType = Constants.logEventTypes;
    302   EventTypeNames = makeInverseMap(EventType);
    303   EventPhase = Constants.logEventPhase;
    304   EventSourceType = Constants.logSourceType;
    305   EventSourceTypeNames = makeInverseMap(EventSourceType);
    306   LogLevelType = Constants.logLevelType;
    307   ClientInfo = Constants.clientInfo;
    308   LoadFlag = Constants.loadFlag;
    309   NetError = Constants.netError;
    310   QuicError = Constants.quicError;
    311   QuicRstStreamError = Constants.quicRstStreamError;
    312   AddressFamily = Constants.addressFamily;
    313   LoadState = Constants.loadState;
    314 
    315   timeutil.setTimeTickOffset(Constants.timeTickOffset);
    316 };
    317 
    318 /**
    319  * Returns true if it's given a valid-looking constants object.
    320  * @param {Object} receivedConstants The received map of constants.
    321  * @return {boolean} True if the |receivedConstants| object appears valid.
    322  */
    323 function areValidConstants(receivedConstants) {
    324   return typeof(receivedConstants) == 'object' &&
    325          typeof(receivedConstants.logEventTypes) == 'object' &&
    326          typeof(receivedConstants.clientInfo) == 'object' &&
    327          typeof(receivedConstants.logEventPhase) == 'object' &&
    328          typeof(receivedConstants.logSourceType) == 'object' &&
    329          typeof(receivedConstants.logLevelType) == 'object' &&
    330          typeof(receivedConstants.loadFlag) == 'object' &&
    331          typeof(receivedConstants.netError) == 'object' &&
    332          typeof(receivedConstants.addressFamily) == 'object' &&
    333          typeof(receivedConstants.timeTickOffset) == 'string' &&
    334          typeof(receivedConstants.logFormatVersion) == 'number';
    335 }
    336 
    337 /**
    338  * Returns the name for netError.
    339  *
    340  * Example: netErrorToString(-105) should return
    341  * "ERR_NAME_NOT_RESOLVED".
    342  * @param {number} netError The net error code.
    343  * @return {string} The name of the given error.
    344  */
    345 function netErrorToString(netError) {
    346   var str = getKeyWithValue(NetError, netError);
    347   if (str == '?')
    348     return str;
    349   return 'ERR_' + str;
    350 }
    351 
    352 /**
    353  * Returns the name for quicError.
    354  *
    355  * Example: quicErrorToString(25) should return
    356  * "TIMED_OUT".
    357  * @param {number} quicError The QUIC error code.
    358  * @return {string} The name of the given error.
    359  */
    360 function quicErrorToString(quicError) {
    361   return getKeyWithValue(QuicError, quicError);
    362 }
    363 
    364 /**
    365  * Returns the name for quicRstStreamError.
    366  *
    367  * Example: quicRstStreamErrorToString(3) should return
    368  * "BAD_APPLICATION_PAYLOAD".
    369  * @param {number} quicRstStreamError The QUIC RST_STREAM error code.
    370  * @return {string} The name of the given error.
    371  */
    372 function quicRstStreamErrorToString(quicRstStreamError) {
    373   return getKeyWithValue(QuicRstStreamError, quicRstStreamError);
    374 }
    375 
    376 /**
    377  * Returns a string representation of |family|.
    378  * @param {number} family An AddressFamily
    379  * @return {string} A representation of the given family.
    380  */
    381 function addressFamilyToString(family) {
    382   var str = getKeyWithValue(AddressFamily, family);
    383   // All the address family start with ADDRESS_FAMILY_*.
    384   // Strip that prefix since it is redundant and only clutters the output.
    385   return str.replace(/^ADDRESS_FAMILY_/, '');
    386 }
    387