Upgrade to manifest version 2.

I use the beta channel by default, and it no longer allows me to run
development builds with the old manifest version.

1 files changed, 810 insertions, 0 deletions

diff --git a/background_scripts/main.js b/background_scripts/main.js
new file mode 100644
index 00000000..49790b87
--- /dev/null
+++ b/background_scripts/main.js
@@ -0,0 +1,810 @@
+var currentVersion = Utils.getCurrentVersion();
+
+var tabQueue = {}; // windowId -> Array
+var openTabs = {}; // tabId -> object with various tab properties
+var keyQueue = ""; // Queue of keys typed
+var validFirstKeys = {};
+var singleKeyCommands = [];
+var focusedFrame = null;
+var framesForTab = {};
+
+// Keys are either literal characters, or "named" - for example <a-b> (alt+b), <left> (left arrow) or <f12>
+// This regular expression captures two groups: the first is a named key, the second is the remainder of
+// the string.
+var namedKeyRegex = /^(<(?:[amc]-.|(?:[amc]-)?[a-z0-9]{2,5})>)(.*)$/;
+
+// Port handler mapping
+var portHandlers = {
+  keyDown:              handleKeyDown,
+  returnScrollPosition: handleReturnScrollPosition,
+  getCurrentTabUrl:     getCurrentTabUrl,
+  settings:             handleSettings,
+  filterCompleter:      filterCompleter
+};
+
+var sendRequestHandlers = {
+  getCompletionKeys: getCompletionKeysRequest,
+  getLinkHintCss: getLinkHintCss,
+  openUrlInNewTab: openUrlInNewTab,
+  openUrlInCurrentTab: openUrlInCurrentTab,
+  openOptionsPageInNewTab: openOptionsPageInNewTab,
+  registerFrame: registerFrame,
+  frameFocused: handleFrameFocused,
+  upgradeNotificationClosed: upgradeNotificationClosed,
+  updateScrollPosition: handleUpdateScrollPosition,
+  copyToClipboard: copyToClipboard,
+  isEnabledForUrl: isEnabledForUrl,
+  saveHelpDialogSettings: saveHelpDialogSettings,
+  selectSpecificTab: selectSpecificTab,
+  refreshCompleter: refreshCompleter
+};
+
+// Event handlers
+var selectionChangedHandlers = [];
+var getScrollPositionHandlers = {}; // tabId -> function(tab, scrollX, scrollY);
+var tabLoadedHandlers = {}; // tabId -> function()
+
+var completionSources = {
+  bookmarks: new BookmarkCompleter(),
+  history: new HistoryCompleter(),
+  domains: new DomainCompleter(),
+  tabs: new TabCompleter()
+};
+
+var completers = {
+  omni: new MultiCompleter([
+    completionSources.bookmarks,
+    completionSources.history,
+    completionSources.domains]),
+  bookmarks: new MultiCompleter([completionSources.bookmarks]),
+  tabs: new MultiCompleter([completionSources.tabs])
+};
+
+chrome.extension.onConnect.addListener(function(port, name) {
+  var senderTabId = port.sender.tab ? port.sender.tab.id : null;
+  // If this is a tab we've been waiting to open, execute any "tab loaded" handlers, e.g. to restore
+  // the tab's scroll position. Wait until domReady before doing this; otherwise operations like restoring
+  // the scroll position will not be possible.
+  if (port.name === "domReady" && senderTabId !== null) {
+    if (tabLoadedHandlers[senderTabId]) {
+      var toCall = tabLoadedHandlers[senderTabId];
+      // Delete first to be sure there's no circular events.
+      delete tabLoadedHandlers[senderTabId];
+      toCall.call();
+    }
+
+    // domReady is the appropriate time to show the "vimium has been upgraded" message.
+    // TODO: This might be broken on pages with frames.
+    if (shouldShowUpgradeMessage())
+      chrome.tabs.sendRequest(senderTabId, { name: "showUpgradeNotification", version: currentVersion });
+  }
+
+  if (portHandlers[port.name])
+    port.onMessage.addListener(portHandlers[port.name]);
+});
+
+chrome.extension.onRequest.addListener(function (request, sender, sendResponse) {
+  var senderTabId = sender.tab ? sender.tab.id : null;
+  if (sendRequestHandlers[request.handler])
+    sendResponse(sendRequestHandlers[request.handler](request, sender));
+});
+
+function handleReturnScrollPosition(args) {
+  if (getScrollPositionHandlers[args.currentTab.id]) {
+    // Delete first to be sure there's no circular events.
+    var toCall = getScrollPositionHandlers[args.currentTab.id];
+    delete getScrollPositionHandlers[args.currentTab.id];
+    toCall(args.currentTab, args.scrollX, args.scrollY);
+  }
+}
+
+/*
+ * Used by the content scripts to get their full URL. This is needed for URLs like "view-source:http:// .."
+ * because window.location doesn't know anything about the Chrome-specific "view-source:".
+ */
+function getCurrentTabUrl(args, port) {
+  var returnPort = chrome.tabs.connect(port.sender.tab.id, { name: "returnCurrentTabUrl" });
+  returnPort.postMessage({ url: port.sender.tab.url });
+}
+
+/*
+ * Checks the user's preferences in local storage to determine if Vimium is enabled for the given URL.
+ */
+function isEnabledForUrl(request) {
+  // excludedUrls are stored as a series of URL expressions separated by newlines.
+  var excludedUrls = Settings.get("excludedUrls").split("\n");
+  var isEnabled = true;
+  for (var i = 0; i < excludedUrls.length; i++) {
+    // The user can add "*" to the URL which means ".*"
+    var regexp = new RegExp("^" + excludedUrls[i].replace(/\*/g, ".*") + "$");
+    if (request.url.match(regexp))
+      isEnabled = false;
+  }
+  return { isEnabledForUrl: isEnabled };
+}
+
+/*
+ * Called by the popup UI. Strips leading/trailing whitespace and ignores empty strings.
+ */
+function addExcludedUrl(url) {
+  url = trim(url);
+  if (url === "") { return; }
+
+  var excludedUrls = Settings.get("excludedUrls");
+  excludedUrls += "\n" + url;
+  Settings.set("excludedUrls", excludedUrls);
+
+  chrome.tabs.query({ windowId: chrome.windows.WINDOW_ID_CURRENT, active: true }, function(tabs) {
+    updateActiveState(tabs[0].id);
+  });
+}
+
+function saveHelpDialogSettings(request) {
+  Settings.set("helpDialog_showAdvancedCommands", request.showAdvancedCommands);
+}
+
+function showHelp(callback, frameId) {
+  chrome.tabs.getSelected(null, function(tab) {
+    chrome.tabs.sendRequest(tab.id,
+      { name: "showHelpDialog", dialogHtml: helpDialogHtml(), frameId:frameId });
+  });
+}
+
+/*
+ * Retrieves the help dialog HTML template from a file, and populates it with the latest keybindings.
+ */
+function helpDialogHtml(showUnboundCommands, showCommandNames, customTitle) {
+  var commandsToKey = {};
+  for (var key in Commands.keyToCommandRegistry) {
+    var command = Commands.keyToCommandRegistry[key].command;
+    commandsToKey[command] = (commandsToKey[command] || []).concat(key);
+  }
+  var dialogHtml = fetchFileContents("help_dialog.html");
+  for (var group in Commands.commandGroups)
+    dialogHtml = dialogHtml.replace("{{" + group + "}}",
+        helpDialogHtmlForCommandGroup(group, commandsToKey, Commands.availableCommands,
+                                      showUnboundCommands, showCommandNames));
+  dialogHtml = dialogHtml.replace("{{version}}", currentVersion);
+  dialogHtml = dialogHtml.replace("{{title}}", customTitle || "Help");
+  dialogHtml = dialogHtml.replace("{{showAdvancedCommands}}",
+      Settings.get("helpDialog_showAdvancedCommands"));
+  return dialogHtml;
+}
+
+/*
+ * Generates HTML for a given set of commands. commandGroups are defined in commands.js
+ */
+function helpDialogHtmlForCommandGroup(group, commandsToKey, availableCommands,
+                                       showUnboundCommands, showCommandNames) {
+  var html = [];
+  for (var i = 0; i < Commands.commandGroups[group].length; i++) {
+    var command = Commands.commandGroups[group][i];
+    bindings = (commandsToKey[command] || [""]).join(", ");
+    if (showUnboundCommands || commandsToKey[command]) {
+      html.push(
+        "<tr class='vimiumReset " +
+            (Commands.advancedCommands.indexOf(command) >= 0 ? "advanced" : "") + "'>",
+        "<td class='vimiumReset'>", Utils.escapeHtml(bindings), "</td>",
+        "<td class='vimiumReset'>:</td><td class='vimiumReset'>", availableCommands[command].description);
+
+      if (showCommandNames)
+        html.push("<span class='vimiumReset commandName'>(" + command + ")</span>");
+
+      html.push("</td></tr>");
+    }
+  }
+  return html.join("\n");
+}
+
+/*
+ * Fetches the contents of a file bundled with this extension.
+ */
+function fetchFileContents(extensionFileName) {
+  var req = new XMLHttpRequest();
+  req.open("GET", chrome.extension.getURL(extensionFileName), false); // false => synchronous
+  req.send();
+  return req.responseText;
+}
+
+/**
+ * Returns the keys that can complete a valid command given the current key queue.
+ */
+function getCompletionKeysRequest(request) {
+  return { name: "refreshCompletionKeys",
+           completionKeys: generateCompletionKeys(),
+           validFirstKeys: validFirstKeys
+         };
+}
+
+/*
+  * Opens the url in the current tab.
+  */
+ function openUrlInCurrentTab(request) {
+   chrome.tabs.getSelected(null, function(tab) {
+     chrome.tabs.update(tab.id, { url: Utils.convertToUrl(request.url) });
+   });
+ }
+
+/*
+ * Opens request.url in new tab and switches to it if request.selected is true.
+ */
+function openUrlInNewTab(request) {
+  chrome.tabs.getSelected(null, function(tab) {
+    chrome.tabs.create({ url: Utils.convertToUrl(request.url), index: tab.index + 1, selected: true });
+  });
+}
+
+function openCopiedUrlInCurrentTab(request) { openUrlInCurrentTab({ url: Clipboard.paste() }); }
+
+function openCopiedUrlInNewTab(request) { openUrlInNewTab({ url: Clipboard.paste() }); }
+
+/*
+ * Returns the user-provided CSS overrides.
+ */
+function getLinkHintCss(request) {
+  return { linkHintCss: (Settings.get("userDefinedLinkHintCss") || "") };
+}
+
+/*
+ * Called when the user has clicked the close icon on the "Vimium has been updated" message.
+ * We should now dismiss that message in all tabs.
+ */
+function upgradeNotificationClosed(request) {
+  Settings.set("previousVersion", currentVersion);
+  sendRequestToAllTabs({ name: "hideUpgradeNotification" });
+}
+
+/*
+ * Copies some data (request.data) to the clipboard.
+ */
+function copyToClipboard(request) {
+  Clipboard.copy(request.data);
+}
+
+/**
+  * Selects the tab with the ID specified in request.id
+  */
+function selectSpecificTab(request) {
+  chrome.tabs.update(request.id, { selected: true });
+}
+
+/*
+ * Used by the content scripts to get settings from the local storage.
+ */
+function handleSettings(args, port) {
+  if (args.operation == "get") {
+    var value = Settings.get(args.key);
+    port.postMessage({ key: args.key, value: value });
+  }
+  else { // operation == "set"
+    Settings.set(args.key, args.value);
+  }
+}
+
+function refreshCompleter(request) {
+  completers[request.name].refresh();
+}
+
+function filterCompleter(args, port) {
+  var queryTerms = args.query === "" ? [] : args.query.split(" ");
+  completers[args.name].filter(queryTerms, function(results) {
+    port.postMessage({ id: args.id, results: results });
+  });
+}
+
+/*
+ * Used by everyone to get settings from local storage.
+ */
+function getSettingFromLocalStorage(setting) {
+  if (localStorage[setting] !== "" && !localStorage[setting]) {
+    return defaultSettings[setting];
+  } else {
+    return localStorage[setting];
+  }
+}
+
+function getCurrentTimeInSeconds() { Math.floor((new Date()).getTime() / 1000); }
+
+chrome.tabs.onSelectionChanged.addListener(function(tabId, selectionInfo) {
+  if (selectionChangedHandlers.length > 0) { selectionChangedHandlers.pop().call(); }
+});
+
+function repeatFunction(func, totalCount, currentCount, frameId) {
+  if (currentCount < totalCount)
+    func(function() { repeatFunction(func, totalCount, currentCount + 1, frameId); }, frameId);
+}
+
+// Returns the scroll coordinates of the given tab. Pass in a callback of the form:
+//   function(tab, scrollX, scrollY) { .. }
+function getScrollPosition(tab, callback) {
+  getScrollPositionHandlers[tab.id] = callback;
+  var scrollPort = chrome.tabs.connect(tab.id, { name: "getScrollPosition" });
+  scrollPort.postMessage({currentTab: tab});
+}
+
+// Start action functions
+function createTab(callback) {
+  chrome.tabs.create({}, function(tab) { callback(); });
+}
+
+function nextTab(callback) { selectTab(callback, "next"); }
+function previousTab(callback) { selectTab(callback, "previous"); }
+function firstTab(callback) { selectTab(callback, "first"); }
+function lastTab(callback) { selectTab(callback, "last"); }
+
+/*
+ * Selects a tab before or after the currently selected tab. Direction is either "next", "previous", "first" or "last".
+ */
+function selectTab(callback, direction) {
+  chrome.tabs.getAllInWindow(null, function(tabs) {
+    if (tabs.length <= 1)
+      return;
+    chrome.tabs.getSelected(null, function(currentTab) {
+        switch (direction) {
+          case "next":
+            toSelect = tabs[(currentTab.index + 1 + tabs.length) % tabs.length];
+            break;
+          case "previous":
+            toSelect = tabs[(currentTab.index - 1 + tabs.length) % tabs.length];
+            break;
+          case "first":
+            toSelect = tabs[0];
+            break;
+          case "last":
+            toSelect = tabs[tabs.length - 1];
+            break;
+        }
+        selectionChangedHandlers.push(callback);
+        chrome.tabs.update(toSelect.id, { selected: true });
+    });
+  });
+}
+
+function removeTab(callback) {
+  chrome.tabs.getSelected(null, function(tab) {
+    chrome.tabs.remove(tab.id);
+    // We can't just call the callback here because we actually need to wait
+    // for the selection to change to consider this action done.
+    selectionChangedHandlers.push(callback);
+  });
+}
+
+function updateOpenTabs(tab) {
+  openTabs[tab.id] = { url: tab.url, positionIndex: tab.index, windowId: tab.windowId };
+  // Frames are recreated on refresh
+  delete framesForTab[tab.id];
+}
+
+/* Updates the browserAction icon to indicated whether Vimium is enabled or disabled on the current page.
+ * Also disables Vimium if it is currently enabled but should be disabled according to the url blacklist.
+ * This lets you disable Vimium on a page without needing to reload.
+ *
+ * Three situations are considered:
+ * 1. Active tab is disabled -> disable icon
+ * 2. Active tab is enabled and should be enabled -> enable icon
+ * 3. Active tab is enabled but should be disabled -> disable icon and disable vimium
+ */
+function updateActiveState(tabId) {
+  // TODO(philc): Re-enable once we've restyled the browser action icon.
+  return;
+  var enabledIcon = "icons/icon48.png";
+  var disabledIcon = "icons/icon48disabled.png";
+  chrome.tabs.get(tabId, function(tab) {
+    // Default to disabled state in case we can't connect to Vimium, primarily for the "New Tab" page.
+    // TODO(philc): Re-enable once we've restyled the browser action icon.
+    // chrome.browserAction.setIcon({ path: disabledIcon });
+    var returnPort = chrome.tabs.connect(tabId, { name: "getActiveState" });
+    returnPort.onMessage.addListener(function(response) {
+      var isCurrentlyEnabled = response.enabled;
+      var shouldBeEnabled = isEnabledForUrl({url: tab.url}).isEnabledForUrl;
+
+      if (isCurrentlyEnabled) {
+        if (shouldBeEnabled) {
+          chrome.browserAction.setIcon({ path: enabledIcon });
+        } else {
+          chrome.browserAction.setIcon({ path: disabledIcon });
+          chrome.tabs.connect(tabId, { name: "disableVimium" }).postMessage();
+        }
+      } else {
+        chrome.browserAction.setIcon({ path: disabledIcon });
+      }
+    });
+    returnPort.postMessage();
+  });
+}
+
+function handleUpdateScrollPosition(request, sender) {
+  updateScrollPosition(sender.tab, request.scrollX, request.scrollY);
+}
+
+function updateScrollPosition(tab, scrollX, scrollY) {
+  openTabs[tab.id].scrollX = scrollX;
+  openTabs[tab.id].scrollY = scrollY;
+}
+
+
+chrome.tabs.onUpdated.addListener(function(tabId, changeInfo, tab) {
+  if (changeInfo.status != "loading") { return; } // only do this once per URL change
+  updateOpenTabs(tab);
+  updateActiveState(tabId);
+});
+
+chrome.tabs.onAttached.addListener(function(tabId, attachedInfo) {
+  // We should update all the tabs in the old window and the new window.
+  if (openTabs[tabId]) {
+    updatePositionsAndWindowsForAllTabsInWindow(openTabs[tabId].windowId);
+  }
+  updatePositionsAndWindowsForAllTabsInWindow(attachedInfo.newWindowId);
+});
+
+chrome.tabs.onMoved.addListener(function(tabId, moveInfo) {
+  updatePositionsAndWindowsForAllTabsInWindow(moveInfo.windowId);
+});
+
+chrome.tabs.onRemoved.addListener(function(tabId) {
+  var openTabInfo = openTabs[tabId];
+  updatePositionsAndWindowsForAllTabsInWindow(openTabInfo.windowId);
+
+  // If we restore chrome:// pages, they'll ignore Vimium keystrokes when they reappear.
+  // Pretend they never existed and adjust tab indices accordingly.
+  // Could possibly expand this into a blacklist in the future
+  if (/^chrome[^:]*:\/\/.*/.test(openTabInfo.url)) {
+    for (var i in tabQueue[openTabInfo.windowId]) {
+      if (tabQueue[openTabInfo.windowId][i].positionIndex > openTabInfo.positionIndex)
+        tabQueue[openTabInfo.windowId][i].positionIndex--;
+    }
+    return;
+  }
+
+  if (tabQueue[openTabInfo.windowId])
+    tabQueue[openTabInfo.windowId].push(openTabInfo);
+  else
+    tabQueue[openTabInfo.windowId] = [openTabInfo];
+
+  delete openTabs[tabId];
+  delete framesForTab[tabId];
+});
+
+chrome.tabs.onActiveChanged.addListener(function(tabId, selectInfo) {
+  updateActiveState(tabId);
+});
+
+chrome.windows.onRemoved.addListener(function(windowId) {
+  delete tabQueue[windowId];
+});
+
+function restoreTab(callback) {
+  // TODO(ilya): Should this be getLastFocused instead?
+  chrome.windows.getCurrent(function(window) {
+    if (tabQueue[window.id] && tabQueue[window.id].length > 0)
+    {
+      var tabQueueEntry = tabQueue[window.id].pop();
+
+      // Clean out the tabQueue so we don't have unused windows laying about.
+      if (tabQueue[window.id].length === 0)
+        delete tabQueue[window.id];
+
+      // We have to chain a few callbacks to set the appropriate scroll position. We can't just wait until the
+      // tab is created because the content script is not available during the "loading" state. We need to
+      // wait until that's over before we can call setScrollPosition.
+      chrome.tabs.create({ url: tabQueueEntry.url, index: tabQueueEntry.positionIndex }, function(tab) {
+        tabLoadedHandlers[tab.id] = function() {
+          var scrollPort = chrome.tabs.connect(tab.id, {name: "setScrollPosition"});
+          scrollPort.postMessage({ scrollX: tabQueueEntry.scrollX, scrollY: tabQueueEntry.scrollY });
+        };
+
+        callback();
+      });
+    }
+  });
+}
+// End action functions
+
+function updatePositionsAndWindowsForAllTabsInWindow(windowId) {
+  chrome.tabs.getAllInWindow(windowId, function (tabs) {
+    for (var i = 0; i < tabs.length; i++) {
+      var tab = tabs[i];
+      var openTabInfo = openTabs[tab.id];
+      if (openTabInfo) {
+        openTabInfo.positionIndex = tab.index;
+        openTabInfo.windowId = tab.windowId;
+      }
+    }
+  });
+}
+
+function splitKeyIntoFirstAndSecond(key) {
+  if (key.search(namedKeyRegex) === 0)
+      return { first: RegExp.$1, second: RegExp.$2 };
+  else
+    return { first: key[0], second: key.slice(1) };
+}
+
+function getActualKeyStrokeLength(key) {
+  if (key.search(namedKeyRegex) === 0)
+    return 1 + getActualKeyStrokeLength(RegExp.$2);
+  else
+    return key.length;
+}
+
+function populateValidFirstKeys() {
+  for (var key in Commands.keyToCommandRegistry)
+  {
+    if (getActualKeyStrokeLength(key) == 2)
+      validFirstKeys[splitKeyIntoFirstAndSecond(key).first] = true;
+  }
+}
+
+function populateSingleKeyCommands() {
+  for (var key in Commands.keyToCommandRegistry)
+  {
+    if (getActualKeyStrokeLength(key) == 1)
+      singleKeyCommands.push(key);
+  }
+}
+
+function refreshCompletionKeysAfterMappingSave() {
+  validFirstKeys = {};
+  singleKeyCommands = [];
+
+  populateValidFirstKeys();
+  populateSingleKeyCommands();
+
+  sendRequestToAllTabs(getCompletionKeysRequest());
+}
+
+/*
+ * Generates a list of keys that can complete a valid command given the current key queue or the one passed
+ * in.
+ */
+function generateCompletionKeys(keysToCheck) {
+  var splitHash = splitKeyQueue(keysToCheck || keyQueue);
+  command = splitHash.command;
+  count = splitHash.count;
+
+  var completionKeys = singleKeyCommands.slice(0);
+
+  if (getActualKeyStrokeLength(command) == 1)
+  {
+    for (var key in Commands.keyToCommandRegistry)
+    {
+      var splitKey = splitKeyIntoFirstAndSecond(key);
+      if (splitKey.first == command)
+       completionKeys.push(splitKey.second);
+    }
+  }
+
+  return completionKeys;
+}
+
+function splitKeyQueue(queue) {
+  var match = /([1-9][0-9]*)?(.*)/.exec(queue);
+  var count = parseInt(match[1], 10);
+  var command = match[2];
+
+  return {count: count, command: command};
+}
+
+function handleKeyDown(request, port) {
+  var key = request.keyChar;
+  if (key == "<ESC>") {
+    console.log("clearing keyQueue");
+    keyQueue = "";
+  }
+  else {
+    console.log("checking keyQueue: [", keyQueue + key, "]");
+    keyQueue = checkKeyQueue(keyQueue + key, port.sender.tab.id, request.frameId);
+    console.log("new KeyQueue: " + keyQueue);
+  }
+}
+
+function checkKeyQueue(keysToCheck, tabId, frameId) {
+  var refreshedCompletionKeys = false;
+  var splitHash = splitKeyQueue(keysToCheck);
+  command = splitHash.command;
+  count = splitHash.count;
+
+  if (command.length === 0) { return keysToCheck; }
+  if (isNaN(count)) { count = 1; }
+
+  if (Commands.keyToCommandRegistry[command]) {
+    registryEntry = Commands.keyToCommandRegistry[command];
+
+    if (!registryEntry.isBackgroundCommand) {
+      var port = chrome.tabs.connect(tabId, { name: "executePageCommand" });
+      port.postMessage({ command: registryEntry.command,
+                         frameId: frameId,
+                         count: count,
+                         passCountToFunction: registryEntry.passCountToFunction,
+                         completionKeys: generateCompletionKeys("")
+                       });
+
+      refreshedCompletionKeys = true;
+    } else {
+      if(registryEntry.passCountToFunction){
+        this[registryEntry.command](count);
+      } else {
+        repeatFunction(this[registryEntry.command], count, 0, frameId);
+      }
+    }
+
+    newKeyQueue = "";
+  } else if (getActualKeyStrokeLength(command) > 1) {
+    var splitKey = splitKeyIntoFirstAndSecond(command);
+
+    // The second key might be a valid command by its self.
+    if (Commands.keyToCommandRegistry[splitKey.second])
+      newKeyQueue = checkKeyQueue(splitKey.second, tabId, frameId);
+    else
+      newKeyQueue = (validFirstKeys[splitKey.second] ? splitKey.second : "");
+  } else {
+    newKeyQueue = (validFirstKeys[command] ? count.toString() + command : "");
+  }
+
+  // If we haven't sent the completion keys piggybacked on executePageCommand,
+  // send them by themselves.
+  if (!refreshedCompletionKeys) {
+    chrome.tabs.sendRequest(tabId, getCompletionKeysRequest(), null);
+  }
+
+  return newKeyQueue;
+}
+
+/*
+ * Message all tabs. Args should be the arguments hash used by the Chrome sendRequest API.
+ */
+function sendRequestToAllTabs(args) {
+  chrome.windows.getAll({ populate: true }, function(windows) {
+    for (var i = 0; i < windows.length; i++)
+      for (var j = 0; j < windows[i].tabs.length; j++)
+        chrome.tabs.sendRequest(windows[i].tabs[j].id, args, null);
+  });
+}
+
+// Compares two version strings (e.g. "1.1" and "1.5") and returns
+// -1 if versionA is < versionB, 0 if they're equal, and 1 if versionA is > versionB.
+function compareVersions(versionA, versionB) {
+  versionA = versionA.split(".");
+  versionB = versionB.split(".");
+  for (var i = 0; i < Math.max(versionA.length, versionB.length); i++) {
+    var a = parseInt(versionA[i] || 0, 10);
+    var b = parseInt(versionB[i] || 0, 10);
+    if (a < b) return -1;
+    else if (a > b) return 1;
+  }
+  return 0;
+}
+
+/*
+ * Returns true if the current extension version is greater than the previously recorded version in
+ * localStorage, and false otherwise.
+ */
+function shouldShowUpgradeMessage() {
+  // Avoid showing the upgrade notification when previousVersion is undefined, which is the case for new
+  // installs.
+  if (!Settings.get("previousVersion"))
+    Settings.set("previousVersion", currentVersion);
+  return compareVersions(currentVersion, Settings.get("previousVersion")) == 1;
+}
+
+function openOptionsPageInNewTab() {
+  chrome.tabs.getSelected(null, function(tab) {
+    chrome.tabs.create({ url: chrome.extension.getURL("options.html"), index: tab.index + 1 });
+  });
+}
+
+function registerFrame(request, sender) {
+  if (!framesForTab[sender.tab.id])
+    framesForTab[sender.tab.id] = { frames: [] };
+
+  if (request.is_top) {
+    focusedFrame = request.frameId;
+    framesForTab[sender.tab.id].total = request.total;
+  }
+
+  framesForTab[sender.tab.id].frames.push({ id: request.frameId, area: request.area });
+
+  // We've seen all the frames. Time to focus the largest one.
+  // NOTE: Disabled because it's buggy with iframes.
+  // if (framesForTab[sender.tab.id].frames.length >= framesForTab[sender.tab.id].total)
+  //  focusLargestFrame(sender.tab.id);
+}
+
+function focusLargestFrame(tabId) {
+  var mainFrameId = null;
+  var mainFrameArea = 0;
+
+  for (var i = 0; i < framesForTab[tabId].frames.length; i++) {
+    var currentFrame = framesForTab[tabId].frames[i];
+
+    if (currentFrame.area > mainFrameArea) {
+      mainFrameId = currentFrame.id;
+      mainFrameArea = currentFrame.area;
+    }
+  }
+
+  chrome.tabs.sendRequest(tabId, { name: "focusFrame", frameId: mainFrameId, highlight: false });
+}
+
+function handleFrameFocused(request, sender) {
+  focusedFrame = request.frameId;
+}
+
+function nextFrame(count) {
+  chrome.tabs.getSelected(null, function(tab) {
+    var frames = framesForTab[tab.id].frames;
+    var curr_index = getCurrFrameIndex(frames);
+
+    // TODO: Skip the "top" frame (which doesn't actually have a <frame> tag),
+    // since it exists only to contain the other frames.
+    var new_index = (curr_index + count) % frames.length;
+
+    chrome.tabs.sendRequest(tab.id, { name: "focusFrame", frameId: frames[new_index].id, highlight: true });
+  });
+}
+
+function getCurrFrameIndex(frames) {
+  var index;
+  for (index=0; index < frames.length; index++) {
+    if (frames[index].id == focusedFrame)
+        break;
+  }
+  return index;
+}
+
+/*
+ * Convenience function for trimming leading and trailing whitespace.
+ */
+function trim(str) {
+  return str.replace(/^\s*/, "").replace(/\s*$/, "");
+}
+
+function init() {
+  Commands.clearKeyMappingsAndSetDefaults();
+
+  if (Settings.has("keyMappings"))
+    Commands.parseCustomKeyMappings(Settings.get("keyMappings"));
+
+  // In version 1.22, we changed the mapping for "d" and "u" to be scroll page down/up instead of close
+  // and restore tab. For existing users, we want to preserve existing behavior for them by adding some
+  // custom key mappings on their behalf.
+  if (Settings.get("previousVersion") == "1.21") {
+    var customKeyMappings = Settings.get("keyMappings") || "";
+    if ((Commands.keyToCommandRegistry["d"] || {}).command == "scrollPageDown")
+      customKeyMappings += "\nmap d removeTab";
+    if ((Commands.keyToCommandRegistry["u"] || {}).command == "scrollPageUp")
+      customKeyMappings += "\nmap u restoreTab";
+    if (customKeyMappings !== "") {
+      Settings.set("keyMappings", customKeyMappings);
+      Commands.parseCustomKeyMappings(customKeyMappings);
+    }
+  }
+
+  populateValidFirstKeys();
+  populateSingleKeyCommands();
+  if (shouldShowUpgradeMessage())
+    sendRequestToAllTabs({ name: "showUpgradeNotification", version: currentVersion });
+
+  // Ensure that openTabs is populated when Vimium is installed.
+  chrome.windows.getAll({ populate: true }, function(windows) {
+    for (var i in windows) {
+      for (var j in windows[i].tabs) {
+        var tab = windows[i].tabs[j];
+        updateOpenTabs(tab);
+        getScrollPosition(tab, function(tab, scrollX, scrollY) {
+          // Not using the tab defined in the for loop because
+          // it might have changed by the time this callback is activated.
+          updateScrollPosition(tab, scrollX, scrollY);
+        });
+      }
+    }
+  });
+}
+init();
+
+/**
+ * Convenience function for development use.
+ */
+function runTests() {
+  open(chrome.extension.getURL('test_harnesses/automated.html'));
+}