- Electron version:  0.37.8
- Operating system: Windows 7 Ultimate SP1

I am testing failure scenarios for file downloading using downloadURL. I've registered an event listener to the 'done' even using the download item. When I interrupt the network connection during a download, I do not see any 'done' event fire with the state of 'interrupted.

I was hoping to catch and do something useful in case a download is interrupted, but it appears that I'm not getting the notification event I expect.

Can anyone help? Is this the right approach? Does the event handling require external network connection to function? What does trigger the 'interrupted' state?

``` javascript
... 
   item.on('done', (e, s) => this._handleDone(e, s))
  }

  _handleDone(event, state) {
    logger.info("_handleDone: state = " + state)
    switch(state) {
      case 'completed': {
        logger.info("DOWNLOAD COMPLETED")
        this.currentJob.file.Status = Downloader.STATUS_COMPLETED
        this.emit('job-changed', this._jobStatus(this.currentJob.job))
        break;
      }
      case 'cancelled': {
        logger.info("DOWNLOAD CANCELLED")
        this.currentJob.file.Status = Downloader.STATUS_CANCELLED
        this.emit('job-changed', this._jobStatus(this.currentJob.job))
        break;
      }
      case 'interrupted': {
        logger.info("DOWNLOAD FAILED")
        this.currentJob.file.Status = Downloader.STATUS_FAILED
        this.emit('job-changed', this._jobStatus(this.currentJob.job))
        break;
      }
      default: {
        logger.info("DOWNLOAD DONE UNHANDLED STATE", state)
      }
    }
```

atom/browser/api/atom_api_download_item.cc
v8::Isolate* isolate, content::DownloadItem* item) {
  auto existing = TrackableObject::FromWrappedClass(isolate, item);
  if (existing)
    return mate::CreateHandle(isolate, static_cast<DownloadItem*>(existing));
  auto handle = mate::CreateHandle(isolate, new DownloadItem(isolate, item));
  g_wrap_download_item.Run(handle.ToV8());
  
  g_download_item_objects[handle->weak_map_id()] = make_linked_ptr(
      new v8::Global<v8::Value>(isolate, handle.ToV8()));
  return handle;
}
void SetWrapDownloadItem(const WrapDownloadItemCallback& callback) {
  g_wrap_download_item = callback;
}
}  
}  
namespace {
void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
                v8::Local<v8::Context> context, void* priv) {
  v8::Isolate* isolate = context->GetIsolate();
  mate::Dictionary dict(isolate, exports);
  dict.SetMethod("_setWrapDownloadItem", &atom::api::SetWrapDownloadItem);
}
}  
NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_download_item, Initialize);