Merge ProxyResolverMojo::Job and ProxyResolverMojo::RequestImpl

net/proxy/proxy_resolver_factory_mojo.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 <set>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 111 matching lines @@
 
   // ProxyResolver implementation:
   int GetProxyForURL(const GURL& url,
                      ProxyInfo* results,
                      const net::CompletionCallback& callback,
                      std::unique_ptr<Request>* request,
                      const NetLogWithSource& net_log) override;
 
  private:
   class Job;
-  class RequestImpl;
 
   base::ThreadChecker thread_checker_;
 
   // Mojo error handler.
   void OnConnectionError();
 
   // Connection to the Mojo proxy resolver.
   interfaces::ProxyResolverPtr mojo_proxy_resolver_ptr_;
 
   HostResolver* host_resolver_;
 
   std::unique_ptr<ProxyResolverErrorObserver> error_observer_;
 
   NetLog* net_log_;
 
   std::unique_ptr<base::ScopedClosureRunner> on_delete_callback_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(ProxyResolverMojo);
 };
 
-class ProxyResolverMojo::RequestImpl : public ProxyResolver::Request {
- public:
-  explicit RequestImpl(std::unique_ptr<Job> job);
-
-  ~RequestImpl() override {}
-
-  LoadState GetLoadState() override;
-
- private:
-  std::unique_ptr<Job> job_;
-
-  DISALLOW_COPY_AND_ASSIGN(RequestImpl);
-};
-
 class ProxyResolverMojo::Job
-    : public ClientMixin<interfaces::ProxyResolverRequestClient> {
+    : public ProxyResolver::Request,
+      public ClientMixin<interfaces::ProxyResolverRequestClient> {
  public:
   Job(ProxyResolverMojo* resolver,
       const GURL& url,
       ProxyInfo* results,
       const CompletionCallback& callback,
       const NetLogWithSource& net_log);
   ~Job() override;
 
   // Returns the LoadState of this job.
-  LoadState GetLoadState();
+  LoadState GetLoadState() override;
 
  private:
   // Mojo error handler.
   void OnConnectionError();
 
   // Overridden from interfaces::ProxyResolverRequestClient:
   void ReportResult(int32_t error, const net::ProxyInfo& proxy_info) override;
 
   // Completes a request with a result code.
   void CompleteRequest(int result);
 
   const GURL url_;
   ProxyInfo* results_;
   CompletionCallback callback_;
 
   base::ThreadChecker thread_checker_;
   mojo::Binding<interfaces::ProxyResolverRequestClient> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(Job);
 };
 
-ProxyResolverMojo::RequestImpl::RequestImpl(std::unique_ptr<Job> job)
-    : job_(std::move(job)) {}
-
-LoadState ProxyResolverMojo::RequestImpl::GetLoadState() {
-  return job_->GetLoadState();
-}
-
 ProxyResolverMojo::Job::Job(ProxyResolverMojo* resolver,
                             const GURL& url,
                             ProxyInfo* results,
                             const CompletionCallback& callback,
                             const NetLogWithSource& net_log)
     : ClientMixin<interfaces::ProxyResolverRequestClient>(
           resolver->host_resolver_,
           resolver->error_observer_.get(),
           resolver->net_log_,
           net_log),
@@ skipping 70 matching lines @@
 int ProxyResolverMojo::GetProxyForURL(const GURL& url,
                                       ProxyInfo* results,
                                       const CompletionCallback& callback,
                                       std::unique_ptr<Request>* request,
                                       const NetLogWithSource& net_log) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!mojo_proxy_resolver_ptr_)
     return ERR_PAC_SCRIPT_TERMINATED;
 
-  std::unique_ptr<Job> job(new Job(this, url, results, callback, net_log));
-  request->reset(new RequestImpl(std::move(job)));
+  *request = base::MakeUnique<Job>(this, url, results, callback, net_log);
 
   return ERR_IO_PENDING;
 }
 
 }  // namespace
 
 // A Job to create a ProxyResolver instance.
 //
 // Note: a Job instance is not tied to a particular resolve request, and hence
 // there is no per-request logging to be done (any netlog events are only sent
@@ skipping 79 matching lines @@
     return ERR_PAC_SCRIPT_FAILED;
   }
   request->reset(new Job(this, pac_script, resolver, callback,
                          error_observer_factory_.is_null()
                              ? nullptr
                              : error_observer_factory_.Run()));
   return ERR_IO_PENDING;
 }
 
 }  // namespace net