Replace //net TypeConverters with StructTraits.

net/proxy/proxy_resolver_factory_mojo_unittest.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/proxy_resolver_factory_mojo.h"
 
 #include <list>
 #include <map>
 #include <memory>
 #include <queue>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "net/base/load_states.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/dns/host_resolver.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"
 #include "net/proxy/proxy_resolver_script_data.h"
 #include "net/test/event_waiter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace net {
 
@@ skipping 73 matching lines @@
     DROP,
     // Disconnect the service.
     DISCONNECT,
     // Wait for the client pipe to be disconnected.
     WAIT_FOR_CLIENT_DISCONNECT,
     // Make a DNS request.
     MAKE_DNS_REQUEST,
   };
 
   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;
     result.expected_url = url;
     result.error = error;
     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;
   }
 
   static GetProxyForUrlAction DropRequest(const GURL& url) {
     GetProxyForUrlAction result;
     result.expected_url = url;
     result.action = DROP;
     return result;
   }
 
@@ skipping 13 matching lines @@
 
   static GetProxyForUrlAction MakeDnsRequest(const GURL& url) {
     GetProxyForUrlAction result;
     result.expected_url = url;
     result.action = MAKE_DNS_REQUEST;
     return result;
   }
 
   Action action = COMPLETE;
   Error error = OK;
-  mojo::Array<interfaces::ProxyServerPtr> proxy_servers;
+  ProxyInfo proxy_info;
   GURL expected_url;
 };
 
 class MockMojoProxyResolver : public interfaces::ProxyResolver {
  public:
   MockMojoProxyResolver();
   ~MockMojoProxyResolver() override;
 
   void AddGetProxyAction(GetProxyForUrlAction action);
 
@@ skipping 62 matching lines @@
     interfaces::ProxyResolverRequestClientPtr client) {
   ASSERT_FALSE(get_proxy_actions_.empty());
   GetProxyForUrlAction action = get_proxy_actions_.front();
   get_proxy_actions_.pop();
 
   EXPECT_EQ(action.expected_url, url);
   client->Alert(url.spec());
   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: {
       client.reset();
       break;
     }
     case GetProxyForUrlAction::DISCONNECT: {
       binding_.Close();
       break;
     }
     case GetProxyForUrlAction::WAIT_FOR_CLIENT_DISCONNECT: {
       ASSERT_FALSE(client.WaitForIncomingResponse());
       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));
       blocked_clients_.push_back(base::WrapUnique(
           new interfaces::ProxyResolverRequestClientPtr(std::move(client))));
       break;
     }
   }
   WakeWaiter();
 }
@@ skipping 139 matching lines @@
     }
     case CreateProxyResolverAction::DROP_BOTH: {
       // Both |request| and |client| will be closed.
       break;
     }
     case CreateProxyResolverAction::WAIT_FOR_CLIENT_DISCONNECT: {
       ASSERT_FALSE(client.WaitForIncomingResponse());
       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));
       blocked_clients_.push_back(
           base::WrapUnique(new interfaces::ProxyResolverFactoryRequestClientPtr(
               std::move(client))));
       break;
     }
   }
   WakeWaiter();
@@ skipping 76 matching lines @@
 
   std::unique_ptr<base::ScopedClosureRunner> CreateResolver(
       const mojo::String& pac_script,
       mojo::InterfaceRequest<interfaces::ProxyResolver> req,
       interfaces::ProxyResolverFactoryRequestClientPtr client) override {
     factory_ptr_->CreateResolver(pac_script, std::move(req), std::move(client));
     return base::WrapUnique(
         new base::ScopedClosureRunner(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() {
     mock_proxy_resolver_factory_->AddCreateProxyResolverAction(
         CreateProxyResolverAction::ReturnResult(kScriptData, OK));
     TestCompletionCallback callback;
     scoped_refptr<ProxyResolverScriptData> pac_script(
         ProxyResolverScriptData::FromUTF8(kScriptData));
     std::unique_ptr<ProxyResolverFactory::Request> request;
     ASSERT_EQ(
@@ skipping 337 matching lines @@
   mock_proxy_resolver_.ClearBlockedClients();
   request->WaitForResult();
 }
 
 TEST_F(ProxyResolverFactoryMojoTest, DeleteResolver) {
   CreateProxyResolver();
   proxy_resolver_mojo_.reset();
   on_delete_callback_.WaitForResult();
 }
 }  // namespace net