Split ProxyResolverV8Tracing into an implementation and a wrapper.

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 "base/bind.h"
 #include "base/logging.h"
@@ skipping 114 matching lines @@
   Job(ProxyResolverMojo* resolver,
       const GURL& url,
       ProxyInfo* results,
       const CompletionCallback& callback);
   ~Job() override;
 
   // Cancels the job and prevents the callback from being run.
   void Cancel();
 
   // Returns the LoadState of this job.
-  LoadState load_state() { return load_state_; }
+  LoadState load_state() { return LOAD_STATE_RESOLVING_PROXY_FOR_URL; }
 
  private:
   // Overridden from mojo::ErrorHandler:
   void OnConnectionError() override;
 
   // Overridden from interfaces::ProxyResolverRequestClient:
   void ReportResult(
       int32_t error,
       mojo::Array<interfaces::ProxyServerPtr> proxy_servers) override;
-  void LoadStateChanged(int32_t load_state) override;
 
   ProxyResolverMojo* resolver_;
   const GURL url_;
   ProxyInfo* results_;
   CompletionCallback callback_;
-  LoadState load_state_ = LOAD_STATE_RESOLVING_PROXY_FOR_URL;
 
   base::ThreadChecker thread_checker_;
   mojo::Binding<interfaces::ProxyResolverRequestClient> binding_;
 };
 
 ProxyResolverMojo::Job::Job(ProxyResolverMojo* resolver,
                             const GURL& url,
                             ProxyInfo* results,
                             const CompletionCallback& callback)
     : resolver_(resolver),
@@ skipping 37 matching lines @@
     *results_ = proxy_servers.To<ProxyInfo>();
     DVLOG(1) << "Servers: " << results_->ToPacString();
   }
 
   CompletionCallback callback = callback_;
   callback_.Reset();
   resolver_->RemoveJob(this);
   callback.Run(error);
 }
 
-void ProxyResolverMojo::Job::LoadStateChanged(int32_t load_state) {
-  load_state_ = static_cast<LoadState>(load_state);
-}
-
 ProxyResolverMojo::ProxyResolverMojo(
     interfaces::ProxyResolverPtr resolver_ptr,
     scoped_ptr<interfaces::HostResolver> host_resolver,
     scoped_ptr<mojo::Binding<interfaces::HostResolver>> host_resolver_binding,
     scoped_ptr<base::ScopedClosureRunner> on_delete_callback_runner,
     scoped_ptr<ErrorObserverHolder> error_observer)
     : mojo_proxy_resolver_ptr_(resolver_ptr.Pass()),
       mojo_host_resolver_(host_resolver.Pass()),
       mojo_host_resolver_binding_(host_resolver_binding.Pass()),
       error_observer_(error_observer.Pass()),
@@ skipping 144 matching lines @@
   DCHECK(request);
   if (pac_script->type() != ProxyResolverScriptData::TYPE_SCRIPT_CONTENTS ||
       pac_script->utf16().empty()) {
     return ERR_PAC_SCRIPT_FAILED;
   }
   request->reset(new Job(this, pac_script, resolver, callback));
   return ERR_IO_PENDING;
 }
 
 }  // namespace net