### Preflight Checklist
<!-- Please ensure you've completed the following steps by replacing [ ] with [x]-->

* [x] I have read the [Contributing Guidelines](https://github.com/electron/electron/blob/master/CONTRIBUTING.md) for this project.
* [x] I agree to follow the [Code of Conduct](https://github.com/electron/electron/blob/master/CODE_OF_CONDUCT.md) that this project adheres to.
* [x] I have searched the issue tracker for an issue that matches the one I want to file, without success.

### Issue Details

* **Electron Version:**
  * 12.0.0
* **Operating System:**
  * macOS 10.14
* **Last Known Working Electron version:**
  * N/A

### Expected Behavior

`shell.trashItem` should just work.

### Actual Behavior

It does its job, and then immediately crashes the process.

### To Reproduce

I don't have a fiddle, but this line makes the process crash for me:

```js
return shell.trashItem ( path ).then ( () => true, () => false );
```

While this works:

```js
return Promise.resolve ( shell.moveItemToTrash ( path, false ) );
```

In addition I'm getting as output from the main process:

```
{ reason: 'crashed', exitCode: 11 }
{ reason: 'crashed', exitCode: 5 }
{ reason: 'crashed', exitCode: 5 }
{ reason: 'crashed', exitCode: 5 }
{ reason: 'crashed', exitCode: 5 }
{ reason: 'crashed', exitCode: 5 }
{ reason: 'crashed', exitCode: 5 }
{ reason: 'crashed', exitCode: 5 }
and so on...
```

Basically it crashes the window with exit code 11, then my app opens gain the window after it crashed, and it crashes again immediately with exit code 5.
shell/common/platform_util.cc
#include "shell/common/platform_util.h"
#include <utility>
#include "base/bind.h"
#include "base/task/thread_pool.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h"
#include "shell/common/platform_util_internal.h"
namespace platform_util {
void TrashItemOnBlockingThread(
    const base::FilePath& full_path,
    base::OnceCallback<void(bool, const std::string&)> callback) {
  std::string error;
  bool success = internal::PlatformTrashItem(full_path, &error);
  content::GetUIThreadTaskRunner({})->PostTask(
      FROM_HERE, base::BindOnce(std::move(callback), success, error));
}
void TrashItem(const base::FilePath& full_path,
               base::OnceCallback<void(bool, const std::string&)> callback) {
  
  base::ThreadPool::PostTask(FROM_HERE,
                             {base::MayBlock(), base::WithBaseSyncPrimitives(),
                              base::TaskPriority::USER_BLOCKING,
                              base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
                             base::BindOnce(&TrashItemOnBlockingThread,
                                            full_path, std::move(callback)));
}
}