Change the mojo ProxyResolver to use ProxyResolverV8Tracing.

This allows a much simpler implementation of GetLoadState and forwarding
errors to a ProxyResolverErrorObserver as well as enabling a
straightforward implementation of NetLog event reporting.

BUG=467832

Review URL: https://codereview.chromium.org/1166523003

Cr-Commit-Position: refs/heads/master@{#337993}

1 files changed, 9 insertions, 44 deletions

diff --git a/net/dns/host_resolver_mojo_unittest.cc b/net/dns/host_resolver_mojo_unittest.cc
index 774c945..209bda8 100644
--- a/net/dns/host_resolver_mojo_unittest.cc
+++ b/net/dns/host_resolver_mojo_unittest.cc
@@ -83,11 +83,10 @@ struct HostResolverAction {
   Error error = OK;
 };
 
-class MockMojoHostResolver : public interfaces::HostResolver {
+class MockMojoHostResolver : public HostResolverMojo::Impl {
  public:
-  MockMojoHostResolver(mojo::InterfaceRequest<interfaces::HostResolver> request,
-                       const base::Closure& resolver_connection_error_callback,
-                       const base::Closure& request_connection_error_callback);
+  explicit MockMojoHostResolver(
+      const base::Closure& request_connection_error_callback);
   ~MockMojoHostResolver() override;
 
   void AddAction(scoped_ptr<HostResolverAction> action);
@@ -96,46 +95,31 @@ class MockMojoHostResolver : public interfaces::HostResolver {
     return requests_received_;
   }
 
- private:
-  // interfaces::HostResolver override.
-  void Resolve(interfaces::HostResolverRequestInfoPtr request_info,
-               interfaces::HostResolverRequestClientPtr client) override;
-
-  void OnConnectionError();
+  void ResolveDns(interfaces::HostResolverRequestInfoPtr request_info,
+                  interfaces::HostResolverRequestClientPtr client) override;
 
-  mojo::Binding<interfaces::HostResolver> binding_;
+ private:
   ScopedVector<HostResolverAction> actions_;
   size_t results_returned_ = 0;
   mojo::Array<interfaces::HostResolverRequestInfoPtr> requests_received_;
-  const base::Closure resolver_connection_error_callback_;
   const base::Closure request_connection_error_callback_;
   ScopedVector<MockMojoHostResolverRequest> requests_;
 };
 
 MockMojoHostResolver::MockMojoHostResolver(
-    mojo::InterfaceRequest<interfaces::HostResolver> request,
-    const base::Closure& resolver_connection_error_callback,
     const base::Closure& request_connection_error_callback)
-    : binding_(this, request.Pass()),
-      resolver_connection_error_callback_(resolver_connection_error_callback),
-      request_connection_error_callback_(request_connection_error_callback) {
-  binding_.set_connection_error_handler(base::Bind(
-      &MockMojoHostResolver::OnConnectionError, base::Unretained(this)));
+    : request_connection_error_callback_(request_connection_error_callback) {
 }
 
 MockMojoHostResolver::~MockMojoHostResolver() {
   EXPECT_EQ(results_returned_, actions_.size());
 }
 
-void MockMojoHostResolver::OnConnectionError() {
-  resolver_connection_error_callback_.Run();
-}
-
 void MockMojoHostResolver::AddAction(scoped_ptr<HostResolverAction> action) {
   actions_.push_back(action.Pass());
 }
 
-void MockMojoHostResolver::Resolve(
+void MockMojoHostResolver::ResolveDns(
     interfaces::HostResolverRequestInfoPtr request_info,
     interfaces::HostResolverRequestClientPtr client) {
   requests_received_.push_back(request_info.Pass());
@@ -161,24 +145,15 @@ void MockMojoHostResolver::Resolve(
 class HostResolverMojoTest : public testing::Test {
  protected:
   enum class ConnectionErrorSource {
-    RESOLVER,
     REQUEST,
-    CLIENT,
   };
   using Waiter = EventWaiter<ConnectionErrorSource>;
 
   void SetUp() override {
-    interfaces::HostResolverPtr resolver_ptr;
     mock_resolver_.reset(new MockMojoHostResolver(
-        mojo::GetProxy(&resolver_ptr),
-        base::Bind(&Waiter::NotifyEvent, base::Unretained(&waiter_),
-                   ConnectionErrorSource::RESOLVER),
         base::Bind(&Waiter::NotifyEvent, base::Unretained(&waiter_),
                    ConnectionErrorSource::REQUEST)));
-    resolver_.reset(new HostResolverMojo(
-        resolver_ptr.Pass(),
-        base::Bind(&Waiter::NotifyEvent, base::Unretained(&waiter_),
-                   ConnectionErrorSource::CLIENT)));
+    resolver_.reset(new HostResolverMojo(mock_resolver_.get()));
   }
 
   int Resolve(const HostResolver::RequestInfo& request_info,
@@ -373,16 +348,6 @@ TEST_F(HostResolverMojoTest, ImplDropsClientConnection) {
   EXPECT_FALSE(request.is_my_ip_address);
 }
 
-TEST_F(HostResolverMojoTest, DestroyImpl) {
-  mock_resolver_.reset();
-  waiter_.WaitForEvent(ConnectionErrorSource::CLIENT);
-}
-
-TEST_F(HostResolverMojoTest, DestroyClient) {
-  resolver_.reset();
-  waiter_.WaitForEvent(ConnectionErrorSource::RESOLVER);
-}
-
 TEST_F(HostResolverMojoTest, ResolveFromCache_Miss) {
   HostResolver::RequestInfo request_info(
       HostPortPair::FromString("example.com:8080"));