Notifications work in service workers. Resolves #14.

src/js/polyfills/notifications.polyfill.js

 // Copyright 2015 Google Inc. All Rights Reserved.
 //
 // 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.
 
 /**
  * Polyfill for Chrome Apps' notifications API.
  */
 
 'use strict';
 
 // Set up a namespace for the polyfill if necessary.
 if (!chrome.notifications)
   chrome.notifications = {};
 
+chrome.caterpillar.notifications = {};
+
 (function() {
 
 // Private object to map notification IDs to their notification.
 var notifications = {};
 
 // List of event handlers for the click event.
 var onClickHandlers = [];
 
 // Arbitrary maximum for randomly generated notification IDs.
 var MAX_NOTIFICATION_ID = 1000000;
@@ skipping 83 matching lines @@
     chrome.notifications.clear(opt_notificationId);
   }
 
   // Generate a notification ID if necessary.
   if (opt_notificationId === undefined) {
     // Math.random is notoriously bad at random numbers, but we don't care very
     // much about collisions.
     opt_notificationId = Math.round(Math.random() * MAX_NOTIFICATION_ID) + '';
   }
 
-  // TODO(alger): This uses a deprecated callback since the callback is
-  // supported on both Chrome and Firefox but the not-deprecated Promise return
-  // is only currently supported on Chrome.
-  Notification.requestPermission(function() {
-    var title = options.title;
-    var body = options.message;
-    if (options.contextMessage)
-      body += '\n\n' + options.contextMessage;
-    if (options.type === chrome.notifications.TemplateType.PROGRESS) {
-      body += '\n\nProgress: ' + options.progress + '%';
-    } else if (options.type !== chrome.notifications.TemplateType.BASIC) {
-      console.warn('Notification type', options.type, 'not supported.',
-                   'Falling back to basic.');
-    }
-    var notification_options = {
-      'body': body,
-      'tag': opt_notificationId,
-      'icon': options.iconUrl,
-      'data': options,
-    };
+  var title = options.title;
+  var body = options.message;
+  if (options.contextMessage)
+    body += '\n\n' + options.contextMessage;
+  if (options.type === chrome.notifications.TemplateType.PROGRESS) {
+    body += '\n\nProgress: ' + options.progress + '%';
+  } else if (options.type !== chrome.notifications.TemplateType.BASIC) {
+    console.warn('Notification type', options.type, 'not supported.',
+                 'Falling back to basic.');
+  }
+  var notificationOptions = {
+    'body': body,
+    'tag': opt_notificationId,
+    'icon': options.iconUrl,
+    'data': options,
+  };
 
-    var notification = new Notification(title, notification_options);
+  // Service workers can't request permission, so request permission if we can
+  // or just assume we have permission if we can't.
+  var notificationPromise;
+  if (!Notification.requestPermission) {
+    notificationPromise = createNotification(title, notificationOptions);
+  } else {
+    notificationPromise = new Promise(function(resolve, reject) {
+      // TODO(alger): This uses a deprecated callback since the callback is
+      // supported on both Chrome and Firefox but the not-deprecated Promise
+      // return is only currently supported on Chrome.
+      Notification.requestPermission(function() {
+        createNotification(title, notificationOptions)
+            .then(resolve)
+            .catch(reject);
+      });
+    });
+  }
 
+  notificationPromise.then(function(notification) {
     for (var i = 0; i < onClickHandlers.length; i++) {
       notification.addEventListener('click', onClickHandlers[i]);
     }
 
     notifications[opt_notificationId] = notification;
 
     if (opt_callback)
       opt_callback(opt_notificationId);
-  });
+  })
 };
 
 /**
+ * Gets the service worker registration.
+ *
+ * Exported so we can override for testing.
+ *
+ * @returns {Promise} Promise resolving to the service worker registration.
+ *     Rejects if no registration is available.
+ */
+chrome.caterpillar.notifications.getRegistration = function() {
+  if (self.registration)
+    return Promise.resolve(self.registration);
+
+  if (navigator.serviceWorker &&
+      navigator.serviceWorker.getRegistration) {
+    return navigator.serviceWorker.getRegistration().then(function(reg) {
+      if (!reg)
+        return Promise.reject();
+      return Promise.resolve(reg);
+    });
+  }
+
+  return Promise.reject();
+}
+
+
+/**
+ * Creates a notification.
+ *
+ * Internal helper function.
+ *
+ * @param {string} title
+ * @param {object} notificationOptions Object with properties body, tag, icon,
+ *     and data. All properties are expected to be defined.
+ * @returns {Promise} Promise resolving to a Notification.
+ */
+function createNotification(title, notificationOptions) {
+  return chrome.caterpillar.notifications.getRegistration()
+      .then(function(registration) {
+        registration.showNotification(title, notificationOptions);
+        return registration.getNotifications({ tag: notificationOptions.tag });
+      }).catch(function() {
+        return Promise.resolve([new Notification(title, notificationOptions)]);
+      }).then(function(notifications) {
+        // Notifications are in creation order, so get the last notification.
+        return Promise.resolve(notifications[notifications.length - 1]);
+      });
+}
+
+/**
  * Clears the specified notification.
  *
  * @param {string} notificationId
  * @param {function} opt_callback Takes a boolean which is true iff the
  *     notification was cleared successfully.
  */
 chrome.notifications.clear = function(notificationId, opt_callback) {
   if (!(notificationId in notifications) && opt_callback) {
     opt_callback(false);
     return;
@@ skipping 50 matching lines @@
     callback(e.target.tag);
   };
 
   for (var i in notifications) {
     notifications[i].addEventListener('click', callbackWrapper);
   }
 
   onClickHandlers.push(callbackWrapper);
 };
 
-}).call(this);
+}).call(this);