* Output of `node_modules/.bin/electron --version`:
* Operating System (Platform and Version):
* Output of `node_modules/.bin/electron --version` on last known working Electron version (if applicable): 3.0.4

**Expected Behavior**
devtools extension's page (`manifest.json`'s `devtools_page`) have electron's global `chrome.*` extension api context constructed.

**Actual behavior**
`devtools_page` doesn't have context, any calls to `chrome.*` will fail

**To Reproduce**
```
const {app, BrowserWindow} = require('electron')

//enable mixed sandbox asap
app.enableMixedSandbox();

let mainWindow

function createWindow () {
  mainWindow = new BrowserWindow({width: 1024, height: 768})

 mainWindow.loadURL('https://reactjs.org')
  
  //other devtools extension can be used instead as long as `devtools_page` access chrome.* api
  require('devtron').install();
  mainWindow.webContents.openDevTools()

  mainWindow.on('closed', function () {
    mainWindow = null
  })
}

app.on('ready', createWindow)

app.on('window-all-closed', function () {
  if (process.platform !== 'darwin') {
    app.quit()
  }
})

app.on('activate', function () {
  if (mainWindow === null) {
    createWindow()
  }
})
```

devtron is used for simplified repro, but any other devtools (i.e react devtools) will have same symptoms.
launch electron, then open devtools will emit console logs like
```
[10800:1104/011325.639:ERROR:CONSOLE(7)] "Uncaught ReferenceError: chrome is not defined", source: chrome-extension://devtron/static/devtron.html (7)
```

**Screenshots**
If applicable, add screenshots to help explain your problem.

**Additional Information**
Add any other context about the problem here.

atom/renderer/atom_sandboxed_renderer_client.cc
std::string left = "(function(binding, require) {\n";
  std::string right = "\n})";
  
  auto script = v8::Script::Compile(v8::String::Concat(
      mate::ConvertToV8(isolate, left)->ToString(),
      v8::String::Concat(node::preload_bundle_value.ToStringChecked(isolate),
                         mate::ConvertToV8(isolate, right)->ToString())));
  auto func =
      v8::Handle<v8::Function>::Cast(script->Run(context).ToLocalChecked());
  
  auto binding = v8::Object::New(isolate);
  InitializeBindings(binding, context);
  AddRenderBindings(isolate, binding);
  v8::Local<v8::Value> args[] = {binding};
  
  ignore_result(
      func->Call(context, v8::Null(isolate), node::arraysize(args), args));
}
void AtomSandboxedRendererClient::WillReleaseScriptContext(
    v8::Handle<v8::Context> context,
    content::RenderFrame* render_frame) {
  
  if (!render_frame->IsMainFrame())
    return;
  auto* isolate = context->GetIsolate();
  v8::HandleScope handle_scope(isolate);
  v8::Context::Scope context_scope(context);
  InvokeIpcCallback(context, "onExit", std::vector<v8::Local<v8::Value>>());
}
void AtomSandboxedRendererClient::InvokeIpcCallback(