Replace //net TypeConverters with StructTraits.

BUG=621383

Review-Url: https://codereview.chromium.org/2083463002
Cr-Commit-Position: refs/heads/master@{#424110}

mojo/public/cpp/bindings/BUILD.gn

@@ -39,7 +39,6 @@ component("bindings") {
     "bindings_export.h",
     "connection_error_callback.h",
     "connector.h",
-    "enum_traits.h",
     "filter_chain.h",
     "interface_data_view.h",
     "interface_endpoint_client.h",
@@ -166,6 +165,7 @@ component("bindings") {
 
 source_set("struct_traits") {
   sources = [
+    "enum_traits.h",
     "struct_traits.h",
   ]
 }

mojo/public/tools/bindings/chromium_bindings_configuration.gni

@@ -18,6 +18,7 @@ _typemap_imports = [
   "//media/mojo/interfaces/typemaps.gni",
   "//mojo/common/typemaps.gni",
   "//mojo/public/cpp/bindings/tests/chromium_typemaps.gni",
+  "//net/interfaces/typemaps.gni",
   "//services/shell/public/cpp/typemaps.gni",
   "//services/ui/public/interfaces/display/typemaps.gni",
   "//services/video_capture/public/interfaces/typemaps.gni",

net/BUILD.gn

@@ -738,7 +738,6 @@ if (use_v8_in_net && !is_android) {
     ]
 
     public_deps = [
-      ":mojo_type_converters",
       ":net_with_v8",
       "//base",
       "//mojo/common",
@@ -753,22 +752,6 @@ if (use_v8_in_net && !is_android) {
     ]
   }
 
-  source_set("mojo_type_converters") {
-    sources = [
-      "dns/mojo_host_type_converters.cc",
-      "dns/mojo_host_type_converters.h",
-      "proxy/mojo_proxy_type_converters.cc",
-      "proxy/mojo_proxy_type_converters.h",
-    ]
-
-    public_deps = [
-      ":net",
-      "//base",
-      "//mojo/public/cpp/bindings",
-      "//net/interfaces",
-    ]
-  }
-
   source_set("net_utility_services") {
     sources = [
       "dns/host_resolver_mojo.cc",
@@ -786,7 +769,6 @@ if (use_v8_in_net && !is_android) {
     ]
 
     public_deps = [
-      ":mojo_type_converters",
       ":net",
       "//mojo/common",
       "//mojo/public/cpp/bindings",

net/base/address_list.h

@@ -82,6 +82,9 @@ class NET_EXPORT AddressList {
   iterator end() { return endpoints_.end(); }
   const_iterator end() const { return endpoints_.end(); }
 
+  const std::vector<net::IPEndPoint>& endpoints() const { return endpoints_; }
+  std::vector<net::IPEndPoint>& endpoints() { return endpoints_; }
+
  private:
   std::vector<IPEndPoint> endpoints_;
   // TODO(szym): Remove. http://crbug.com/126134

net/dns/OWNERS

+per-file *_struct_traits*.*=set noparent
+per-file *_struct_traits*.*=file://ipc/SECURITY_OWNERS

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

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|.

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) {

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);
 }
 

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(); }

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();

net/dns/mojo_host_struct_traits.cc

+// 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

net/dns/mojo_host_struct_traits.h

+// 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_

net/dns/mojo_host_type_converters.cc

-// 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

net/dns/mojo_host_type_converters.h

-// 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_

net/interfaces/host_resolver.typemap

+# Copyright 2016 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.
+
+mojom = "//net/interfaces/host_resolver_service.mojom"
+public_headers = [ "//net/dns/host_resolver.h" ]
+traits_headers = [ "//net/dns/mojo_host_struct_traits.h" ]
+sources = [
+  "//net/dns/mojo_host_struct_traits.cc",
+]
+type_mappings = [
+  "net.interfaces.HostResolverRequestInfo=std::unique_ptr<net::HostResolver::RequestInfo>[move_only]",
+  "net.interfaces.AddressList=net::AddressList",
+  "net.interfaces.AddressFamily=net::AddressFamily",
+]
+public_deps = [
+  "//net",
+]

net/interfaces/host_resolver_service.mojom

@@ -42,5 +42,5 @@ struct AddressList {
 
 interface HostResolverRequestClient {
   // |error| is a value in net::Error.
-  ReportResult(int32 error, AddressList? result);
+  ReportResult(int32 error, AddressList result);
 };

net/interfaces/proxy_resolver.typemap

+# Copyright 2016 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.
+
+mojom = "//net/interfaces/proxy_resolver_service.mojom"
+public_headers = [
+  "//net/proxy/proxy_server.h",
+  "//net/proxy/proxy_info.h",
+]
+traits_headers = [ "//net/proxy/mojo_proxy_struct_traits.h" ]
+sources = [
+  "//net/proxy/mojo_proxy_struct_traits.cc",
+]
+type_mappings = [
+  "net.interfaces.ProxyInfo=net::ProxyInfo",
+  "net.interfaces.ProxyServer=net::ProxyServer",
+  "net.interfaces.ProxyServer::Scheme=net::ProxyScheme",
+]
+public_deps = [
+  "//net",
+]

net/interfaces/proxy_resolver_service.mojom

@@ -26,10 +26,14 @@ struct ProxyServer {
   ProxyScheme scheme;
 
   // |host| and |port| are only valid if |scheme| is not INVALID or DIRECT.
-  string? host;
+  string host;
   uint16 port;
 };
 
+struct ProxyInfo {
+  array<ProxyServer> proxy_servers;
+};
+
 interface ProxyResolver {
   // Use a ProxyResolverRequestClient instead of returning a result so we can
   // cancel in-flight requests by destroying the client.
@@ -37,7 +41,7 @@ interface ProxyResolver {
 };
 
 interface ProxyResolverRequestClient {
-  ReportResult(int32 error, array<ProxyServer>? proxy_servers);
+  ReportResult(int32 error, ProxyInfo proxy_info);
 
   Alert(string error);
   OnError(int32 line_number, string error);

net/interfaces/typemaps.gni

+# Copyright 2016 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.
+
+typemaps = [
+  "//net/interfaces/host_resolver.typemap",
+  "//net/interfaces/proxy_resolver.typemap",
+]

net/proxy/OWNERS

+per-file *_struct_traits*.*=set noparent
+per-file *_struct_traits*.*=file://ipc/SECURITY_OWNERS

net/proxy/mojo_proxy_resolver_factory_impl_unittest.cc

@@ -123,7 +123,7 @@ class MojoProxyResolverFactoryImplTest
 
   void OnError(int32_t line_number, const mojo::String& message) override {}
 
-  void ResolveDns(interfaces::HostResolverRequestInfoPtr request_info,
+  void ResolveDns(std::unique_ptr<HostResolver::RequestInfo> request_info,
                   interfaces::HostResolverRequestClientPtr client) override {}
 
  protected:

net/proxy/mojo_proxy_resolver_impl.cc

@@ -10,7 +10,6 @@
 #include "base/memory/ptr_util.h"
 #include "net/base/net_errors.h"
 #include "net/proxy/mojo_proxy_resolver_v8_tracing_bindings.h"
-#include "net/proxy/mojo_proxy_type_converters.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver_script_data.h"
 #include "net/proxy/proxy_resolver_v8_tracing.h"
@@ -100,12 +99,11 @@ void MojoProxyResolverImpl::Job::GetProxyDone(int error) {
   for (const auto& proxy : result_.proxy_list().GetAll()) {
     DVLOG(1) << proxy.ToURI();
   }
-  mojo::Array<interfaces::ProxyServerPtr> result;
-  if (error == OK) {
-    result = mojo::Array<interfaces::ProxyServerPtr>::From(
-        result_.proxy_list().GetAll());
-  }
-  client_->ReportResult(error, std::move(result));
+  if (error == OK)
+    client_->ReportResult(error, result_);
+  else
+    client_->ReportResult(error, ProxyInfo());
+
   resolver_->DeleteJob(this);
 }
 

net/proxy/mojo_proxy_resolver_impl_unittest.cc

@@ -12,7 +12,6 @@
 #include "mojo/public/cpp/bindings/binding.h"
 #include "net/base/net_errors.h"
 #include "net/proxy/mock_proxy_resolver.h"
-#include "net/proxy/mojo_proxy_type_converters.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver_v8_tracing.h"
 #include "net/proxy/proxy_server.h"
@@ -40,16 +39,15 @@ class TestRequestClient : public interfaces::ProxyResolverRequestClient {
   void WaitForResult();
 
   Error error() { return error_; }
-  const mojo::Array<interfaces::ProxyServerPtr>& results() { return results_; }
+  const ProxyInfo& results() { return results_; }
   EventWaiter<Event>& event_waiter() { return event_waiter_; }
 
  private:
   // interfaces::ProxyResolverRequestClient override.
-  void ReportResult(int32_t error,
-                    mojo::Array<interfaces::ProxyServerPtr> results) override;
+  void ReportResult(int32_t error, const ProxyInfo& results) override;
   void Alert(const mojo::String& message) override;
   void OnError(int32_t line_number, const mojo::String& message) override;
-  void ResolveDns(interfaces::HostResolverRequestInfoPtr request_info,
+  void ResolveDns(std::unique_ptr<HostResolver::RequestInfo> request_info,
                   interfaces::HostResolverRequestClientPtr client) override;
 
   // Mojo error handler.
@@ -57,7 +55,7 @@ class TestRequestClient : public interfaces::ProxyResolverRequestClient {
 
   bool done_ = false;
   Error error_ = ERR_FAILED;
-  mojo::Array<interfaces::ProxyServerPtr> results_;
+  ProxyInfo results_;
 
   mojo::Binding<interfaces::ProxyResolverRequestClient> binding_;
 
@@ -79,13 +77,11 @@ void TestRequestClient::WaitForResult() {
   ASSERT_TRUE(done_);
 }
 
-void TestRequestClient::ReportResult(
-    int32_t error,
-    mojo::Array<interfaces::ProxyServerPtr> results) {
+void TestRequestClient::ReportResult(int32_t error, const ProxyInfo& results) {
   event_waiter_.NotifyEvent(RESULT_RECEIVED);
   ASSERT_FALSE(done_);
   error_ = static_cast<Error>(error);
-  results_ = std::move(results);
+  results_ = results;
   done_ = true;
 }
 
@@ -97,9 +93,8 @@ void TestRequestClient::OnError(int32_t line_number,
 }
 
 void TestRequestClient::ResolveDns(
-    interfaces::HostResolverRequestInfoPtr request_info,
-    interfaces::HostResolverRequestClientPtr client) {
-}
+    std::unique_ptr<HostResolver::RequestInfo> request_info,
+    interfaces::HostResolverRequestClientPtr client) {}
 
 void TestRequestClient::OnConnectionError() {
   event_waiter_.NotifyEvent(CONNECTION_ERROR);
@@ -214,8 +209,7 @@ TEST_F(MojoProxyResolverImplTest, GetProxyForUrl) {
   client.WaitForResult();
 
   EXPECT_THAT(client.error(), IsOk());
-  std::vector<ProxyServer> servers =
-      client.results().To<std::vector<ProxyServer>>();
+  std::vector<ProxyServer> servers = client.results().proxy_list().GetAll();
   ASSERT_EQ(6u, servers.size());
   EXPECT_EQ(ProxyServer::SCHEME_HTTP, servers[0].scheme());
   EXPECT_EQ("proxy.example.com", servers[0].host_port_pair().host());
@@ -254,7 +248,7 @@ TEST_F(MojoProxyResolverImplTest, GetProxyForUrlFailure) {
 
   EXPECT_THAT(client.error(), IsError(ERR_FAILED));
   std::vector<ProxyServer> proxy_servers =
-      client.results().To<std::vector<ProxyServer>>();
+      client.results().proxy_list().GetAll();
   EXPECT_TRUE(proxy_servers.empty());
 }
 
@@ -283,7 +277,7 @@ TEST_F(MojoProxyResolverImplTest, GetProxyForUrlMultiple) {
 
   EXPECT_THAT(client1.error(), IsOk());
   std::vector<ProxyServer> proxy_servers1 =
-      client1.results().To<std::vector<ProxyServer>>();
+      client1.results().proxy_list().GetAll();
   ASSERT_EQ(1u, proxy_servers1.size());
   ProxyServer& server1 = proxy_servers1[0];
   EXPECT_EQ(ProxyServer::SCHEME_HTTPS, server1.scheme());
@@ -292,7 +286,7 @@ TEST_F(MojoProxyResolverImplTest, GetProxyForUrlMultiple) {
 
   EXPECT_THAT(client2.error(), IsOk());
   std::vector<ProxyServer> proxy_servers2 =
-      client2.results().To<std::vector<ProxyServer>>();
+      client2.results().proxy_list().GetAll();
   ASSERT_EQ(1u, proxy_servers1.size());
   ProxyServer& server2 = proxy_servers2[0];
   EXPECT_EQ(ProxyServer::SCHEME_SOCKS5, server2.scheme());

net/proxy/mojo_proxy_resolver_v8_tracing_bindings.h

@@ -55,7 +55,7 @@ class MojoProxyResolverV8TracingBindings
 
  private:
   // HostResolverMojo::Impl override.
-  void ResolveDns(interfaces::HostResolverRequestInfoPtr request_info,
+  void ResolveDns(std::unique_ptr<HostResolver::RequestInfo> request_info,
                   interfaces::HostResolverRequestClientPtr client) {
     DCHECK(thread_checker_.CalledOnValidThread());
     client_->ResolveDns(std::move(request_info), std::move(client));

net/proxy/mojo_proxy_resolver_v8_tracing_bindings_unittest.cc

@@ -31,7 +31,7 @@ class MojoProxyResolverV8TracingBindingsTest : public testing::Test {
     errors_.push_back(std::make_pair(line_number, message.To<std::string>()));
   }
 
-  void ResolveDns(interfaces::HostResolverRequestInfoPtr request_info,
+  void ResolveDns(std::unique_ptr<HostResolver::RequestInfo> request_info,
                   interfaces::HostResolverRequestClientPtr client) {}
 
  protected:

net/proxy/mojo_proxy_struct_traits.cc

+// 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/proxy/mojo_proxy_struct_traits.h"
+
+#include "base/logging.h"
+#include "net/base/host_port_pair.h"
+#include "net/proxy/proxy_info.h"
+#include "net/proxy/proxy_server.h"
+
+namespace mojo {
+
+net::interfaces::ProxyScheme
+EnumTraits<net::interfaces::ProxyScheme, net::ProxyServer::Scheme>::ToMojom(
+    net::ProxyServer::Scheme scheme) {
+  using net::ProxyServer;
+  switch (scheme) {
+    case ProxyServer::SCHEME_INVALID:
+      return net::interfaces::ProxyScheme::INVALID;
+    case ProxyServer::SCHEME_DIRECT:
+      return net::interfaces::ProxyScheme::DIRECT;
+    case ProxyServer::SCHEME_HTTP:
+      return net::interfaces::ProxyScheme::HTTP;
+    case ProxyServer::SCHEME_SOCKS4:
+      return net::interfaces::ProxyScheme::SOCKS4;
+    case ProxyServer::SCHEME_SOCKS5:
+      return net::interfaces::ProxyScheme::SOCKS5;
+    case ProxyServer::SCHEME_HTTPS:
+      return net::interfaces::ProxyScheme::HTTPS;
+    case ProxyServer::SCHEME_QUIC:
+      return net::interfaces::ProxyScheme::QUIC;
+  }
+  NOTREACHED();
+  return net::interfaces::ProxyScheme::INVALID;
+}
+
+bool EnumTraits<net::interfaces::ProxyScheme, net::ProxyServer::Scheme>::
+    FromMojom(net::interfaces::ProxyScheme scheme,
+              net::ProxyServer::Scheme* out) {
+  using net::ProxyServer;
+  switch (scheme) {
+    case net::interfaces::ProxyScheme::INVALID:
+      *out = ProxyServer::SCHEME_INVALID;
+      return true;
+    case net::interfaces::ProxyScheme::DIRECT:
+      *out = ProxyServer::SCHEME_DIRECT;
+      return true;
+    case net::interfaces::ProxyScheme::HTTP:
+      *out = ProxyServer::SCHEME_HTTP;
+      return true;
+    case net::interfaces::ProxyScheme::SOCKS4:
+      *out = ProxyServer::SCHEME_SOCKS4;
+      return true;
+    case net::interfaces::ProxyScheme::SOCKS5:
+      *out = ProxyServer::SCHEME_SOCKS5;
+      return true;
+    case net::interfaces::ProxyScheme::HTTPS:
+      *out = ProxyServer::SCHEME_HTTPS;
+      return true;
+    case net::interfaces::ProxyScheme::QUIC:
+      *out = ProxyServer::SCHEME_QUIC;
+      return true;
+  }
+  return false;
+}
+
+base::StringPiece
+StructTraits<net::interfaces::ProxyServerDataView, net::ProxyServer>::host(
+    const net::ProxyServer& s) {
+  if (s.scheme() == net::ProxyServer::SCHEME_DIRECT ||
+      s.scheme() == net::ProxyServer::SCHEME_INVALID) {
+    return base::StringPiece();
+  }
+  return s.host_port_pair().host();
+}
+
+uint16_t StructTraits<net::interfaces::ProxyServerDataView,
+                      net::ProxyServer>::port(const net::ProxyServer& s) {
+  if (s.scheme() == net::ProxyServer::SCHEME_DIRECT ||
+      s.scheme() == net::ProxyServer::SCHEME_INVALID) {
+    return 0;
+  }
+  return s.host_port_pair().port();
+}
+
+bool StructTraits<net::interfaces::ProxyServerDataView, net::ProxyServer>::Read(
+    net::interfaces::ProxyServerDataView data,
+    net::ProxyServer* out) {
+  net::ProxyServer::Scheme scheme;
+  if (!data.ReadScheme(&scheme))
+    return false;
+
+  base::StringPiece host;
+  if (!data.ReadHost(&host))
+    return false;
+
+  if ((scheme == net::ProxyServer::SCHEME_DIRECT ||
+       scheme == net::ProxyServer::SCHEME_INVALID) &&
+      (!host.empty() || data.port())) {
+    return false;
+  }
+
+  *out = net::ProxyServer(scheme,
+                          net::HostPortPair(host.as_string(), data.port()));
+  return true;
+}
+
+bool StructTraits<net::interfaces::ProxyInfoDataView, net::ProxyInfo>::Read(
+    net::interfaces::ProxyInfoDataView data,
+    net::ProxyInfo* out) {
+  std::vector<net::ProxyServer> proxy_servers;
+  if (!data.ReadProxyServers(&proxy_servers))
+    return false;
+
+  net::ProxyList proxy_list;
+  for (const auto& server : proxy_servers)
+    proxy_list.AddProxyServer(server);
+
+  out->UseProxyList(proxy_list);
+  return true;
+}
+
+}  // namespace mojo

net/proxy/mojo_proxy_struct_traits.h

+// 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_PROXY_MOJO_PROXY_STRUCT_TRAITS_H_
+#define NET_PROXY_MOJO_PROXY_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/base/host_port_pair.h"
+#include "net/interfaces/proxy_resolver_service.mojom.h"
+#include "net/proxy/proxy_info.h"
+#include "net/proxy/proxy_list.h"
+#include "net/proxy/proxy_server.h"
+
+namespace net {
+class ProxyInfo;
+class ProxyServer;
+}
+
+namespace mojo {
+
+template <>
+struct EnumTraits<net::interfaces::ProxyScheme, net::ProxyServer::Scheme> {
+  static net::interfaces::ProxyScheme ToMojom(net::ProxyServer::Scheme scheme);
+  static bool FromMojom(net::interfaces::ProxyScheme scheme,
+                        net::ProxyServer::Scheme* out);
+};
+
+template <>
+struct StructTraits<net::interfaces::ProxyServerDataView, net::ProxyServer> {
+  static net::ProxyServer::Scheme scheme(const net::ProxyServer& s) {
+    return s.scheme();
+  }
+
+  static base::StringPiece host(const net::ProxyServer& s);
+  static uint16_t port(const net::ProxyServer& s);
+
+  static bool Read(net::interfaces::ProxyServerDataView data,
+                   net::ProxyServer* out);
+};
+
+template <>
+struct StructTraits<net::interfaces::ProxyInfoDataView, net::ProxyInfo> {
+  static const std::vector<net::ProxyServer>& proxy_servers(
+      const net::ProxyInfo& info) {
+    return info.proxy_list().GetAll();
+  }
+
+  static bool Read(net::interfaces::ProxyInfoDataView data,
+                   net::ProxyInfo* out);
+};
+
+}  // namespace mojo
+
+#endif  // NET_PROXY_MOJO_PROXY_STRUCT_TRAITS_H_

net/proxy/mojo_proxy_type_converters.cc

-// 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/proxy/mojo_proxy_type_converters.h"
-
-#include "base/logging.h"
-#include "net/base/host_port_pair.h"
-#include "net/proxy/proxy_info.h"
-#include "net/proxy/proxy_server.h"
-
-namespace net {
-namespace {
-
-interfaces::ProxyScheme ProxySchemeToMojo(ProxyServer::Scheme scheme) {
-  switch (scheme) {
-    case ProxyServer::SCHEME_INVALID:
-      return interfaces::ProxyScheme::INVALID;
-    case ProxyServer::SCHEME_DIRECT:
-      return interfaces::ProxyScheme::DIRECT;
-    case ProxyServer::SCHEME_HTTP:
-      return interfaces::ProxyScheme::HTTP;
-    case ProxyServer::SCHEME_SOCKS4:
-      return interfaces::ProxyScheme::SOCKS4;
-    case ProxyServer::SCHEME_SOCKS5:
-      return interfaces::ProxyScheme::SOCKS5;
-    case ProxyServer::SCHEME_HTTPS:
-      return interfaces::ProxyScheme::HTTPS;
-    case ProxyServer::SCHEME_QUIC:
-      return interfaces::ProxyScheme::QUIC;
-  }
-  NOTREACHED();
-  return interfaces::ProxyScheme::INVALID;
-}
-
-ProxyServer::Scheme ProxySchemeFromMojo(interfaces::ProxyScheme scheme) {
-  switch (scheme) {
-    case interfaces::ProxyScheme::INVALID:
-      return ProxyServer::SCHEME_INVALID;
-    case interfaces::ProxyScheme::DIRECT:
-      return ProxyServer::SCHEME_DIRECT;
-    case interfaces::ProxyScheme::HTTP:
-      return ProxyServer::SCHEME_HTTP;
-    case interfaces::ProxyScheme::SOCKS4:
-      return ProxyServer::SCHEME_SOCKS4;
-    case interfaces::ProxyScheme::SOCKS5:
-      return ProxyServer::SCHEME_SOCKS5;
-    case interfaces::ProxyScheme::HTTPS:
-      return ProxyServer::SCHEME_HTTPS;
-    case interfaces::ProxyScheme::QUIC:
-      return ProxyServer::SCHEME_QUIC;
-  }
-  NOTREACHED();
-  return ProxyServer::SCHEME_INVALID;
-}
-
-}  // namespace
-}  // namespace net
-
-namespace mojo {
-
-// static
-net::interfaces::ProxyServerPtr
-TypeConverter<net::interfaces::ProxyServerPtr, net::ProxyServer>::Convert(
-    const net::ProxyServer& obj) {
-  net::interfaces::ProxyServerPtr server(net::interfaces::ProxyServer::New());
-  server->scheme = net::ProxySchemeToMojo(obj.scheme());
-  if (server->scheme != net::interfaces::ProxyScheme::DIRECT &&
-      server->scheme != net::interfaces::ProxyScheme::INVALID) {
-    server->host = obj.host_port_pair().host();
-    server->port = obj.host_port_pair().port();
-  }
-  return server;
-}
-
-// static
-net::ProxyServer
-TypeConverter<net::ProxyServer, net::interfaces::ProxyServerPtr>::Convert(
-    const net::interfaces::ProxyServerPtr& obj) {
-  return net::ProxyServer(net::ProxySchemeFromMojo(obj->scheme),
-                          net::HostPortPair(obj->host, obj->port));
-}
-
-// static
-net::ProxyInfo
-TypeConverter<net::ProxyInfo, mojo::Array<net::interfaces::ProxyServerPtr>>::
-    Convert(const mojo::Array<net::interfaces::ProxyServerPtr>& obj) {
-  net::ProxyList proxy_list;
-  for (size_t i = 0; i < obj.size(); i++) {
-    proxy_list.AddProxyServer(obj[i].To<net::ProxyServer>());
-  }
-  net::ProxyInfo info;
-  info.UseProxyList(proxy_list);
-  return info;
-}
-
-}  // namespace mojo

net/proxy/mojo_proxy_type_converters.h

-// 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_PROXY_MOJO_PROXY_TYPE_CONVERTERS_H_
-#define NET_PROXY_MOJO_PROXY_TYPE_CONVERTERS_H_
-
-#include "mojo/public/cpp/bindings/type_converter.h"
-#include "net/interfaces/proxy_resolver_service.mojom.h"
-
-namespace net {
-class ProxyInfo;
-class ProxyServer;
-}
-
-namespace mojo {
-
-template <>
-struct TypeConverter<net::interfaces::ProxyServerPtr, net::ProxyServer> {
-  static net::interfaces::ProxyServerPtr Convert(const net::ProxyServer& obj);
-};
-
-template <>
-struct TypeConverter<net::ProxyServer, net::interfaces::ProxyServerPtr> {
-  static net::ProxyServer Convert(const net::interfaces::ProxyServerPtr& obj);
-};
-
-template <>
-struct TypeConverter<net::ProxyInfo,
-                     mojo::Array<net::interfaces::ProxyServerPtr>> {
-  static net::ProxyInfo Convert(
-      const mojo::Array<net::interfaces::ProxyServerPtr>& obj);
-};
-
-}  // namespace mojo
-
-#endif  // NET_PROXY_MOJO_PROXY_TYPE_CONVERTERS_H_

net/proxy/proxy_resolver_factory_mojo.cc

@@ -26,7 +26,6 @@
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_with_source.h"
 #include "net/proxy/mojo_proxy_resolver_factory.h"
-#include "net/proxy/mojo_proxy_type_converters.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver.h"
 #include "net/proxy/proxy_resolver_error_observer.h"
@@ -82,7 +81,7 @@ class ClientMixin : public ClientInterface {
       error_observer_->OnPACScriptError(line_number, message_str);
   }
 
-  void ResolveDns(interfaces::HostResolverRequestInfoPtr request_info,
+  void ResolveDns(std::unique_ptr<HostResolver::RequestInfo> request_info,
                   interfaces::HostResolverRequestClientPtr client) override {
     host_resolver_.Resolve(std::move(request_info), std::move(client));
   }
@@ -177,9 +176,7 @@ class ProxyResolverMojo::Job
   void OnConnectionError();
 
   // Overridden from interfaces::ProxyResolverRequestClient:
-  void ReportResult(
-      int32_t error,
-      mojo::Array<interfaces::ProxyServerPtr> proxy_servers) override;
+  void ReportResult(int32_t error, const net::ProxyInfo& proxy_info) override;
 
   ProxyResolverMojo* resolver_;
   const GURL url_;
@@ -234,14 +231,13 @@ void ProxyResolverMojo::Job::OnConnectionError() {
   resolver_->RemoveJob(this);
 }
 
-void ProxyResolverMojo::Job::ReportResult(
-    int32_t error,
-    mojo::Array<interfaces::ProxyServerPtr> proxy_servers) {
+void ProxyResolverMojo::Job::ReportResult(int32_t error,
+                                          const ProxyInfo& proxy_info) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "ProxyResolverMojo::Job::ReportResult: " << error;
 
   if (error == OK) {
-    *results_ = proxy_servers.To<ProxyInfo>();
+    *results_ = proxy_info;
     DVLOG(1) << "Servers: " << results_->ToPacString();
   }
 

net/proxy/proxy_resolver_factory_mojo_unittest.cc

@@ -28,7 +28,6 @@
 #include "net/log/net_log_with_source.h"
 #include "net/log/test_net_log.h"
 #include "net/proxy/mojo_proxy_resolver_factory.h"
-#include "net/proxy/mojo_proxy_type_converters.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver.h"
 #include "net/proxy/proxy_resolver_error_observer.h"
@@ -127,12 +126,7 @@ struct GetProxyForUrlAction {
   };
 
   GetProxyForUrlAction() {}
-  GetProxyForUrlAction(const GetProxyForUrlAction& old) {
-    action = old.action;
-    error = old.error;
-    expected_url = old.expected_url;
-    proxy_servers = old.proxy_servers.Clone();
-  }
+  GetProxyForUrlAction(const GetProxyForUrlAction& other) = default;
 
   static GetProxyForUrlAction ReturnError(const GURL& url, Error error) {
     GetProxyForUrlAction result;
@@ -141,12 +135,11 @@ struct GetProxyForUrlAction {
     return result;
   }
 
-  static GetProxyForUrlAction ReturnServers(
-      const GURL& url,
-      const mojo::Array<interfaces::ProxyServerPtr>& proxy_servers) {
+  static GetProxyForUrlAction ReturnServers(const GURL& url,
+                                            const ProxyInfo& proxy_info) {
     GetProxyForUrlAction result;
     result.expected_url = url;
-    result.proxy_servers = proxy_servers.Clone();
+    result.proxy_info = proxy_info;
     return result;
   }
 
@@ -180,7 +173,7 @@ struct GetProxyForUrlAction {
 
   Action action = COMPLETE;
   Error error = OK;
-  mojo::Array<interfaces::ProxyServerPtr> proxy_servers;
+  ProxyInfo proxy_info;
   GURL expected_url;
 };
 
@@ -263,7 +256,7 @@ void MockMojoProxyResolver::GetProxyForUrl(
   client->OnError(12345, url.spec());
   switch (action.action) {
     case GetProxyForUrlAction::COMPLETE: {
-      client->ReportResult(action.error, std::move(action.proxy_servers));
+      client->ReportResult(action.error, action.proxy_info);
       break;
     }
     case GetProxyForUrlAction::DROP: {
@@ -284,10 +277,8 @@ void MockMojoProxyResolver::GetProxyForUrl(
       break;
     }
     case GetProxyForUrlAction::MAKE_DNS_REQUEST: {
-      interfaces::HostResolverRequestInfoPtr request(
-          interfaces::HostResolverRequestInfo::New());
-      request->host = url.spec();
-      request->port = 12345;
+      auto request = base::MakeUnique<HostResolver::RequestInfo>(
+          HostPortPair(url.spec(), 12345));
       interfaces::HostResolverRequestClientPtr dns_client;
       mojo::GetProxy(&dns_client);
       client->ResolveDns(std::move(request), std::move(dns_client));
@@ -453,10 +444,8 @@ void MockMojoProxyResolverFactory::CreateResolver(
       break;
     }
     case CreateProxyResolverAction::MAKE_DNS_REQUEST: {
-      interfaces::HostResolverRequestInfoPtr request(
-          interfaces::HostResolverRequestInfo::New());
-      request->host = pac_script;
-      request->port = 12345;
+      auto request = base::MakeUnique<HostResolver::RequestInfo>(
+          HostPortPair(pac_script, 12345));
       interfaces::HostResolverRequestClientPtr dns_client;
       mojo::GetProxy(&dns_client);
       client->ResolveDns(std::move(request), std::move(dns_client));
@@ -554,13 +543,10 @@ class ProxyResolverFactoryMojoTest : public testing::Test,
         on_delete_callback_.closure());
   }
 
-  mojo::Array<interfaces::ProxyServerPtr> ProxyServersFromPacString(
-      const std::string& pac_string) {
+  ProxyInfo ProxyServersFromPacString(const std::string& pac_string) {
     ProxyInfo proxy_info;
     proxy_info.UsePacString(pac_string);
-
-    return mojo::Array<interfaces::ProxyServerPtr>::From(
-        proxy_info.proxy_list().GetAll());
+    return proxy_info;
   }
 
   void CreateProxyResolver() {