BASELINE: Update Chromium to 56.0.2924.122

Change-Id: I4e04de8f47e47e501c46ed934c76a431c6337ced
Reviewed-by: Michael Brüning <michael.bruning@qt.io>

21 files changed, 304 insertions, 291 deletions

diff --git a/chromium/net/dns/OWNERS b/chromium/net/dns/OWNERS
new file mode 100644
index 00000000000..bb6511619b7
--- /dev/null
+++ b/chromium/net/dns/OWNERS
@@ -0,0 +1,2 @@
+per-file *_struct_traits*.*=set noparent
+per-file *_struct_traits*.*=file://ipc/SECURITY_OWNERS
diff --git a/chromium/net/dns/address_sorter_posix.cc b/chromium/net/dns/address_sorter_posix.cc
index 730fb4fb23a..965543c0a27 100644
--- a/chromium/net/dns/address_sorter_posix.cc
+++ b/chromium/net/dns/address_sorter_posix.cc
@@ -25,7 +25,7 @@
 #include "net/base/net_errors.h"
 #include "net/log/net_log_source.h"
 #include "net/socket/client_socket_factory.h"
-#include "net/udp/datagram_client_socket.h"
+#include "net/socket/datagram_client_socket.h"
 
 #if defined(OS_LINUX)
 #include "net/base/address_tracker_linux.h"
diff --git a/chromium/net/dns/address_sorter_posix_unittest.cc b/chromium/net/dns/address_sorter_posix_unittest.cc
index 203f76f0a52..102cc62f5fa 100644
--- a/chromium/net/dns/address_sorter_posix_unittest.cc
+++ b/chromium/net/dns/address_sorter_posix_unittest.cc
@@ -12,10 +12,10 @@
 #include "net/base/test_completion_callback.h"
 #include "net/log/net_log_with_source.h"
 #include "net/socket/client_socket_factory.h"
+#include "net/socket/datagram_client_socket.h"
 #include "net/socket/socket_performance_watcher.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/stream_socket.h"
-#include "net/udp/datagram_client_socket.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
diff --git a/chromium/net/dns/dns_protocol.h b/chromium/net/dns/dns_protocol.h
index 21bfc6cbc82..f80886338ac 100644
--- a/chromium/net/dns/dns_protocol.h
+++ b/chromium/net/dns/dns_protocol.h
@@ -96,6 +96,9 @@ static const uint16_t kOffsetMask = 0x3fff;
 // section 10.2.
 static const uint16_t kMDnsClassMask = 0x7FFF;
 
+// RFC 1035, section 3.1: To simplify implementations, the total length of
+// a domain name (i.e., label octets and label length octets) is restricted
+// to 255 octets or less.
 static const int kMaxNameLength = 255;
 
 // RFC 1035, section 4.2.1: Messages carried by UDP are restricted to 512
@@ -107,10 +110,13 @@ static const int kMaxUDPSize = 512;
 static const int kMaxMulticastSize = 9000;
 
 // DNS class types.
+//
+// https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-2
 static const uint16_t kClassIN = 1;
 
-// DNS resource record types. See
-// http://www.iana.org/assignments/dns-parameters
+// DNS resource record types.
+//
+// https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-4
 static const uint16_t kTypeA = 1;
 static const uint16_t kTypeCNAME = 5;
 static const uint16_t kTypePTR = 12;
@@ -119,7 +125,9 @@ static const uint16_t kTypeAAAA = 28;
 static const uint16_t kTypeSRV = 33;
 static const uint16_t kTypeNSEC = 47;
 
-// DNS rcode values.
+// DNS reply codes (RCODEs).
+//
+// https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-6
 static const uint8_t kRcodeMask = 0xf;
 static const uint8_t kRcodeNOERROR = 0;
 static const uint8_t kRcodeFORMERR = 1;
diff --git a/chromium/net/dns/dns_session.cc b/chromium/net/dns/dns_session.cc
index b022907c4db..cdcd7ce0f49 100644
--- a/chromium/net/dns/dns_session.cc
+++ b/chromium/net/dns/dns_session.cc
@@ -28,8 +28,8 @@
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_source.h"
 #include "net/log/net_log_with_source.h"
+#include "net/socket/datagram_client_socket.h"
 #include "net/socket/stream_socket.h"
