Expose global commands at chrome://extensions/shortcuts

background_scripts/bg_utils.js

@@ -10,6 +10,7 @@ class TabRecency {
     this.cache = {};
     this.lastVisited = null;
     this.lastVisitedTime = null;
+    this.jumpList = null;
 
     chrome.tabs.onActivated.addListener(activeInfo => this.register(activeInfo.tabId));
     chrome.tabs.onRemoved.addListener(tabId => this.deregister(tabId));
@@ -31,6 +32,31 @@ class TabRecency {
     }
   }
 
+  getJumpBackTabId({count}) {
+    let backTabId = -1;
+    if (!this.jumpList) {
+      // getTabsByRecency might not include the current tab, eg if it was just
+      // opened. Tabs aren't added until they have been seen for some time and
+      // then an event is fired (like navigating back to the window). Add the
+      // current tab if it hasn't been added.
+      const tabs = this.getTabsByRecency().reverse();
+      if (tabs.length > 0 && tabs[tabs.length - 1] !== this.current) {
+        tabs.push(this.current);
+      }
+      this.jumpList = new TabJumpList(tabs);
+    }
+    backTabId = this.jumpList.getJumpBackTabId({count});
+    return backTabId === -1 ? this.current : backTabId;
+  }
+
+  getJumpForwardTabId({count}) {
+    let forwardTabId = -1;
+    if (this.jumpList) {
+      forwardTabId = this.jumpList.getJumpForwardTabId({count});
+    }
+    return forwardTabId === -1 ? this.current : forwardTabId;
+  }
+
   register(tabId) {
     const currentTime = new Date();
     // Register tabId if it has been visited for at least @timeDelta ms.  Tabs which are visited only for a
@@ -39,6 +65,10 @@ class TabRecency {
       this.cache[this.lastVisited] = ++this.timestamp;
     }
 
+    if (this.jumpList && !this.jumpList.isCoherent(tabId)) {
+      this.jumpList = null;
+    }
+
     this.current = (this.lastVisited = tabId);
     this.lastVisitedTime = currentTime;
   }
@@ -49,6 +79,11 @@ class TabRecency {
       this.lastVisited = (this.lastVisitedTime = null);
     }
     delete this.cache[tabId];
+
+    if (this.jumpList) {
+      const jumpListInvalidated = this.jumpList.deregister(tabId);
+      if (jumpListInvalidated) this.jumpList = null;
+    }
   }
 
   // Recently-visited tabs get a higher score (except the current tab, which gets a low score).
@@ -69,6 +104,84 @@ class TabRecency {
   }
 }
 
