Thanks for Electron! Amazing project :)

* Electron version: 1.6.2
* Operating system: macOS Sierra (10.12.3)

It happens when `BrowserWindow` is opened with `sandbox: true`. It might be on purpose, but I couldn't find any Electron/Chromium documentation that explains why. So I'm suspecting it's a bug. I can submit a PR with a failing test to this repo if you agree that it's a bug.

### Expected behavior

`webContents`' `will-navigate` event should fire when user reloads page fx.

### Actual behavior

It does not fire.

### How to reproduce

package.json:

```json
{
  "name": "electron-sandbox-will-navigate-bug",
  "version": "0.0.0",
  "main": "main.js",
  "dependencies": {
    "electron": "^1.6.2"
  }
}
```

main.js:

```js
const {app, BrowserWindow} = require('electron')
const path = require('path')

app.on('ready', function() {
  const win = new BrowserWindow({
    webPreferences: {
      sandbox: true
    }
  })

  const {webContents} = win
  webContents.on('will-navigate', () => {
    console.log('will-navigate')
  })
  webContents.on('did-navigate', () => {
    console.log('did-navigate')
  })

  win.loadURL('file://' + path.join(__dirname, 'index.html'))
})
```

index.html:

```html
<!doctype html>
<html>
  <body>
    <button onclick="window.location.reload()">Reload</button>
  </body>
</html>
```

Perform these steps:

- Run `npm install`
- Run `./node_modules/.bin/electron .`
- Click the Reload button in the browser window
- Observe the Terminal output

Expected output:

```
did-navigate
will-navigate
did-navigate
```

Actual output:

```
did-navigate
did-navigate
```

(will-navigate is not fired).

If you outcomment the line `sandbox:true` in `main.js`, then it works as expected.
shell/renderer/electron_sandboxed_renderer_client.cc
v8::Local<v8::String> preloadSrc) {
  return RendererClientBase::RunScript(isolate->GetCurrentContext(),
                                       preloadSrc);
}
void InvokeHiddenCallback(v8::Handle<v8::Context> context,
                          const std::string& hidden_key,
                          const std::string& callback_name) {
  auto* isolate = context->GetIsolate();
  auto binding_key =
      gin::ConvertToV8(isolate, hidden_key)->ToString(context).ToLocalChecked();
  auto private_binding_key = v8::Private::ForApi(isolate, binding_key);
  auto global_object = context->Global();
  v8::Local<v8::Value> value;
  if (!global_object->GetPrivate(context, private_binding_key).ToLocal(&value))
    return;
  if (value.IsEmpty() || !value->IsObject())
    return;
  auto binding = value->ToObject(context).ToLocalChecked();
  auto callback_key = gin::ConvertToV8(isolate, callback_name)
                          ->ToString(context)
                          .ToLocalChecked();
  auto callback_value = binding->Get(context, callback_key).ToLocalChecked();
  DCHECK(callback_value->IsFunction());  
  auto callback = v8::Handle<v8::Function>::Cast(callback_value);
  ignore_result(callback->Call(context, binding, 0, nullptr));
}
}  
ElectronSandboxedRendererClient::ElectronSandboxedRendererClient() {