### 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:** v6.0.0-beta.12 x86
* **Operating System:** win7 x64 sp1
* **Last Known Working Electron version:** v5.0.6

The webFrame execute APIs have always been synchronous (which makes perfect sense, since this is in-process js evaluation), and under the hood they still are, despite now (#17312) returning promises. The callback used to deliver the result synchronously before the method returned.

There is nothing gained and only loss of flexibility when you wrap an actually sync api in a promise. It's trivial for the user to go from sync to promise (`Promise.(resolve|reject)`) but going from promise to sync is impossible.

So this change (for webFrame) is:

1. not an improvement
2. a breaking change for 6.0 (I have code that depends on the synchronous nature of these, which now can't even be fixed without having to become async)

### Expected Behavior
existing execute methods should remain sync, they could also be improved by returning the result, in addition to invoking the sync callback (which could be deprecated for later removal)

### Actual Behavior
no more sync callback, async promise instead

### To Reproduce
1. launch the following app in 5.0.6
    **`index.js`**
    ```js
    'use strict';
    
    const {app, BrowserWindow} = require('electron'),
          path = require('path');
    
    let win;
    
    app.on('ready', () => {
    
      win = new BrowserWindow({
        width: 1440,
        height: 900,
        useContentSize: true,
        webPreferences: {
          nodeIntegration: false,
          contextIsolation: true,
          preload: path.join(__dirname, 'preload.js'),
        },
      });
    
      win.loadURL('about:blank');
      win.webContents.openDevTools({mode: 'right'});
    
    });
    ```
    **`preload.js`**
    ```js
    'use strict';
    
    const {webFrame} = require('electron');
    
    window.evalMainWorldSync = function(code) {
      let result;
      webFrame.executeJavaScript(code, false, res => result = res);
      return result;
    };
    ```
2. In the devtools console for the main world, enter: `foo = 1`
3. Switch console context to the Electron Isolated Context
4. eval `evalMainWorldSync('foo')`
5. it prints `1`
6. repeat 1-5 with electron 6.0.0-beta.12
7. it prints `undefined`

shell/renderer/api/electron_api_web_frame.cc
blink::WebCacheResourceTypeStats stats;
  blink::WebCache::GetResourceTypeStats(&stats);
  return stats;
}
void ClearCache(v8::Isolate* isolate) {
  isolate->IdleNotificationDeadline(0.5);
  blink::WebCache::Clear();
  base::MemoryPressureListener::NotifyMemoryPressure(
      base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL);
}
v8::Local<v8::Value> FindFrameByRoutingId(v8::Isolate* isolate,
                                          v8::Local<v8::Value> window,
                                          int routing_id) {
  content::RenderFrame* render_frame =
      content::RenderFrame::FromRoutingID(routing_id);
  if (render_frame)
    return render_frame->GetWebFrame()->MainWorldScriptContext()->Global();
  else
    return v8::Null(isolate);
}
v8::Local<v8::Value> GetOpener(v8::Isolate* isolate,