+// TabJumpList maintains a list of visited tabs. When no jumps have occurred,
+// the list is all open tabs--the current (i.e. most recently visited) tab is
+// the last element. The tab visited the longest in the past is the 0th tab.
+// Jumping backwards moves through the open tabs. The index is maintained,
+// allowing jumping forward to move again back to newer tabs. A manual
+// navigation through a mechanism other than a jump resets the jump list.
+class TabJumpList {
+
+  constructor(tabs) {
+    this.tabs = tabs;
+    this.activeIdx = tabs.length - 1;
+    // Tabs can be deleted after a TabJumpList has flattened the tabs into an
+    // array. Rather than O(N) look through the tabs, we'll just maintain
+    // deleted IDs and skip them.
+    this.deletedTabs = new Set();
+  }
+
+  isCoherent(currentTabId) {
+    return this.tabs[this.activeIdx] === currentTabId;
+  }
+
+  // Returns true if deregistering this tab invalidates the jump list.
+  deregister(tabId) {
+    if (this.tabs[this.activeIdx] == tabId) return true;
+
+    this.deletedTabs.add(tabId);
+    return false;
+  }
+
+  getJumpBackTabId({count = 1}) {
+    let candidateIdx = -1;
+    let need = count;
+    for (let i = this.activeIdx - 1; i >= 0; i--) {
+      let candidateId = this.tabs[i];
+      if (this.deletedTabs.has(candidateId)) {
+        continue;
+      }
+      candidateIdx = i;
+      need--;
+      if (need <= 0) {
+        break;
+      }
+    }
+
+    if (candidateIdx === -1) {
+      // We're at the oldest tab.
+      return -1;
+    }
+
+    this.activeIdx = candidateIdx;
+    return this.tabs[this.activeIdx];
+  }
+
+  getJumpForwardTabId({count = 1}) {
+    let candidateIdx = -1;
+    let need = count;
+    for (let i = this.activeIdx + 1; i < this.tabs.length; i++) {
+      let candidateId = this.tabs[i];
+      if (this.deletedTabs.has(candidateId)) {
+        continue;
+      }
+      candidateIdx = i;
+      need--;
+      if (need <= 0) {
+        break;
+      }
+    }
+
+    if (candidateIdx === -1) {
+      // We're at the newest tab.
+      return -1;
+    }
+
+    this.activeIdx = candidateIdx;
+    return this.tabs[this.activeIdx];
+  }
+}
+
 var BgUtils = {
   tabRecency: new TabRecency(),
 

background_scripts/commands.js

@@ -235,6 +235,8 @@ const Commands = {
       "previousTab",
       "nextTab",
       "visitPreviousTab",
+      "jumpBackTabList",
+      "jumpForwardTabList",
       "firstTab",
       "lastTab",
       "duplicateTab",
@@ -340,6 +342,8 @@ const defaultKeyMappings = {
   "gt": "nextTab",
   "gT": "previousTab",
   "^": "visitPreviousTab",
+  "<c-o>": "jumpBackTabList",
+  "<c-i>": "jumpForwardTabList",
   "<<": "moveTabLeft",
   ">>": "moveTabRight",
   "g0": "firstTab",
@@ -423,6 +427,8 @@ const commandDescriptions = {
   nextTab: ["Go one tab right", { background: true }],
   previousTab: ["Go one tab left", { background: true }],
   visitPreviousTab: ["Go to previously-visited tab", { background: true }],
+  jumpBackTabList: ["Jump back in visited tab list", { background: true }],
+  jumpForwardTabList: ["Jump forward in visited tab list", { background: true }],
   firstTab: ["Go to the first tab", { background: true }],
   lastTab: ["Go to the last tab", { background: true }],
 

background_scripts/main.js

@@ -332,6 +332,16 @@ const BackgroundCommands = {
       return selectSpecificTab({id: tabIds[(count-1) % tabIds.length]});
   },
 
+  jumpBackTabList({count}) {
+    const tabId = BgUtils.tabRecency.getJumpBackTabId({count});
+    return selectSpecificTab({id: tabId});
+  },
+
+  jumpForwardTabList({count}) {
+    const tabId = BgUtils.tabRecency.getJumpForwardTabId({count});
+    return selectSpecificTab({id: tabId});
+  },
+
   reload({count, tabId, registryEntry, tab: {windowId}}){
     const bypassCache = registryEntry.options.hard != null ? registryEntry.options.hard : false;
     return chrome.tabs.query({windowId}, function(tabs) {
@@ -350,6 +360,58 @@ const BackgroundCommands = {
   }
 };
 
+chrome.commands.onCommand.addListener(function(command) {
+
+  const sendCommandToCurrentTab = function(requestName) {
+    chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => {
+      if (tabs[0]) {
+        const tabId = tabs[0].id;
+        chrome.tabs.sendMessage(tabId, {
+          name: 'runInTopFrame',
+          registryEntry: {
+            command: requestName,
+            optionList: [],
+          },
+        });
+      }
+    });
+  };
+
+  switch (command) {
+    case "jump-back-tab":
+      BackgroundCommands.jumpBackTabList({count: 1});
+      break;
+    case "jump-forward-tab":
+      BackgroundCommands.jumpForwardTabList({count: 1});
+      break;
+    case "open-vomnibox":
+      sendCommandToCurrentTab("Vomnibar.activate");
+      break;
+    case "open-vomnibox-new-tab":
+      sendCommandToCurrentTab("Vomnibar.activateInNewTab");
+      break;
+    case "open-vomnibox-tab":
+      sendCommandToCurrentTab("Vomnibar.activateTabSelection");
+      break;
+    case "open-vomnibox-bookmark":
+      sendCommandToCurrentTab("Vomnibar.activateBookmarks");
+      break;
+    case "open-vomnibox-bookmark-new-tab":
+      sendCommandToCurrentTab("Vomnibar.activateBookmarksInNewTab");
+      break;
+    case "switch-to-previous-tab":
+      chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => {
+        if (tabs[0]) {
+          const tabId = tabs[0].id;
+          BackgroundCommands.visitPreviousTab({count: 1, tab: { id: tabId} });
+        }
+      });
+      break;
+    default:
+      console.error('unrecognized command: ', command);
+  }
+});
+
 var forCountTabs = (count, currentTab, callback) => chrome.tabs.query({currentWindow: true}, function(tabs) {
   const activeTabIndex = currentTab.index;
   const startTabIndex = Math.max(0, Math.min(activeTabIndex, tabs.length - count));
@@ -613,7 +675,9 @@ var portHandlers = {
 };
 
 var sendRequestHandlers = {
-  runBackgroundCommand(request) { return BackgroundCommands[request.registryEntry.command](request); },
+  runBackgroundCommand(request) {
+    return BackgroundCommands[request.registryEntry.command](request);
+  },
   // getCurrentTabUrl is used by the content scripts to get their full URL, because window.location cannot help
   // with Chrome-specific URLs like "view-source:http:..".
   getCurrentTabUrl({tab}) { return tab.url; },

manifest.json

@@ -7,6 +7,32 @@
               "48": "icons/icon48.png",
              "128": "icons/icon128.png" },
   "minimum_chrome_version": "69.0",
+  "commands": {
+    "jump-back-tab": {
+      "description": "Jump back in the tab stack."
+    },
+    "jump-forward-tab": {
+      "description": "Jump forward in the tab stack."
+    },
+    "open-vomnibox": {
+      "description": "Open the vomnibox for the same tab."
+    },
+    "open-vomnibox-new-tab": {
+      "description": "Open the vomnibox for a new tab."
+    },
+    "open-vomnibox-tab": {
+      "description": "Open the vomnibox with tabs."
+    },
+    "open-vomnibox-bookmark": {
+      "description": "Open the vomnibox with history."
+    },
+    "open-vomnibox-bookmark-new-tab": {
+      "description": "Open the vomnibox with history."
+    },
+    "switch-to-previous-tab": {
+      "description": "Switch to the previously used tab."
+    }
+  },
   "background": {
     "scripts": [
       "lib/utils.js",