create single path for handling errors from the protocol

lighthouse-core/gather/connections/connection.js

@@ -95,34 +95,41 @@ class Connection {
       const callback = this._callbacks.get(object.id);
       this._callbacks.delete(object.id);
 
-      if (object.error) {
-        return this.handleRawError(object.error, callback);
-      }
+      // handleRawError returns or throws synchronously; wrap to put into promise chain.
+      return callback.resolve(Promise.resolve().then(_ => {
+        if (object.error) {
+          return this.handleRawError(object.error, callback.method);
+        }
 
-      log.formatProtocol('method <= browser OK',
+        log.formatProtocol('method <= browser OK',
           {method: callback.method, params: object.result}, 'verbose');
-      callback.resolve(object.result);
-      return;
+        return object.result;
+      }));
     }
     log.formatProtocol('<= event',
         {method: object.method, params: object.params}, 'verbose');
     this.emitNotification(object.method, object.params);
   }
 
   /**
+   * Handles error responses from the protocol, absorbing errors we don't care
+   * about and throwing on the rest.
+   *
+   * Currently the only error ignored is from defensive calls of `DOM.disable`
+   * when already disabled.
    * @param {{message: string}} error
-   * @param {{resolve: function(*), reject: function(*), method: string}} callback
+   * @param {string} method Protocol method that received the error response.
+   * @throws {Error}
    * @protected
    */
-  handleRawError(error, callback) {
+  handleRawError(error, method) {
     // We proactively disable the DOM domain. Ignore any errors.
     if (error.message && error.message.includes('DOM agent hasn\'t been enabled')) {
-      callback.resolve();
       return;
     }
 
-    log.formatProtocol('method <= browser ERR', {method: callback.method}, 'error');
-    callback.reject(new Error(`Protocol error (${callback.method}): ${error.message}`));
+    log.formatProtocol('method <= browser ERR', {method}, 'error');
+    throw new Error(`Protocol error (${method}): ${error.message}`);
   }
 
   /**

lighthouse-core/gather/connections/extension.js

@@ -112,19 +112,21 @@ class ExtensionConnection extends Connection {
 
       chrome.debugger.sendCommand({tabId: this._tabId}, command, params, result => {
         if (chrome.runtime.lastError) {
+          // The error from the extension has a `message` property that is the
+          // stringified version of the actual protocol error object.
           const message = chrome.runtime.lastError.message;
           let error;
           try {
             error = JSON.parse(message);
           } catch (e) {}
           error = error || {message: 'Unknown debugger protocol error.'};
 
-          const callback = {
-            resolve,
-            reject,
-            method: command
-          };
-          return this.handleRawError(error, callback);
+          // handleRawError returns or throws synchronously, so try/catch awkwardly.
+          try {
+            return resolve(this.handleRawError(error, command));
+          } catch (err) {
+            return reject(err);
+          }
         }
 
         log.formatProtocol('method <= browser OK', {method: command, params: result}, 'verbose');

lighthouse-core/gather/driver.js

@@ -155,7 +155,10 @@ class Driver {
         } else {
           resolve(result.result.value);
         }
-      }).catch(reject);
+      }).catch(err => {
+        clearTimeout(asyncTimeout);
+        reject(err);
+      });
     });
   }