The Tor Browser: browser/extensions/pdfjs/content/web/debugger.js@6474c204b198 (annotated)

browser/extensions/pdfjs/content/web/debugger.js@6474c204b198 (annotated)

browser/extensions/pdfjs/content/web/debugger.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */
 /* Copyright 2012 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 /* globals PDFJS */
 'use strict';
 var FontInspector = (function FontInspectorClosure() {
   var fonts;
   var active = false;
   var fontAttribute = 'data-font-name';
   function removeSelection() {
     var divs = document.querySelectorAll('div[' + fontAttribute + ']');
     for (var i = 0, ii = divs.length; i < ii; ++i) {
       var div = divs[i];
       div.className = '';
     }
   }
   function resetSelection() {
     var divs = document.querySelectorAll('div[' + fontAttribute + ']');
     for (var i = 0, ii = divs.length; i < ii; ++i) {
       var div = divs[i];
       div.className = 'debuggerHideText';
     }
   }
   function selectFont(fontName, show) {
     var divs = document.querySelectorAll('div[' + fontAttribute + '=' +
                                          fontName + ']');
     for (var i = 0, ii = divs.length; i < ii; ++i) {
       var div = divs[i];
       div.className = show ? 'debuggerShowText' : 'debuggerHideText';
     }
   }
   function textLayerClick(e) {
     if (!e.target.dataset.fontName ||
         e.target.tagName.toUpperCase() !== 'DIV') {
       return;
     }
     var fontName = e.target.dataset.fontName;
     var selects = document.getElementsByTagName('input');
     for (var i = 0; i < selects.length; ++i) {
       var select = selects[i];
       if (select.dataset.fontName != fontName) {
         continue;
       }
       select.checked = !select.checked;
       selectFont(fontName, select.checked);
       select.scrollIntoView();
     }
   }
   return {
     // Properties/functions needed by PDFBug.
     id: 'FontInspector',
     name: 'Font Inspector',
     panel: null,
     manager: null,
     init: function init() {
       var panel = this.panel;
       panel.setAttribute('style', 'padding: 5px;');
       var tmp = document.createElement('button');
       tmp.addEventListener('click', resetSelection);
       tmp.textContent = 'Refresh';
       panel.appendChild(tmp);
       fonts = document.createElement('div');
       panel.appendChild(fonts);
     },
     cleanup: function cleanup() {
       fonts.textContent = '';
     },
     enabled: false,
     get active() {
       return active;
     },
     set active(value) {
       active = value;
       if (active) {
         document.body.addEventListener('click', textLayerClick, true);
         resetSelection();
       } else {
         document.body.removeEventListener('click', textLayerClick, true);
         removeSelection();
       }
     },
     // FontInspector specific functions.
     fontAdded: function fontAdded(fontObj, url) {
       function properties(obj, list) {
         var moreInfo = document.createElement('table');
         for (var i = 0; i < list.length; i++) {
           var tr = document.createElement('tr');
           var td1 = document.createElement('td');
           td1.textContent = list[i];
           tr.appendChild(td1);
           var td2 = document.createElement('td');
           td2.textContent = obj[list[i]].toString();
           tr.appendChild(td2);
           moreInfo.appendChild(tr);
         }
         return moreInfo;
       }
       var moreInfo = properties(fontObj, ['name', 'type']);
       var m = /url\(['"]?([^\)"']+)/.exec(url);
       var fontName = fontObj.loadedName;
       var font = document.createElement('div');
       var name = document.createElement('span');
       name.textContent = fontName;
       var download = document.createElement('a');
       download.href = m[1];
       download.textContent = 'Download';
       var logIt = document.createElement('a');
       logIt.href = '';
       logIt.textContent = 'Log';
       logIt.addEventListener('click', function(event) {
         event.preventDefault();
         console.log(fontObj);
       });
       var select = document.createElement('input');
       select.setAttribute('type', 'checkbox');
       select.dataset.fontName = fontName;
       select.addEventListener('click', (function(select, fontName) {
         return (function() {
            selectFont(fontName, select.checked);
         });
       })(select, fontName));
       font.appendChild(select);
       font.appendChild(name);
       font.appendChild(document.createTextNode(' '));
       font.appendChild(download);
       font.appendChild(document.createTextNode(' '));
       font.appendChild(logIt);
       font.appendChild(moreInfo);
       fonts.appendChild(font);
       // Somewhat of a hack, should probably add a hook for when the text layer
       // is done rendering.
       setTimeout(function() {
         if (this.active) {
           resetSelection();
         }
       }.bind(this), 2000);
     }
   };
 })();
 // Manages all the page steppers.
 var StepperManager = (function StepperManagerClosure() {
   var steppers = [];
   var stepperDiv = null;
   var stepperControls = null;
   var stepperChooser = null;
   var breakPoints = {};
   return {
     // Properties/functions needed by PDFBug.
     id: 'Stepper',
     name: 'Stepper',
     panel: null,
     manager: null,
     init: function init() {
       var self = this;
       this.panel.setAttribute('style', 'padding: 5px;');
       stepperControls = document.createElement('div');
       stepperChooser = document.createElement('select');
       stepperChooser.addEventListener('change', function(event) {
         self.selectStepper(this.value);
       });
       stepperControls.appendChild(stepperChooser);
       stepperDiv = document.createElement('div');
       this.panel.appendChild(stepperControls);
       this.panel.appendChild(stepperDiv);
       if (sessionStorage.getItem('pdfjsBreakPoints')) {
         breakPoints = JSON.parse(sessionStorage.getItem('pdfjsBreakPoints'));
       }
     },
     cleanup: function cleanup() {
       stepperChooser.textContent = '';
       stepperDiv.textContent = '';
       steppers = [];
     },
     enabled: false,
     active: false,
     // Stepper specific functions.
     create: function create(pageIndex) {
       var debug = document.createElement('div');
       debug.id = 'stepper' + pageIndex;
       debug.setAttribute('hidden', true);
       debug.className = 'stepper';
       stepperDiv.appendChild(debug);
       var b = document.createElement('option');
       b.textContent = 'Page ' + (pageIndex + 1);
       b.value = pageIndex;
       stepperChooser.appendChild(b);
       var initBreakPoints = breakPoints[pageIndex] || [];
       var stepper = new Stepper(debug, pageIndex, initBreakPoints);
       steppers.push(stepper);
       if (steppers.length === 1) {
         this.selectStepper(pageIndex, false);
       }
       return stepper;
     },
     selectStepper: function selectStepper(pageIndex, selectPanel) {
       var i;
       if (selectPanel) {
         this.manager.selectPanel(this);
       }
       for (i = 0; i < steppers.length; ++i) {
         var stepper = steppers[i];
         if (stepper.pageIndex == pageIndex) {
           stepper.panel.removeAttribute('hidden');
         } else {
           stepper.panel.setAttribute('hidden', true);
         }
       }
       var options = stepperChooser.options;
       for (i = 0; i < options.length; ++i) {
         var option = options[i];
         option.selected = option.value == pageIndex;
       }
     },
     saveBreakPoints: function saveBreakPoints(pageIndex, bps) {
       breakPoints[pageIndex] = bps;
       sessionStorage.setItem('pdfjsBreakPoints', JSON.stringify(breakPoints));
     }
   };
 })();
 // The stepper for each page's IRQueue.
 var Stepper = (function StepperClosure() {
   // Shorter way to create element and optionally set textContent.
   function c(tag, textContent) {
     var d = document.createElement(tag);
     if (textContent) {
       d.textContent = textContent;
     }
     return d;
   }
   function glyphsToString(glyphs) {
     var out = '';
     for (var i = 0; i < glyphs.length; i++) {
       if (glyphs[i] === null) {
         out += ' ';
       } else {
         out += glyphs[i].fontChar;
       }
     }
     return out;
   }
   var opMap = null;
   var glyphCommands = {
     'showText': 0,
     'showSpacedText': 0,
     'nextLineShowText': 0,
     'nextLineSetSpacingShowText': 2
   };
   function simplifyArgs(args) {
     if (typeof args === 'string') {
       var MAX_STRING_LENGTH = 75;
       return args.length <= MAX_STRING_LENGTH ? args :
         args.substr(0, MAX_STRING_LENGTH) + '...';
     }
     if (typeof args !== 'object' || args === null) {
       return args;
     }
     if ('length' in args) { // array
       var simpleArgs = [], i, ii;
       var MAX_ITEMS = 10;
       for (i = 0, ii = Math.min(MAX_ITEMS, args.length); i < ii; i++) {
         simpleArgs.push(simplifyArgs(args[i]));
       }
       if (i < args.length) {
         simpleArgs.push('...');
       }
       return simpleArgs;
     }
     var simpleObj = {};
     for (var key in args) {
       simpleObj[key] = simplifyArgs(args[key]);
     }
     return simpleObj;
   }
   function Stepper(panel, pageIndex, initialBreakPoints) {
     this.panel = panel;
     this.breakPoint = 0;
     this.nextBreakPoint = null;
     this.pageIndex = pageIndex;
     this.breakPoints = initialBreakPoints;
     this.currentIdx = -1;
     this.operatorListIdx = 0;
   }
   Stepper.prototype = {
     init: function init() {
       var panel = this.panel;
       var content = c('div', 'c=continue, s=step');
       var table = c('table');
       content.appendChild(table);
       table.cellSpacing = 0;
       var headerRow = c('tr');
       table.appendChild(headerRow);
       headerRow.appendChild(c('th', 'Break'));
       headerRow.appendChild(c('th', 'Idx'));
       headerRow.appendChild(c('th', 'fn'));
       headerRow.appendChild(c('th', 'args'));
       panel.appendChild(content);
       this.table = table;
       if (!opMap) {
         opMap = Object.create(null);
         for (var key in PDFJS.OPS) {
           opMap[PDFJS.OPS[key]] = key;
         }
       }
     },
     updateOperatorList: function updateOperatorList(operatorList) {
       var self = this;
       function cboxOnClick() {
         var x = +this.dataset.idx;
         if (this.checked) {
           self.breakPoints.push(x);
         } else {
           self.breakPoints.splice(self.breakPoints.indexOf(x), 1);
         }
         StepperManager.saveBreakPoints(self.pageIndex, self.breakPoints);
       }
       var MAX_OPERATORS_COUNT = 15000;
       if (this.operatorListIdx > MAX_OPERATORS_COUNT) {
         return;
       }
       var chunk = document.createDocumentFragment();
       var operatorsToDisplay = Math.min(MAX_OPERATORS_COUNT,
                                         operatorList.fnArray.length);
       for (var i = this.operatorListIdx; i < operatorsToDisplay; i++) {
         var line = c('tr');
         line.className = 'line';
         line.dataset.idx = i;
         chunk.appendChild(line);
         var checked = this.breakPoints.indexOf(i) != -1;
         var args = operatorList.argsArray[i] || [];
         var breakCell = c('td');
         var cbox = c('input');
         cbox.type = 'checkbox';
         cbox.className = 'points';
         cbox.checked = checked;
         cbox.dataset.idx = i;
         cbox.onclick = cboxOnClick;
         breakCell.appendChild(cbox);
         line.appendChild(breakCell);
         line.appendChild(c('td', i.toString()));
         var fn = opMap[operatorList.fnArray[i]];
         var decArgs = args;
         if (fn in glyphCommands) {
           var glyphIndex = glyphCommands[fn];
           var glyphs = args[glyphIndex];
           decArgs = args.slice();
           var newArg;
           if (fn === 'showSpacedText') {
             newArg = [];
             for (var j = 0; j < glyphs.length; j++) {
               if (typeof glyphs[j] === 'number') {
                 newArg.push(glyphs[j]);
               } else {
                 newArg.push(glyphsToString(glyphs[j]));
               }
             }
           } else {
             newArg = glyphsToString(glyphs);
           }
           decArgs[glyphIndex] = newArg;
         }
         line.appendChild(c('td', fn));
         line.appendChild(c('td', JSON.stringify(simplifyArgs(decArgs))));
       }
       if (operatorsToDisplay < operatorList.fnArray.length) {
         line = c('tr');
         var lastCell = c('td', '...');
         lastCell.colspan = 4;
         chunk.appendChild(lastCell);
       }
       this.operatorListIdx = operatorList.fnArray.length;
       this.table.appendChild(chunk);
     },
     getNextBreakPoint: function getNextBreakPoint() {
       this.breakPoints.sort(function(a, b) { return a - b; });
       for (var i = 0; i < this.breakPoints.length; i++) {
         if (this.breakPoints[i] > this.currentIdx) {
           return this.breakPoints[i];
         }
       }
       return null;
     },
     breakIt: function breakIt(idx, callback) {
       StepperManager.selectStepper(this.pageIndex, true);
       var self = this;
       var dom = document;
       self.currentIdx = idx;
       var listener = function(e) {
         switch (e.keyCode) {
           case 83: // step
             dom.removeEventListener('keydown', listener, false);
             self.nextBreakPoint = self.currentIdx + 1;
             self.goTo(-1);
             callback();
             break;
           case 67: // continue
             dom.removeEventListener('keydown', listener, false);
             var breakPoint = self.getNextBreakPoint();
             self.nextBreakPoint = breakPoint;
             self.goTo(-1);
             callback();
             break;
         }
       };
       dom.addEventListener('keydown', listener, false);
       self.goTo(idx);
     },
     goTo: function goTo(idx) {
       var allRows = this.panel.getElementsByClassName('line');
       for (var x = 0, xx = allRows.length; x < xx; ++x) {
         var row = allRows[x];
         if (row.dataset.idx == idx) {
           row.style.backgroundColor = 'rgb(251,250,207)';
           row.scrollIntoView();
         } else {
           row.style.backgroundColor = null;
         }
       }
     }
   };
   return Stepper;
 })();
 var Stats = (function Stats() {
   var stats = [];
   function clear(node) {
     while (node.hasChildNodes()) {
       node.removeChild(node.lastChild);
     }
   }
   function getStatIndex(pageNumber) {
     for (var i = 0, ii = stats.length; i < ii; ++i) {
       if (stats[i].pageNumber === pageNumber) {
         return i;
       }
     }
     return false;
   }
   return {
     // Properties/functions needed by PDFBug.
     id: 'Stats',
     name: 'Stats',
     panel: null,
     manager: null,
     init: function init() {
       this.panel.setAttribute('style', 'padding: 5px;');
       PDFJS.enableStats = true;
     },
     enabled: false,
     active: false,
     // Stats specific functions.
     add: function(pageNumber, stat) {
       if (!stat) {
         return;
       }
       var statsIndex = getStatIndex(pageNumber);
       if (statsIndex !== false) {
         var b = stats[statsIndex];
         this.panel.removeChild(b.div);
         stats.splice(statsIndex, 1);
       }
       var wrapper = document.createElement('div');
       wrapper.className = 'stats';
       var title = document.createElement('div');
       title.className = 'title';
       title.textContent = 'Page: ' + pageNumber;
       var statsDiv = document.createElement('div');
       statsDiv.textContent = stat.toString();
       wrapper.appendChild(title);
       wrapper.appendChild(statsDiv);
       stats.push({ pageNumber: pageNumber, div: wrapper });
       stats.sort(function(a, b) { return a.pageNumber - b.pageNumber; });
       clear(this.panel);
       for (var i = 0, ii = stats.length; i < ii; ++i) {
         this.panel.appendChild(stats[i].div);
       }
     },
     cleanup: function () {
       stats = [];
       clear(this.panel);
     }
   };
 })();
 // Manages all the debugging tools.
 var PDFBug = (function PDFBugClosure() {
   var panelWidth = 300;
   var buttons = [];
   var activePanel = null;
   return {
     tools: [
       FontInspector,
       StepperManager,
       Stats
     ],
     enable: function(ids) {
       var all = false, tools = this.tools;
       if (ids.length === 1 && ids[0] === 'all') {
         all = true;
       }
       for (var i = 0; i < tools.length; ++i) {
         var tool = tools[i];
         if (all || ids.indexOf(tool.id) !== -1) {
           tool.enabled = true;
         }
       }
       if (!all) {
         // Sort the tools by the order they are enabled.
         tools.sort(function(a, b) {
           var indexA = ids.indexOf(a.id);
           indexA = indexA < 0 ? tools.length : indexA;
           var indexB = ids.indexOf(b.id);
           indexB = indexB < 0 ? tools.length : indexB;
           return indexA - indexB;
         });
       }
     },
     init: function init() {
       /*
        * Basic Layout:
        * PDFBug
        *  Controls
        *  Panels
        *    Panel
        *    Panel
        *    ...
        */
       var ui = document.createElement('div');
       ui.id = 'PDFBug';
       var controls = document.createElement('div');
       controls.setAttribute('class', 'controls');
       ui.appendChild(controls);
       var panels = document.createElement('div');
       panels.setAttribute('class', 'panels');
       ui.appendChild(panels);
       var container = document.getElementById('viewerContainer');
       container.appendChild(ui);
       container.style.right = panelWidth + 'px';
       // Initialize all the debugging tools.
       var tools = this.tools;
       var self = this;
       for (var i = 0; i < tools.length; ++i) {
         var tool = tools[i];
         var panel = document.createElement('div');
         var panelButton = document.createElement('button');
         panelButton.textContent = tool.name;
         panelButton.addEventListener('click', (function(selected) {
           return function(event) {
             event.preventDefault();
             self.selectPanel(selected);
           };
         })(i));
         controls.appendChild(panelButton);
         panels.appendChild(panel);
         tool.panel = panel;
         tool.manager = this;
         if (tool.enabled) {
           tool.init();
         } else {
           panel.textContent = tool.name + ' is disabled. To enable add ' +
                               ' "' + tool.id + '" to the pdfBug parameter ' +
                               'and refresh (seperate multiple by commas).';
         }
         buttons.push(panelButton);
       }
       this.selectPanel(0);
     },
     cleanup: function cleanup() {
       for (var i = 0, ii = this.tools.length; i < ii; i++) {
         if (this.tools[i].enabled) {
           this.tools[i].cleanup();
         }
       }
     },
     selectPanel: function selectPanel(index) {
       if (typeof index !== 'number') {
         index = this.tools.indexOf(index);
       }
       if (index === activePanel) {
         return;
       }
       activePanel = index;
       var tools = this.tools;
       for (var j = 0; j < tools.length; ++j) {
         if (j == index) {
           buttons[j].setAttribute('class', 'active');
           tools[j].active = true;
           tools[j].panel.removeAttribute('hidden');
         } else {
           buttons[j].setAttribute('class', '');
           tools[j].active = false;
           tools[j].panel.setAttribute('hidden', 'true');
         }
       }
     }
   };
 })();