chrome/browser/resources/cryptotoken/webrequestsender.js

   1 // Copyright 2014 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  * @fileoverview Provides a representation of a web request sender, and
   7  * utility functions for creating them.
   8  */
   9 'use strict';
  10
  11 /**
  12  * @typedef {{
  13  *   origin: string,
  14  *   tlsChannelId: (string|undefined),
  15  *   tabId: (number|undefined)
  16  * }}
  17  */
  18 var WebRequestSender;
  19
  20 /**
  21  * Creates an object representing the sender's origin, and, if available,
  22  * tab.
  23  * @param {MessageSender} messageSender The message sender.
  24  * @return {?WebRequestSender} The sender's origin and tab, or null if the
  25  *     sender is invalid.
  26  */
  27 function createSenderFromMessageSender(messageSender) {
  28   var origin = getOriginFromUrl(/** @type {string} */ (messageSender.url));
  29   if (!origin) {
  30     return null;
  31   }
  32   var sender = {
  33     origin: origin
  34   };
  35   if (messageSender.tlsChannelId) {
  36     sender.tlsChannelId = messageSender.tlsChannelId;
  37   }
  38   if (messageSender.tab) {
  39     sender.tabId = messageSender.tab.id;
  40   }
  41   return sender;
  42 }
  43
  44 /**
  45  * Checks whether the given tab could have sent a message from the given
  46  * origin.
  47  * @param {Tab} tab The tab to match
  48  * @param {string} origin The origin to check.
  49  * @return {Promise} A promise resolved with the tab id if it the tab could,
  50  *     have sent the request, and rejected if it can't.
  51  */
  52 function tabMatchesOrigin(tab, origin) {
  53   return new Promise(function(resolve, reject) {
  54     // If the tab's origin matches, trust that the request came from this tab.
  55     if (getOriginFromUrl(tab.url) == origin) {
  56       resolve(tab.id);
  57       return;
  58     }
  59     // Look for an iframe in the current tab matching the origin.
  60     chrome.tabs.executeScript(tab.id, { file: 'taborigincs.js' }, function() {
  61         chrome.tabs.sendMessage(tab.id, { origin: origin },
  62             function(response) {
  63               if (response) {
  64                 resolve(tab.id);
  65               } else {
  66                 reject(false);
  67               }
  68             });
  69       });
  70   });
  71 }
  72
  73 /**
  74  * Attempts to ensure that the tabId of the sender is set, using chrome.tabs
  75  * when available.
  76  * @param {WebRequestSender} sender The request sender.
  77  * @return {Promise} A promise resolved once the tabId retrieval is done.
  78  *     The promise is rejected if the tabId is untrustworthy, e.g. if the
  79  *     user rapidly switched tabs.
  80  */
  81 function getTabIdWhenPossible(sender) {
  82   if (sender.tabId) {
  83     // Already got it? Done.
  84     return Promise.resolve(true);
  85   } else if (!chrome.tabs) {
  86     // Can't get it? Done. (This happens to packaged apps, which can't access
  87     // chrome.tabs.)
  88     return Promise.resolve(true);
  89   } else {
  90     return new Promise(function(resolve, reject) {
  91       chrome.tabs.query({active: true, lastFocusedWindow: true},
  92           function(tabs) {
  93             if (!tabs.length) {
  94               // Safety check.
  95               reject(false);
  96               return;
  97             }
  98             var tab = tabs[0];
  99             tabMatchesOrigin(tab, sender.origin).then(function(tabId) {
 100               sender.tabId = tabId;
 101               resolve(true);
 102             }, function() {
 103               // Didn't match? Check if the debugger is open.
 104               if (tab.url.indexOf('chrome-devtools://') != 0) {
 105                 reject(false);
 106                 return;
 107               }
 108               // Debugger active: find first tab with the sender's origin.
 109               chrome.tabs.query({active: true}, function(tabs) {
 110                 if (!tabs.length) {
 111                   // Safety check.
 112                   reject(false);
 113                   return;
 114                 }
 115                 var numRejected = 0;
 116                 for (var i = 0; i < tabs.length; i++) {
 117                   tab = tabs[i];
 118                   tabMatchesOrigin(tab, sender.origin).then(function(tabId) {
 119                     sender.tabId = tabId;
 120                     resolve(true);
 121                   }, function() {
 122                     if (++numRejected >= tabs.length) {
 123                       // None matches: reject.
 124                       reject(false);
 125                     }
 126                   });
 127                 }
 128               });
 129             });
 130           });
 131     });
 132   }
 133 }
 134
 135 /**
 136  * Checks whether the given tab is in the foreground, i.e. is the active tab
 137  * of the focused window.
 138  * @param {number} tabId The tab id to check.
 139  * @return {Promise<boolean>} A promise for the result of the check.
 140  */
 141 function tabInForeground(tabId) {
 142   return new Promise(function(resolve, reject) {
 143       if (!chrome.tabs || !chrome.tabs.get) {
 144         reject();
 145         return;
 146       }
 147       if (!chrome.windows || !chrome.windows.get) {
 148         reject();
 149         return;
 150       }
 151       chrome.tabs.get(tabId, function(tab) {
 152             if (chrome.runtime.lastError) {
 153               resolve(false);
 154               return;
 155             }
 156             if (!tab.active) {
 157               resolve(false);
 158               return;
 159             }
 160             chrome.windows.get(tab.windowId, function(aWindow) {
 161                   resolve(aWindow && aWindow.focused);
 162                 });
 163           });
 164   });
 165 }