* Output of `node_modules/.bin/electron --version`: v2.0.8
* Operating System (Platform and Version): macos 10.13.6

**To Reproduce**
1. `protocol.interceptStreamProtocol` to handle requests from electron
2. In the callback, give a header like:
```
callback({
  headers: {
    'Set-Cookie': ['foo', 'bar', 'baz']
  }
})
```
3. Request a url and inspect chrome dev tools


**Expected Behavior**
In dev tools you can see multiple set-cookie headers, and multiple cookies get set.

**Actual behavior**
No cookies are set.

---

**To Reproduce**
With a sample repo:


1. clone / checkout the branch I'm on

    ```
    git clone git@github.com:ibash/nativefier.git
    cd nativefier
    git checkout offline_2
    ```

1. install dependencies and build nativefier

    ```
    yarn install
    cd app
    yarn install
    cd ..
    yarn build
    ```

1. package an example app and then run it

    ```
    node lib/cli.js --name "Queue Offline"  "https://safaribooksonline.com"
    ./Queue\ Offline-darwin-x64/Queue\ Offline.app/Contents/MacOS/Queue\ Offline
    ```

1. open dev tools in the app

1. inspect a network request

**Expected Behavior**
All the network requests should have three headers: "TEST: first", "TEST: second", "TEST: third"

**Actual behavior**
A single header like: "TEST: first, second, third"

---


**Additional Information**
The problem is that `Converter<net::HttpResponseHeaders*>::FromV8` expects each header to only have a single string value,  [see this line of code](https://github.com/electron/electron/blob/0e3b2d92d7de5e1d14051c7daf930639cc34c51f/atom/common/native_mate_converters/net_converter.cc#L190).

Oddly enough converting headers _to_ v8 is correct, and handles multiple headers with the same name [as a list](https://github.com/electron/electron/blob/0e3b2d92d7de5e1d14051c7daf930639cc34c51f/atom/common/native_mate_converters/net_converter.cc#L163).

As far as I can tell there's no way to actually respond with multiple header values with the same name.

Last but not least, I found you can crash electron if you send a header value like: `{bar: 'foo\0 bar: foo2'}`
atom/common/native_mate_converters/net_converter.cc
v8::Isolate* isolate,
    const scoped_refptr<net::X509Certificate>& val) {
  mate::Dictionary dict(isolate, v8::Object::New(isolate));
  std::string encoded_data;
  net::X509Certificate::GetPEMEncoded(val->cert_buffer(), &encoded_data);
  dict.Set("data", encoded_data);
  dict.Set("issuer", val->issuer());
  dict.Set("issuerName", val->issuer().GetDisplayName());
  dict.Set("subject", val->subject());
  dict.Set("subjectName", val->subject().GetDisplayName());
  dict.Set("serialNumber", base::HexEncode(val->serial_number().data(),
                                           val->serial_number().size()));
  dict.Set("validStart", val->valid_start().ToDoubleT());
  dict.Set("validExpiry", val->valid_expiry().ToDoubleT());
  dict.Set("fingerprint",
           net::HashValue(val->CalculateFingerprint256(val->cert_buffer()))
               .ToString());
  const auto& intermediate_buffers = val->intermediate_buffers();
  if (!intermediate_buffers.empty()) {
    std::vector<bssl::UniquePtr<CRYPTO_BUFFER>> issuer_intermediates;
    issuer_intermediates.reserve(intermediate_buffers.size() - 1);
    for (size_t i = 1; i < intermediate_buffers.size(); ++i) {
      issuer_intermediates.push_back(
          bssl::UpRef(intermediate_buffers[i].get()));
    }
    const scoped_refptr<net::X509Certificate>& issuer_cert =
        net::X509Certificate::CreateFromBuffer(
            bssl::UpRef(intermediate_buffers[0].get()),
            std::move(issuer_intermediates));
    dict.Set("issuerCert", issuer_cert);