* 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
bool internal,
                    const std::string& channel,
                    const base::ListValue& args,
                    int32_t sender_id) override {
    if (!frame)
      return;
    auto* isolate = blink::MainThreadIsolate();
    v8::HandleScope handle_scope(isolate);
    auto context = frame->MainWorldScriptContext();
    v8::Context::Scope context_scope(context);
    v8::Local<v8::Value> argv[] = {mate::ConvertToV8(isolate, channel),
                                   mate::ConvertToV8(isolate, args),
                                   mate::ConvertToV8(isolate, sender_id)};
    renderer_client_->InvokeIpcCallback(
        context, internal ? "onInternalMessage" : "onMessage",
        std::vector<v8::Local<v8::Value>>(argv, argv + node::arraysize(argv)));
  }
 private:
  AtomSandboxedRendererClient* renderer_client_;
  DISALLOW_COPY_AND_ASSIGN(AtomSandboxedRenderFrameObserver);
};
}  
AtomSandboxedRendererClient::AtomSandboxedRendererClient() {
  
  NodeBindings::RegisterBuiltinModules();
  metrics_ = base::ProcessMetrics::CreateCurrentProcessMetrics();
}
AtomSandboxedRendererClient::~AtomSandboxedRendererClient() {}