Issue 2426 - Open block.html as a popup window

chrome/ext/background.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2016 Eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 (function()
 {
   /* Pages */
 
   var Page = ext.Page = function(tab)
   {
-    this._id = tab.id;
+    this.id = tab.id;
     this._url = tab.url && new URL(tab.url);
 
     this.browserAction = new BrowserAction(tab.id);
     this.contextMenus = new ContextMenus(this);
   };
   Page.prototype = {
     get url()
     {
       // usually our Page objects are created from Chrome's Tab objects, which
       // provide the url. So we can return the url given in the constructor.
       if (this._url)
         return this._url;
 
       // but sometimes we only have the tab id when we create a Page object.
       // In that case we get the url from top frame of the tab, recorded by
       // the onBeforeRequest handler.
-      var frames = framesOfTabs[this._id];
+      var frames = framesOfTabs[this.id];
       if (frames)
       {
         var frame = frames[0];
         if (frame)
           return frame.url;
       }
     },
     sendMessage: function(message, responseCallback)
     {
-      chrome.tabs.sendMessage(this._id, message, responseCallback);
-    }
-  };
-
-  ext._getPage = function(id)
+      chrome.tabs.sendMessage(this.id, message, responseCallback);
+    }
+  };
+
+  ext.getPage = function(id)
   {
     return new Page({id: parseInt(id, 10)});
   };
+
+  function afterTabLoaded(callback)
+  {
+     return function(openedTab)
+     {
+       var onUpdated = function(tabId, changeInfo, tab)
+       {
+         if (tabId == openedTab.id && changeInfo.status == "complete")
+         {
+           chrome.tabs.onUpdated.removeListener(onUpdated);
+           callback(new Page(openedTab));
+         }
+       };
+       chrome.tabs.onUpdated.addListener(onUpdated);
+     };
+  }
 
   ext.pages = {
     open: function(url, callback)
     {
-      if (callback)
-      {
-        chrome.tabs.create({url: url}, function(openedTab)
-        {
-          var onUpdated = function(tabId, changeInfo, tab)
-          {
-            if (tabId == openedTab.id && changeInfo.status == "complete")
-            {
-              chrome.tabs.onUpdated.removeListener(onUpdated);
-              callback(new Page(tab));
-            }
-          };
-          chrome.tabs.onUpdated.addListener(onUpdated);
-        });
-      }
-      else
-        chrome.tabs.create({url: url});
+      chrome.tabs.create({url: url}, callback && afterTabLoaded(callback));
     },
     query: function(info, callback)
     {
       var rawInfo = {};
       for (var property in info)
       {
         switch (property)
         {
           case "active":
           case "lastFocusedWindow":
@@ skipping 42 matching lines @@
               url: details.url
             })
           );
         }
       });
     }
   });
 
   function forgetTab(tabId)
   {
     ext.pages.onRemoved._dispatch(tabId);

[Sebastian Noack, 2016/02/10 12:26:56]

I guess we should dispatch the event with a Page object for consistence.

[kzar, 2016/02/10 14:20:16]

I wasn't sure how well it would work using a Page object for a tab that had been
removed. (I nearly did return a Page object here initially.)

 
     ext._removeFromAllPageMaps(tabId);
     delete framesOfTabs[tabId];
   }
 
   chrome.tabs.onReplaced.addListener(function(addedTabId, removedTabId)
   {
     forgetTab(removedTabId);
   });
 
   chrome.tabs.onRemoved.addListener(forgetTab);
 
-  chrome.tabs.onActivated.addListener(details =>
+  chrome.tabs.onActivated.addListener(function(details)
   {
     ext.pages.onActivated._dispatch(new Page({id: details.tabId}));
   });
 
 
   /* Browser actions */
 
   var BrowserAction = function(tabId)
   {
     this._tabId = tabId;
@@ skipping 103 matching lines @@
 
     chrome.tabs.query({active: true, lastFocusedWindow: true}, function(tabs)
     {
       chrome.contextMenus.removeAll(function()
       {
         contextMenuUpdating = false;
 
         if (tabs.length == 0)
           return;
 
-        var items = contextMenuItems.get({_id: tabs[0].id});
+        var items = contextMenuItems.get({id: tabs[0].id});
 
         if (!items)
           return;
 
         items.forEach(function(item)
         {
           chrome.contextMenus.create({
             title: item.title,
             contexts: item.contexts,
             onclick: function(info, tab)
@@ skipping 295 matching lines @@
         else
         {
           ext.pages.open(optionsUrl, callback);
         }
       });
     });
   };
 
   /* Windows */
   ext.windows = {
-    create: (createData, callback) =>

[Sebastian Noack, 2016/02/10 12:26:56]

Nit: I'm not sure if using an arrow function is appropriate here, if it's just
for consistence with the rest of this file.

[kzar, 2016/02/10 14:20:16]

Done.

-    {
-      if (callback)

[Sebastian Noack, 2016/02/10 12:26:57]

The logic here is duplicated from ext.tabs.open. We should probably move it into
a common helper function.

[kzar, 2016/02/10 14:20:16]

Done.

-        chrome.windows.create(createData, createdWindow =>
-        {
-          let createdTab = createdWindow.tabs[0];
-          var onUpdated = (tabId, changeInfo, tab) =>
-          {
-            if (tabId == createdTab.id && changeInfo.status == "complete")
-            {
-              chrome.tabs.onUpdated.removeListener(onUpdated);
-              callback(new Page(createdTab));
-            }
-          };
-          chrome.tabs.onUpdated.addListener(onUpdated);
-        });
-      else
-        chrome.windows.create(createData);
+    create: function(createData, callback)
+    {
+      chrome.windows.create(createData, function(createdWindow)
+      {
+        afterTabLoaded(callback)(createdWindow.tabs[0]);
+      });
     }
   };
 })();