-#include "net/udp/datagram_client_socket.h"
 
 namespace net {
 
diff --git a/chromium/net/dns/dns_socket_pool.cc b/chromium/net/dns/dns_socket_pool.cc
index 2d42ad78e4c..bf90c28c573 100644
--- a/chromium/net/dns/dns_socket_pool.cc
+++ b/chromium/net/dns/dns_socket_pool.cc
@@ -13,8 +13,8 @@
 #include "net/base/net_errors.h"
 #include "net/log/net_log_source.h"
 #include "net/socket/client_socket_factory.h"
+#include "net/socket/datagram_client_socket.h"
 #include "net/socket/stream_socket.h"
-#include "net/udp/datagram_client_socket.h"
 
 namespace net {
 
diff --git a/chromium/net/dns/dns_transaction.cc b/chromium/net/dns/dns_transaction.cc
index 7d0c044bcac..8c7a7577240 100644
--- a/chromium/net/dns/dns_transaction.cc
+++ b/chromium/net/dns/dns_transaction.cc
@@ -42,8 +42,8 @@
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_source.h"
 #include "net/log/net_log_with_source.h"
+#include "net/socket/datagram_client_socket.h"
 #include "net/socket/stream_socket.h"
-#include "net/udp/datagram_client_socket.h"
 
 namespace net {
 
diff --git a/chromium/net/dns/host_resolver_impl.cc b/chromium/net/dns/host_resolver_impl.cc
index 4a5be1834ff..fceb67e33a5 100644
--- a/chromium/net/dns/host_resolver_impl.cc
+++ b/chromium/net/dns/host_resolver_impl.cc
@@ -62,7 +62,7 @@
 #include "net/log/net_log_source_type.h"
 #include "net/log/net_log_with_source.h"
 #include "net/socket/client_socket_factory.h"
-#include "net/udp/datagram_client_socket.h"
+#include "net/socket/datagram_client_socket.h"
 #include "url/url_canon_ip.h"
 
 #if defined(OS_WIN)
@@ -254,7 +254,7 @@ bool IsGloballyReachable(const IPAddress& dest,
       case LOW: DNS_HISTOGRAM(basename "_LOW", time); break; \
       case LOWEST: DNS_HISTOGRAM(basename "_LOWEST", time); break; \
       case IDLE: DNS_HISTOGRAM(basename "_IDLE", time); break; \
-      default: NOTREACHED(); break; \
+      case THROTTLED: DNS_HISTOGRAM(basename "_THROTTLED", time); break; \
     } \
     DNS_HISTOGRAM(basename, time); \
   } while (0)
diff --git a/chromium/net/dns/host_resolver_mojo.cc b/chromium/net/dns/host_resolver_mojo.cc
index aeca31baf2e..3c311c4a2a8 100644
--- a/chromium/net/dns/host_resolver_mojo.cc
+++ b/chromium/net/dns/host_resolver_mojo.cc
@@ -10,7 +10,6 @@
 #include "mojo/public/cpp/bindings/binding.h"
 #include "net/base/address_list.h"
 #include "net/base/net_errors.h"
-#include "net/dns/mojo_host_type_converters.h"
 
 namespace net {
 namespace {
@@ -38,8 +37,7 @@ class HostResolverMojo::Job : public interfaces::HostResolverRequestClient {
 
  private:
   // interfaces::HostResolverRequestClient override.
-  void ReportResult(int32_t error,
-                    interfaces::AddressListPtr address_list) override;
+  void ReportResult(int32_t error, const AddressList& address_list) override;
 
   // Mojo error handler.
   void OnConnectionError();
@@ -95,7 +93,7 @@ int HostResolverMojo::Resolve(const RequestInfo& info,
                                    host_cache_weak_factory_.GetWeakPtr()));
   request->reset(new RequestImpl(std::move(job)));
 
-  impl_->ResolveDns(interfaces::HostResolverRequestInfo::From(info),
+  impl_->ResolveDns(base::MakeUnique<HostResolver::RequestInfo>(info),
                     std::move(handle));
   return ERR_IO_PENDING;
 }
@@ -142,11 +140,10 @@ HostResolverMojo::Job::Job(
       &HostResolverMojo::Job::OnConnectionError, base::Unretained(this)));
 }
 
-void HostResolverMojo::Job::ReportResult(
-    int32_t error,
-    interfaces::AddressListPtr address_list) {
-  if (error == OK && address_list)
-    *addresses_ = address_list->To<AddressList>();
+void HostResolverMojo::Job::ReportResult(int32_t error,
+                                         const AddressList& address_list) {
+  if (error == OK)
+    *addresses_ = address_list;
   if (host_cache_) {
     base::TimeDelta ttl = base::TimeDelta::FromSeconds(
         error == OK ? kCacheEntryTTLSeconds : kNegativeCacheEntryTTLSeconds);
@@ -159,7 +156,7 @@ void HostResolverMojo::Job::ReportResult(
 }
 
 void HostResolverMojo::Job::OnConnectionError() {
-  ReportResult(ERR_FAILED, interfaces::AddressListPtr());
+  ReportResult(ERR_FAILED, AddressList());
 }
 
 }  // namespace net
diff --git a/chromium/net/dns/host_resolver_mojo.h b/chromium/net/dns/host_resolver_mojo.h
index de674990d16..602660adb8e 100644
--- a/chromium/net/dns/host_resolver_mojo.h
+++ b/chromium/net/dns/host_resolver_mojo.h
@@ -23,8 +23,9 @@ class HostResolverMojo : public HostResolver {
   class Impl {
    public:
     virtual ~Impl() = default;
-    virtual void ResolveDns(interfaces::HostResolverRequestInfoPtr,
-                            interfaces::HostResolverRequestClientPtr) = 0;
+    virtual void ResolveDns(
+        std::unique_ptr<HostResolver::RequestInfo> request_info,
+        interfaces::HostResolverRequestClientPtr) = 0;
   };
 
   // |impl| must outlive |this|.
diff --git a/chromium/net/dns/host_resolver_mojo_unittest.cc b/chromium/net/dns/host_resolver_mojo_unittest.cc
index eac52768625..8dcd55b0565 100644
--- a/chromium/net/dns/host_resolver_mojo_unittest.cc
+++ b/chromium/net/dns/host_resolver_mojo_unittest.cc
@@ -14,7 +14,6 @@
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
 #include "net/base/test_completion_callback.h"
-#include "net/dns/mojo_host_type_converters.h"
 #include "net/log/net_log_with_source.h"
 #include "net/test/event_waiter.h"
 #include "net/test/gtest_util.h"
@@ -61,33 +60,32 @@ struct HostResolverAction {
     RETAIN,
   };
 
-  static std::unique_ptr<HostResolverAction> ReturnError(Error error) {
-    std::unique_ptr<HostResolverAction> result(new HostResolverAction);
-    result->error = error;
+  static HostResolverAction ReturnError(Error error) {
+    HostResolverAction result;
+    result.error = error;
     return result;
   }
 
-  static std::unique_ptr<HostResolverAction> ReturnResult(
-      const AddressList& address_list) {
-    std::unique_ptr<HostResolverAction> result(new HostResolverAction);
-    result->addresses = interfaces::AddressList::From(address_list);
+  static HostResolverAction ReturnResult(const AddressList& address_list) {
+    HostResolverAction result;
+    result.addresses = address_list;
     return result;
   }
 
-  static std::unique_ptr<HostResolverAction> DropRequest() {
-    std::unique_ptr<HostResolverAction> result(new HostResolverAction);
-    result->action = DROP;
+  static HostResolverAction DropRequest() {
+    HostResolverAction result;
+    result.action = DROP;
     return result;
   }
 
-  static std::unique_ptr<HostResolverAction> RetainRequest() {
-    std::unique_ptr<HostResolverAction> result(new HostResolverAction);
-    result->action = RETAIN;
+  static HostResolverAction RetainRequest() {
+    HostResolverAction result;
+    result.action = RETAIN;
     return result;
   }
 
   Action action = COMPLETE;
-  interfaces::AddressListPtr addresses;
+  AddressList addresses;
   Error error = OK;
 };
 
@@ -97,19 +95,19 @@ class MockMojoHostResolver : public HostResolverMojo::Impl {
       const base::Closure& request_connection_error_callback);
   ~MockMojoHostResolver() override;
 
-  void AddAction(std::unique_ptr<HostResolverAction> action);
+  void AddAction(HostResolverAction action);
 
-  const mojo::Array<interfaces::HostResolverRequestInfoPtr>& requests() {
+  const std::vector<HostResolver::RequestInfo>& requests() {
     return requests_received_;
   }
 
-  void ResolveDns(interfaces::HostResolverRequestInfoPtr request_info,
+  void ResolveDns(std::unique_ptr<HostResolver::RequestInfo> request_info,
                   interfaces::HostResolverRequestClientPtr client) override;
 
  private:
-  std::vector<std::unique_ptr<HostResolverAction>> actions_;
+  std::vector<HostResolverAction> actions_;
   size_t results_returned_ = 0;
-  mojo::Array<interfaces::HostResolverRequestInfoPtr> requests_received_;
+  std::vector<HostResolver::RequestInfo> requests_received_;
   const base::Closure request_connection_error_callback_;
   std::vector<std::unique_ptr<MockMojoHostResolverRequest>> requests_;
 };
@@ -123,20 +121,19 @@ MockMojoHostResolver::~MockMojoHostResolver() {
   EXPECT_EQ(results_returned_, actions_.size());
 }
 
-void MockMojoHostResolver::AddAction(
-    std::unique_ptr<HostResolverAction> action) {
+void MockMojoHostResolver::AddAction(HostResolverAction action) {
   actions_.push_back(std::move(action));
 }
 
 void MockMojoHostResolver::ResolveDns(
-    interfaces::HostResolverRequestInfoPtr request_info,
+    std::unique_ptr<HostResolver::RequestInfo> request_info,
     interfaces::HostResolverRequestClientPtr client) {
-  requests_received_.push_back(std::move(request_info));
+  requests_received_.push_back(std::move(*request_info));
   ASSERT_LE(results_returned_, actions_.size());
-  switch (actions_[results_returned_]->action) {
+  switch (actions_[results_returned_].action) {
     case HostResolverAction::COMPLETE:
-      client->ReportResult(actions_[results_returned_]->error,
-                           std::move(actions_[results_returned_]->addresses));
+      client->ReportResult(actions_[results_returned_].error,
+                           std::move(actions_[results_returned_].addresses));
       break;
     case HostResolverAction::RETAIN:
       requests_.push_back(base::WrapUnique(new MockMojoHostResolverRequest(
@@ -198,11 +195,11 @@ TEST_F(HostResolverMojoTest, Basic) {
   EXPECT_EQ(address_list[1], result[1]);
 
   ASSERT_EQ(1u, mock_resolver_->requests().size());
-  interfaces::HostResolverRequestInfo& request = *mock_resolver_->requests()[0];
-  EXPECT_EQ("example.com", request.host.To<std::string>());
-  EXPECT_EQ(12345, request.port);
-  EXPECT_EQ(interfaces::AddressFamily::UNSPECIFIED, request.address_family);
-  EXPECT_FALSE(request.is_my_ip_address);
+  const HostResolver::RequestInfo& request = mock_resolver_->requests()[0];
+  EXPECT_EQ("example.com", request.hostname());
+  EXPECT_EQ(12345, request.port());
+  EXPECT_EQ(ADDRESS_FAMILY_UNSPECIFIED, request.address_family());
+  EXPECT_FALSE(request.is_my_ip_address());
 }
 
 TEST_F(HostResolverMojoTest, ResolveCachedResult) {
@@ -274,16 +271,16 @@ TEST_F(HostResolverMojoTest, Multiple) {
   ASSERT_EQ(0u, result2.size());
 
   ASSERT_EQ(2u, mock_resolver_->requests().size());
-  interfaces::HostResolverRequestInfo& info1 = *mock_resolver_->requests()[0];
-  EXPECT_EQ("example.com", info1.host.To<std::string>());
-  EXPECT_EQ(12345, info1.port);
-  EXPECT_EQ(interfaces::AddressFamily::IPV4, info1.address_family);
-  EXPECT_TRUE(info1.is_my_ip_address);
-  interfaces::HostResolverRequestInfo& info2 = *mock_resolver_->requests()[1];
-  EXPECT_EQ("example.org", info2.host.To<std::string>());
-  EXPECT_EQ(80, info2.port);
-  EXPECT_EQ(interfaces::AddressFamily::IPV6, info2.address_family);
-  EXPECT_FALSE(info2.is_my_ip_address);
+  const HostResolver::RequestInfo& info1 = mock_resolver_->requests()[0];
+  EXPECT_EQ("example.com", info1.hostname());
+  EXPECT_EQ(12345, info1.port());
+  EXPECT_EQ(ADDRESS_FAMILY_IPV4, info1.address_family());
+  EXPECT_TRUE(info1.is_my_ip_address());
+  const HostResolver::RequestInfo& info2 = mock_resolver_->requests()[1];
+  EXPECT_EQ("example.org", info2.hostname());
+  EXPECT_EQ(80, info2.port());
+  EXPECT_EQ(ADDRESS_FAMILY_IPV6, info2.address_family());
+  EXPECT_FALSE(info2.is_my_ip_address());
 }
 
 TEST_F(HostResolverMojoTest, Error) {
@@ -297,11 +294,11 @@ TEST_F(HostResolverMojoTest, Error) {
   EXPECT_TRUE(result.empty());
 
   ASSERT_EQ(1u, mock_resolver_->requests().size());
-  interfaces::HostResolverRequestInfo& request = *mock_resolver_->requests()[0];
-  EXPECT_EQ("example.com", request.host.To<std::string>());
-  EXPECT_EQ(8080, request.port);
-  EXPECT_EQ(interfaces::AddressFamily::IPV4, request.address_family);
-  EXPECT_FALSE(request.is_my_ip_address);
+  const HostResolver::RequestInfo& request = mock_resolver_->requests()[0];
+  EXPECT_EQ("example.com", request.hostname());
+  EXPECT_EQ(8080, request.port());
+  EXPECT_EQ(ADDRESS_FAMILY_IPV4, request.address_family());
+  EXPECT_FALSE(request.is_my_ip_address());
 }
 
 TEST_F(HostResolverMojoTest, EmptyResult) {
@@ -329,11 +326,11 @@ TEST_F(HostResolverMojoTest, Cancel) {
   EXPECT_TRUE(result.empty());
 
   ASSERT_EQ(1u, mock_resolver_->requests().size());
-  interfaces::HostResolverRequestInfo& info1 = *mock_resolver_->requests()[0];
-  EXPECT_EQ("example.com", info1.host.To<std::string>());
-  EXPECT_EQ(80, info1.port);
-  EXPECT_EQ(interfaces::AddressFamily::IPV6, info1.address_family);
-  EXPECT_FALSE(info1.is_my_ip_address);
+  const HostResolver::RequestInfo& info1 = mock_resolver_->requests()[0];
+  EXPECT_EQ("example.com", info1.hostname());
+  EXPECT_EQ(80, info1.port());
+  EXPECT_EQ(ADDRESS_FAMILY_IPV6, info1.address_family());
+  EXPECT_FALSE(info1.is_my_ip_address());
 }
 
 TEST_F(HostResolverMojoTest, ImplDropsClientConnection) {
@@ -345,11 +342,11 @@ TEST_F(HostResolverMojoTest, ImplDropsClientConnection) {
   EXPECT_TRUE(result.empty());
 
   ASSERT_EQ(1u, mock_resolver_->requests().size());
-  interfaces::HostResolverRequestInfo& info2 = *mock_resolver_->requests()[0];
-  EXPECT_EQ("example.com", info2.host.To<std::string>());
-  EXPECT_EQ(1, info2.port);
-  EXPECT_EQ(interfaces::AddressFamily::UNSPECIFIED, info2.address_family);
-  EXPECT_FALSE(info2.is_my_ip_address);
+  const HostResolver::RequestInfo& info2 = mock_resolver_->requests()[0];
+  EXPECT_EQ("example.com", info2.hostname());
+  EXPECT_EQ(1, info2.port());
+  EXPECT_EQ(ADDRESS_FAMILY_UNSPECIFIED, info2.address_family());
+  EXPECT_FALSE(info2.is_my_ip_address());
 }
 
 TEST_F(HostResolverMojoTest, ResolveFromCache_Miss) {
diff --git a/chromium/net/dns/mdns_client_impl.cc b/chromium/net/dns/mdns_client_impl.cc
index 634822e83fc..67c5ac5b333 100644
--- a/chromium/net/dns/mdns_client_impl.cc
+++ b/chromium/net/dns/mdns_client_impl.cc
@@ -23,7 +23,7 @@
 #include "net/dns/dns_protocol.h"
 #include "net/dns/dns_util.h"
 #include "net/dns/record_rdata.h"
-#include "net/udp/datagram_socket.h"
+#include "net/socket/datagram_socket.h"
 
 // TODO(gene): Remove this temporary method of disabling NSEC support once it
 // becomes clear whether this feature should be
@@ -323,7 +323,8 @@ void MDnsClientImpl::Core::NotifyNsecRecord(const RecordParsed* record) {
       listeners_.upper_bound(ListenerKey(record->name(), 0));
   for (; i != listeners_.end() && i->first.first == record->name(); i++) {
     if (!rdata->GetBit(i->first.second)) {
-      FOR_EACH_OBSERVER(MDnsListenerImpl, *i->second, AlertNsecRecord());
+      for (auto& observer : *i->second)
+        observer.AlertNsecRecord();
     }
   }
 }
@@ -340,8 +341,8 @@ void MDnsClientImpl::Core::AlertListeners(
   ListenerMap::iterator listener_map_iterator = listeners_.find(key);
   if (listener_map_iterator == listeners_.end()) return;
 
-  FOR_EACH_OBSERVER(MDnsListenerImpl, *listener_map_iterator->second,
-                    HandleRecordUpdate(update_type, record));
+  for (auto& observer : *listener_map_iterator->second)
+    observer.HandleRecordUpdate(update_type, record);
 }
 
 void MDnsClientImpl::Core::AddListener(
diff --git a/chromium/net/dns/mdns_client_impl.h b/chromium/net/dns/mdns_client_impl.h
index 1f064129ea7..ec0536c6264 100644
--- a/chromium/net/dns/mdns_client_impl.h
+++ b/chromium/net/dns/mdns_client_impl.h
@@ -23,9 +23,9 @@
 #include "net/base/net_export.h"
 #include "net/dns/mdns_cache.h"
 #include "net/dns/mdns_client.h"
-#include "net/udp/datagram_server_socket.h"
-#include "net/udp/udp_server_socket.h"
-#include "net/udp/udp_socket.h"
+#include "net/socket/datagram_server_socket.h"
+#include "net/socket/udp_server_socket.h"
+#include "net/socket/udp_socket.h"
 
 namespace base {
 class Clock;
diff --git a/chromium/net/dns/mdns_client_unittest.cc b/chromium/net/dns/mdns_client_unittest.cc
index 8edf48e7ecc..af64bce3f33 100644
--- a/chromium/net/dns/mdns_client_unittest.cc
+++ b/chromium/net/dns/mdns_client_unittest.cc
@@ -23,7 +23,7 @@
 #include "net/dns/mdns_client_impl.h"
 #include "net/dns/mock_mdns_socket_factory.h"
 #include "net/dns/record_rdata.h"
-#include "net/udp/udp_client_socket.h"
+#include "net/socket/udp_client_socket.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
diff --git a/chromium/net/dns/mojo_host_resolver_impl.cc b/chromium/net/dns/mojo_host_resolver_impl.cc
index 1e32639ec38..f8f08d8b249 100644
--- a/chromium/net/dns/mojo_host_resolver_impl.cc
+++ b/chromium/net/dns/mojo_host_resolver_impl.cc
@@ -11,7 +11,6 @@
 #include "net/base/net_errors.h"
 #include "net/base/network_interfaces.h"
 #include "net/dns/host_resolver.h"
-#include "net/dns/mojo_host_type_converters.h"
 
 namespace net {
 
@@ -56,19 +55,17 @@ MojoHostResolverImpl::~MojoHostResolverImpl() {
 }
 
 void MojoHostResolverImpl::Resolve(
-    interfaces::HostResolverRequestInfoPtr request_info,
+    std::unique_ptr<HostResolver::RequestInfo> request_info,
     interfaces::HostResolverRequestClientPtr client) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  HostResolver::RequestInfo host_request_info =
-      request_info->To<net::HostResolver::RequestInfo>();
-  if (host_request_info.is_my_ip_address()) {
+  if (request_info->is_my_ip_address()) {
     // The proxy resolver running inside a sandbox may not be able to get the
     // correct host name. Instead, fill it ourself if the request is for our own
     // IP address.
-    host_request_info.set_host_port_pair(HostPortPair(GetHostName(), 80));
+    request_info->set_host_port_pair(HostPortPair(GetHostName(), 80));
   }
-  Job* job = new Job(this, resolver_, host_request_info, net_log_,
-                     std::move(client));
+  Job* job =
+      new Job(this, resolver_, *request_info, net_log_, std::move(client));
   pending_jobs_.insert(job);
   job->Start();
 }
@@ -119,11 +116,7 @@ void MojoHostResolverImpl::Job::OnResolveDone(int result) {
   for (const auto& address : result_) {
     DVLOG(1) << address.ToString();
   }
-  if (result == OK)
-    client_->ReportResult(result, interfaces::AddressList::From(result_));
-  else
-    client_->ReportResult(result, nullptr);
-
+  client_->ReportResult(result, result_);
   resolver_service_->DeleteJob(this);
 }
 
diff --git a/chromium/net/dns/mojo_host_resolver_impl.h b/chromium/net/dns/mojo_host_resolver_impl.h
index 68eb893e47c..8c9eb48cc44 100644
--- a/chromium/net/dns/mojo_host_resolver_impl.h
+++ b/chromium/net/dns/mojo_host_resolver_impl.h
@@ -28,7 +28,7 @@ class MojoHostResolverImpl {
                        const NetLogWithSource& net_log);
   ~MojoHostResolverImpl();
 
-  void Resolve(interfaces::HostResolverRequestInfoPtr request_info,
+  void Resolve(std::unique_ptr<HostResolver::RequestInfo> request_info,
                interfaces::HostResolverRequestClientPtr client);
 
   bool request_in_progress() { return !pending_jobs_.empty(); }
diff --git a/chromium/net/dns/mojo_host_resolver_impl_unittest.cc b/chromium/net/dns/mojo_host_resolver_impl_unittest.cc
index 9b7425ab0fa..9405c71afb1 100644
--- a/chromium/net/dns/mojo_host_resolver_impl_unittest.cc
+++ b/chromium/net/dns/mojo_host_resolver_impl_unittest.cc
@@ -15,7 +15,6 @@
 #include "net/base/address_list.h"
 #include "net/base/net_errors.h"
 #include "net/dns/mock_host_resolver.h"
-#include "net/dns/mojo_host_type_converters.h"
 #include "net/test/gtest_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -40,11 +39,11 @@ class TestRequestClient : public interfaces::HostResolverRequestClient {
   void WaitForConnectionError();
 
   int32_t error_;
-  interfaces::AddressListPtr results_;
+  AddressList results_;
 
  private:
   // Overridden from interfaces::HostResolverRequestClient.
-  void ReportResult(int32_t error, interfaces::AddressListPtr results) override;
+  void ReportResult(int32_t error, const AddressList& results) override;
 
   // Mojo error handler.
   void OnConnectionError();
@@ -73,13 +72,13 @@ void TestRequestClient::WaitForConnectionError() {
 }
 
 void TestRequestClient::ReportResult(int32_t error,
-                                     interfaces::AddressListPtr results) {
+                                     const AddressList& results) {
   if (!run_loop_quit_closure_.is_null()) {
     run_loop_quit_closure_.Run();
   }
   ASSERT_FALSE(done_);
   error_ = error;
-  results_ = std::move(results);
+  results_ = results;
   done_ = true;
 }
 
@@ -139,15 +138,12 @@ class MojoHostResolverImplTest : public testing::Test {
         new MojoHostResolverImpl(&mock_host_resolver_, NetLogWithSource()));
   }
 
-  interfaces::HostResolverRequestInfoPtr CreateRequest(const std::string& host,
-                                                       uint16_t port,
-                                                       bool is_my_ip_address) {
-    interfaces::HostResolverRequestInfoPtr request =
-        interfaces::HostResolverRequestInfo::New();
-    request->host = host;
-    request->port = port;
-    request->address_family = interfaces::AddressFamily::IPV4;
-    request->is_my_ip_address = is_my_ip_address;
+  std::unique_ptr<HostResolver::RequestInfo>
+  CreateRequest(const std::string& host, uint16_t port, bool is_my_ip_address) {
+    std::unique_ptr<HostResolver::RequestInfo> request =
+        base::MakeUnique<HostResolver::RequestInfo>(HostPortPair(host, port));
+    request->set_is_my_ip_address(is_my_ip_address);
+    request->set_address_family(ADDRESS_FAMILY_IPV4);
     return request;
   }
 
@@ -168,13 +164,12 @@ TEST_F(MojoHostResolverImplTest, Resolve) {
   interfaces::HostResolverRequestClientPtr client_ptr;
   TestRequestClient client(mojo::GetProxy(&client_ptr));
 
-  interfaces::HostResolverRequestInfoPtr request =
-      CreateRequest("example.com", 80, false);
-  resolver_service_->Resolve(std::move(request), std::move(client_ptr));
+  resolver_service_->Resolve(CreateRequest("example.com", 80, false),
+                             std::move(client_ptr));
   client.WaitForResult();
 
   EXPECT_THAT(client.error_, IsOk());
-  AddressList address_list = (*client.results_).To<AddressList>();
+  AddressList& address_list = client.results_;
   EXPECT_EQ(1U, address_list.size());
   EXPECT_EQ("1.2.3.4:80", address_list[0].ToString());
 }
@@ -185,13 +180,12 @@ TEST_F(MojoHostResolverImplTest, ResolveSynchronous) {
 
   mock_host_resolver_.set_synchronous_mode(true);
 
-  interfaces::HostResolverRequestInfoPtr request =
-      CreateRequest("example.com", 80, false);
-  resolver_service_->Resolve(std::move(request), std::move(client_ptr));
+  resolver_service_->Resolve(CreateRequest("example.com", 80, false),
+                             std::move(client_ptr));
   client.WaitForResult();
 
   EXPECT_THAT(client.error_, IsOk());
-  AddressList address_list = (*client.results_).To<AddressList>();
+  AddressList& address_list = client.results_;
   EXPECT_EQ(1U, address_list.size());
   EXPECT_EQ("1.2.3.4:80", address_list[0].ToString());
 }
@@ -204,12 +198,10 @@ TEST_F(MojoHostResolverImplTest, ResolveMultiple) {
 
   mock_host_resolver_.set_ondemand_mode(true);
 
-  interfaces::HostResolverRequestInfoPtr request1 =
-      CreateRequest("example.com", 80, false);
-  resolver_service_->Resolve(std::move(request1), std::move(client1_ptr));
-  interfaces::HostResolverRequestInfoPtr request2 =
-      CreateRequest("chromium.org", 80, false);
-  resolver_service_->Resolve(std::move(request2), std::move(client2_ptr));
+  resolver_service_->Resolve(CreateRequest("example.com", 80, false),
+                             std::move(client1_ptr));
+  resolver_service_->Resolve(CreateRequest("chromium.org", 80, false),
+                             std::move(client2_ptr));
   WaitForRequests(2);
   mock_host_resolver_.ResolveAllPending();
 
@@ -217,13 +209,13 @@ TEST_F(MojoHostResolverImplTest, ResolveMultiple) {
   client2.WaitForResult();
 
   EXPECT_THAT(client1.error_, IsOk());
-  AddressList address_list = (*client1.results_).To<AddressList>();
-  EXPECT_EQ(1U, address_list.size());
-  EXPECT_EQ("1.2.3.4:80", address_list[0].ToString());
+  AddressList& address_list1 = client1.results_;
+  EXPECT_EQ(1U, address_list1.size());
+  EXPECT_EQ("1.2.3.4:80", address_list1[0].ToString());
   EXPECT_THAT(client2.error_, IsOk());
-  address_list = (*client2.results_).To<AddressList>();
-  EXPECT_EQ(1U, address_list.size());
-  EXPECT_EQ("8.8.8.8:80", address_list[0].ToString());
+  AddressList& address_list2 = client2.results_;
+  EXPECT_EQ(1U, address_list2.size());
+  EXPECT_EQ("8.8.8.8:80", address_list2[0].ToString());
 }
 
 TEST_F(MojoHostResolverImplTest, ResolveDuplicate) {
@@ -234,12 +226,10 @@ TEST_F(MojoHostResolverImplTest, ResolveDuplicate) {
 
   mock_host_resolver_.set_ondemand_mode(true);
 
-  interfaces::HostResolverRequestInfoPtr request1 =
-      CreateRequest("example.com", 80, false);
-  resolver_service_->Resolve(std::move(request1), std::move(client1_ptr));
-  interfaces::HostResolverRequestInfoPtr request2 =
-      CreateRequest("example.com", 80, false);
-  resolver_service_->Resolve(std::move(request2), std::move(client2_ptr));
+  resolver_service_->Resolve(CreateRequest("example.com", 80, false),
+                             std::move(client1_ptr));
+  resolver_service_->Resolve(CreateRequest("example.com", 80, false),
+                             std::move(client2_ptr));
   WaitForRequests(2);
   mock_host_resolver_.ResolveAllPending();
 
@@ -247,26 +237,25 @@ TEST_F(MojoHostResolverImplTest, ResolveDuplicate) {
   client2.WaitForResult();
 
   EXPECT_THAT(client1.error_, IsOk());
-  AddressList address_list = (*client1.results_).To<AddressList>();
-  EXPECT_EQ(1U, address_list.size());
-  EXPECT_EQ("1.2.3.4:80", address_list[0].ToString());
+  AddressList& address_list1 = client1.results_;
+  EXPECT_EQ(1U, address_list1.size());
+  EXPECT_EQ("1.2.3.4:80", address_list1[0].ToString());
   EXPECT_THAT(client2.error_, IsOk());
-  address_list = (*client2.results_).To<AddressList>();
-  EXPECT_EQ(1U, address_list.size());
-  EXPECT_EQ("1.2.3.4:80", address_list[0].ToString());
+  AddressList& address_list2 = client2.results_;
+  EXPECT_EQ(1U, address_list2.size());
+  EXPECT_EQ("1.2.3.4:80", address_list2[0].ToString());
 }
 
 TEST_F(MojoHostResolverImplTest, ResolveFailure) {
   interfaces::HostResolverRequestClientPtr client_ptr;
   TestRequestClient client(mojo::GetProxy(&client_ptr));
 
-  interfaces::HostResolverRequestInfoPtr request =
-      CreateRequest("failure.fail", 80, false);
-  resolver_service_->Resolve(std::move(request), std::move(client_ptr));
+  resolver_service_->Resolve(CreateRequest("failure.fail", 80, false),
+                             std::move(client_ptr));
   client.WaitForResult();
 
   EXPECT_THAT(client.error_, IsError(net::ERR_NAME_NOT_RESOLVED));
-  EXPECT_TRUE(client.results_.is_null());
+  EXPECT_TRUE(client.results_.empty());
 }
 
 TEST_F(MojoHostResolverImplTest, DestroyClient) {
@@ -276,9 +265,8 @@ TEST_F(MojoHostResolverImplTest, DestroyClient) {
 
   mock_host_resolver_.set_ondemand_mode(true);
 
-  interfaces::HostResolverRequestInfoPtr request =
-      CreateRequest("example.com", 80, false);
-  resolver_service_->Resolve(std::move(request), std::move(client_ptr));
+  resolver_service_->Resolve(CreateRequest("example.com", 80, false),
+                             std::move(client_ptr));
   WaitForRequests(1);
 
   client.reset();
diff --git a/chromium/net/dns/mojo_host_struct_traits.cc b/chromium/net/dns/mojo_host_struct_traits.cc
new file mode 100644
index 00000000000..9772fd2c139
--- /dev/null
+++ b/chromium/net/dns/mojo_host_struct_traits.cc
@@ -0,0 +1,89 @@
+// 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.
+
+#include "net/dns/mojo_host_struct_traits.h"
+
+#include <utility>
+
+#include "net/base/address_list.h"
+
+namespace mojo {
+
+// static
+bool EnumTraits<net::interfaces::AddressFamily, net::AddressFamily>::FromMojom(
+    net::interfaces::AddressFamily address_family,
+    net::AddressFamily* out) {
+  using net::interfaces::AddressFamily;
+  switch (address_family) {
+    case AddressFamily::UNSPECIFIED:
+      *out = net::ADDRESS_FAMILY_UNSPECIFIED;
+      return true;
+    case AddressFamily::IPV4:
+      *out = net::ADDRESS_FAMILY_IPV4;
+      return true;
+    case AddressFamily::IPV6:
+      *out = net::ADDRESS_FAMILY_IPV6;
+      return true;
+  }
+  return false;
+}
+
+// static
+net::interfaces::AddressFamily
+EnumTraits<net::interfaces::AddressFamily, net::AddressFamily>::ToMojom(
+    net::AddressFamily address_family) {
+  using net::interfaces::AddressFamily;
+  switch (address_family) {
+    case net::ADDRESS_FAMILY_UNSPECIFIED:
+      return AddressFamily::UNSPECIFIED;
+    case net::ADDRESS_FAMILY_IPV4:
+      return AddressFamily::IPV4;
+    case net::ADDRESS_FAMILY_IPV6:
+      return AddressFamily::IPV6;
+  }
+  NOTREACHED();
+  return AddressFamily::UNSPECIFIED;
+}
+
+// static
+bool StructTraits<net::interfaces::HostResolverRequestInfoDataView,
+                  std::unique_ptr<net::HostResolver::RequestInfo>>::
+    Read(net::interfaces::HostResolverRequestInfoDataView data,
+         std::unique_ptr<net::HostResolver::RequestInfo>* out) {
+  base::StringPiece host;
+  if (!data.ReadHost(&host))
+    return false;
+
+  net::AddressFamily address_family;
+  if (!data.ReadAddressFamily(&address_family))
+    return false;
+
+  *out = base::MakeUnique<net::HostResolver::RequestInfo>(
+      net::HostPortPair(host.as_string(), data.port()));
+  net::HostResolver::RequestInfo& request = **out;
+  request.set_address_family(address_family);
+  request.set_is_my_ip_address(data.is_my_ip_address());
+  return true;
+}
+
+// static
+bool StructTraits<net::interfaces::IPEndPointDataView, net::IPEndPoint>::Read(
+    net::interfaces::IPEndPointDataView data,
+    net::IPEndPoint* out) {
+  std::vector<uint8_t> bytes;
+  if (!data.ReadAddress(&bytes))
+    return false;
+
+  *out = net::IPEndPoint(net::IPAddress(bytes), data.port());
+  return true;
+}
+
+// static
+bool StructTraits<net::interfaces::AddressListDataView, net::AddressList>::Read(
+    net::interfaces::AddressListDataView data,
+    net::AddressList* out) {
+  return data.ReadAddresses(&out->endpoints());
+}
+
+}  // namespace mojo
diff --git a/chromium/net/dns/mojo_host_struct_traits.h b/chromium/net/dns/mojo_host_struct_traits.h
new file mode 100644
index 00000000000..307e1b22ba8
--- /dev/null
+++ b/chromium/net/dns/mojo_host_struct_traits.h
@@ -0,0 +1,74 @@
+// 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.
+
+#ifndef NET_DNS_MOJO_HOST_STRUCT_TRAITS_H_
+#define NET_DNS_MOJO_HOST_STRUCT_TRAITS_H_
+
+#include "base/strings/string_piece.h"
+#include "mojo/public/cpp/bindings/enum_traits.h"
+#include "mojo/public/cpp/bindings/struct_traits.h"
+#include "net/dns/host_resolver.h"
+#include "net/interfaces/host_resolver_service.mojom.h"
+
+namespace mojo {
+
+template <>
+struct EnumTraits<net::interfaces::AddressFamily, net::AddressFamily> {
+  static net::interfaces::AddressFamily ToMojom(
+      net::AddressFamily address_family);
+  static bool FromMojom(net::interfaces::AddressFamily address_family,
+                        net::AddressFamily* out);
+};
+
+template <>
+struct StructTraits<net::interfaces::HostResolverRequestInfoDataView,
+                    std::unique_ptr<net::HostResolver::RequestInfo>> {
+  static base::StringPiece host(
+      const std::unique_ptr<net::HostResolver::RequestInfo>& obj) {
+    return obj->hostname();
+  }
+
+  static uint16_t port(
+      const std::unique_ptr<net::HostResolver::RequestInfo>& obj) {
+    return obj->port();
+  }
+
+  static net::AddressFamily address_family(
+      const std::unique_ptr<net::HostResolver::RequestInfo>& obj) {
+    return obj->address_family();
+  }
+
+  static bool is_my_ip_address(
+      const std::unique_ptr<net::HostResolver::RequestInfo>& obj) {
+    return obj->is_my_ip_address();
+  }
+
+  static bool Read(net::interfaces::HostResolverRequestInfoDataView obj,
+                   std::unique_ptr<net::HostResolver::RequestInfo>* output);
+};
+
+template <>
+struct StructTraits<net::interfaces::IPEndPointDataView, net::IPEndPoint> {
+  static const std::vector<uint8_t>& address(const net::IPEndPoint& obj) {
+    return obj.address().bytes();
+  }
+  static uint16_t port(const net::IPEndPoint& obj) { return obj.port(); }
+
+  static bool Read(net::interfaces::IPEndPointDataView obj,
+                   net::IPEndPoint* out);
+};
+
+template <>
+struct StructTraits<net::interfaces::AddressListDataView, net::AddressList> {
+  static std::vector<net::IPEndPoint> addresses(const net::AddressList& obj) {
+    return obj.endpoints();
+  }
+
+  static bool Read(net::interfaces::AddressListDataView data,
+                   net::AddressList* out);
+};
+
+}  // namespace mojo
+
+#endif  // NET_DNS_MOJO_HOST_STRUCT_TRAITS_H_
diff --git a/chromium/net/dns/mojo_host_type_converters.cc b/chromium/net/dns/mojo_host_type_converters.cc
deleted file mode 100644
index 760ee3ba164..00000000000
--- a/chromium/net/dns/mojo_host_type_converters.cc
+++ /dev/null
@@ -1,98 +0,0 @@
-// 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.
-
-#include "net/dns/mojo_host_type_converters.h"
-
-#include <utility>
-
-#include "mojo/public/cpp/bindings/type_converter.h"
-#include "net/base/address_list.h"
-
-namespace net {
-namespace {
-
-AddressFamily AddressFamilyFromMojo(interfaces::AddressFamily address_family) {
-  switch (address_family) {
-    case interfaces::AddressFamily::UNSPECIFIED:
-      return ADDRESS_FAMILY_UNSPECIFIED;
-    case interfaces::AddressFamily::IPV4:
-      return ADDRESS_FAMILY_IPV4;
-    case interfaces::AddressFamily::IPV6:
-      return ADDRESS_FAMILY_IPV6;
-  }
-  NOTREACHED();
-  return ADDRESS_FAMILY_UNSPECIFIED;
-}
-
-interfaces::AddressFamily AddressFamilyToMojo(AddressFamily address_family) {
-  switch (address_family) {
-    case ADDRESS_FAMILY_UNSPECIFIED:
-      return interfaces::AddressFamily::UNSPECIFIED;
-    case ADDRESS_FAMILY_IPV4:
-      return interfaces::AddressFamily::IPV4;
-    case ADDRESS_FAMILY_IPV6:
-      return interfaces::AddressFamily::IPV6;
-  }
-  NOTREACHED();
-  return interfaces::AddressFamily::UNSPECIFIED;
-}
-
-}  // namespace
-}  // namespace net
-
-namespace mojo {
-
-// static
-net::HostResolver::RequestInfo
-TypeConverter<net::HostResolver::RequestInfo,
-              net::interfaces::HostResolverRequestInfo>::
-    Convert(const net::interfaces::HostResolverRequestInfo& obj) {
-  net::HostResolver::RequestInfo result(net::HostPortPair(obj.host, obj.port));
-  result.set_address_family(net::AddressFamilyFromMojo(obj.address_family));
-  result.set_is_my_ip_address(obj.is_my_ip_address);
-  return result;
-}
-
-// static
-net::interfaces::HostResolverRequestInfoPtr
-TypeConverter<net::interfaces::HostResolverRequestInfoPtr,
-              net::HostResolver::RequestInfo>::
-    Convert(const net::HostResolver::RequestInfo& obj) {
-  net::interfaces::HostResolverRequestInfoPtr result(
-      net::interfaces::HostResolverRequestInfo::New());
-  result->host = obj.hostname();
-  result->port = obj.port();
-  result->address_family = net::AddressFamilyToMojo(obj.address_family());
-  result->is_my_ip_address = obj.is_my_ip_address();
-  return result;
-}
-
-// static
-net::interfaces::AddressListPtr
-TypeConverter<net::interfaces::AddressListPtr, net::AddressList>::Convert(
-    const net::AddressList& obj) {
-  net::interfaces::AddressListPtr result(net::interfaces::AddressList::New());
-  for (const auto& endpoint : obj) {
-    net::interfaces::IPEndPointPtr ep(net::interfaces::IPEndPoint::New());
-    ep->port = endpoint.port();
-    ep->address = mojo::Array<uint8_t>::From(endpoint.address().bytes());
-    result->addresses.push_back(std::move(ep));
-  }
-  return result;
-}
-
-// static
-net::AddressList
-TypeConverter<net::AddressList, net::interfaces::AddressList>::Convert(
-    const net::interfaces::AddressList& obj) {
-  net::AddressList address_list;
-  for (size_t i = 0; i < obj.addresses.size(); i++) {
-    const net::interfaces::IPEndPointPtr& ep = obj.addresses[i];
-    net::IPAddress ip_address(ep->address.To<std::vector<uint8_t>>());
-    address_list.push_back(net::IPEndPoint(ip_address, ep->port));
-  }
-  return address_list;
-}
-
-}  // namespace mojo
diff --git a/chromium/net/dns/mojo_host_type_converters.h b/chromium/net/dns/mojo_host_type_converters.h
deleted file mode 100644
index 8889b3fb5fd..00000000000
--- a/chromium/net/dns/mojo_host_type_converters.h
+++ /dev/null
@@ -1,39 +0,0 @@
-// 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.
-
-#ifndef NET_DNS_MOJO_HOST_TYPE_CONVERTERS_H_
-#define NET_DNS_MOJO_HOST_TYPE_CONVERTERS_H_
-
-#include "net/dns/host_resolver.h"
-#include "net/interfaces/host_resolver_service.mojom.h"
-
-namespace mojo {
-
-template <>
-struct TypeConverter<net::HostResolver::RequestInfo,
-                     net::interfaces::HostResolverRequestInfo> {
-  static net::HostResolver::RequestInfo Convert(
-      const net::interfaces::HostResolverRequestInfo& obj);
-};
-
-template <>
-struct TypeConverter<net::interfaces::HostResolverRequestInfoPtr,
-                     net::HostResolver::RequestInfo> {
-  static net::interfaces::HostResolverRequestInfoPtr Convert(
-      const net::HostResolver::RequestInfo& obj);
-};
-
-template <>
-struct TypeConverter<net::interfaces::AddressListPtr, net::AddressList> {
-  static net::interfaces::AddressListPtr Convert(const net::AddressList& obj);
-};
-
-template <>
-struct TypeConverter<net::AddressList, net::interfaces::AddressList> {
-  static net::AddressList Convert(const net::interfaces::AddressList& obj);
-};
-
-}  // namespace mojo
-
-#endif  // NET_DNS_MOJO_HOST_TYPE_CONVERTERS_H_