Checking node object before checking its property.

chrome/browser/resources/bookmark_manager/js/bmm.js

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 'use strict';
 
 cr.define('bmm', function() {
   /**
    * Whether a node contains another node.
    * TODO(yosin): Once JavaScript style guide is updated and linter follows
@@ skipping 23 matching lines @@
 
   var loadingPromises = {};
 
   /**
    * Promise version of chrome.bookmarkManagerPrivate.getSubtree.
    * @param {string} id .
    * @param {boolean} foldersOnly .
    * @return {!Promise<!Array<!BookmarkTreeNode>>} .
    */
   function getSubtreePromise(id, foldersOnly) {
-    return new Promise(function(resolve) {
-      chrome.bookmarkManagerPrivate.getSubtree(id, foldersOnly, resolve);
+    return new Promise(function(resolve, reject) {
+      chrome.bookmarkManagerPrivate.getSubtree(id, foldersOnly, function(node) {
+        if (chrome.runtime.lastError) {
+          reject(new Error(chrome.runtime.lastError.message));
+          return;
+        }
+        resolve(node);
+      });
     });
   }
 
   /**
    * Loads a subtree of the bookmark tree and returns a {@code Promise} that
    * will be fulfilled when done. This reuses multiple loads so that we do not
    * load the same subtree more than once at the same time.
    * @return {!Promise<!BookmarkTreeNode>} The future promise for the load.
    */
   function loadSubtree(id) {
     if (!loadingPromises[id]) {
       loadingPromises[id] = getSubtreePromise(id, false).then(function(nodes) {
-        delete loadingPromises[id];
+        loadingPromises[id].then(function() {

[Bernhard Bauer, 2015/04/30 15:08:07]

You can pull this out into a single callback on loadingPromises[id] after you've
assigned a value to it. The reason why this works is that adding an error
handler will cause loadingPromises[id] to be a resolved promise, even if the
promise returned from getSubtreePromise is rejected. The error handler
effectively turns the rejected promise into a resolved one (with an undefined
value). Then the callback you add with .then is guaranteed to be called.

[Deepak, 2015/04/30 16:11:19]

Done.

+          delete loadingPromises[id];
+        });
         return nodes && nodes[0];
+      }, function(error) {
+        loadingPromises[id].then(function() {
+          delete loadingPromises[id];
+        });
+        console.error(error.message);
+        return;
       });
     }
     return loadingPromises[id];
   }
 
   /**
    * Loads the entire bookmark tree and returns a {@code Promise} that will
    * be fulfilled when done. This reuses multiple loads so that we do not load
    * the same tree more than once at the same time.
    * @return {!Promise<!BookmarkTreeNode>} The future promise for the load.
@@ skipping 172 matching lines @@
   };
 
   return {
     contains: contains,
     isFolder: isFolder,
     loadSubtree: loadSubtree,
     loadTree: loadTree,
     addBookmarkModelListeners: addBookmarkModelListeners
   };
 });