Implement browser-side host resolver Mojo service.

net/interfaces/host_resolver_service.mojom

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // WARNING! Do NOT use this mojom. It is intended as a temporary interface to
 // implement out-of-process proxy resolution. If you wish to use a Mojo DNS
 // service, contact amistry@/sammc@ and net-dev to discuss a permanent Mojo DNS
 // interface.
 
 // Put Mojo definitions into their own namespace to avoid collisions with C++
@@ skipping 22 matching lines @@
   // Will be of length 4 for IPv4 addresses and 16 for IPv6.
   array<uint8> address;
   uint16 port;
 };
 
 // Mirror of net::AddressList.
 struct AddressList {
   array<IPEndPoint> addresses;
 };
 
-interface HostResolverService {
+interface HostResolver {
   // Use a HostResolverRequestClient instead of returning a result so we can
   // cancel in-flight requests by destroying the client.  IPC requests in Mojo
   // cannot be cancelled directly.
   // TODO(amistry): Add BoundNetLog.
   Resolve(HostResolverRequestInfo request_info,
           HostResolverRequestClient client);
 };
 
 interface HostResolverRequestClient {
   // |error| is a value in net::Error.
   ReportResult(int32 error, AddressList? result);

[eroman, 2015/02/12 02:30:18]

Thinking out loud here... 

There is an expectation that the network error codes will always fit within an
int32.

In practice this is likely to be safe since "int" is used and I doubt chrome
will be moving away from 32-bit ints anytime soon.

However what techniques can we use to better future proof this code (and other
code with similar expectations)? Since if these sorts of changes were to happen
we would silently truncate errors and unfortunately our compiler settings
wouldn't even warn about it.

[Anand Mistry (off Chromium), 2015/02/12 04:47:15]

I think we have a couple of different options here. If we rely on ints being
32-bit, we could static_assert(sizeof(int) == sizeof(int32_t)). Of course, that
will won't help if we ever need to move to a 64-bit int platform. Another option
would be to use base::checked_cast(), which will check at run-time. That could
be appropriate for our uses. For error codes specifically, I wonder if we can
ensure that the enum values always fit in an int32_t, but maybe that's more
effort than it's worth.

 };