Add LoadState reporting to the mojo proxy resolver.

net/proxy/proxy_resolver_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_mojo.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "mojo/common/common_type_converters.h"
@@ skipping 13 matching lines @@
  public:
   Job(ProxyResolverMojo* resolver,
       const GURL& url,
       ProxyInfo* results,
       const net::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_; }
+
  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_;
   net::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 net::CompletionCallback& callback)
     : resolver_(resolver),
@@ skipping 36 matching lines @@
   if (error == OK) {
     *results_ = proxy_servers.To<ProxyInfo>();
     DVLOG(1) << "Servers: " << results_->ToPacString();
   }
 
   callback_.Run(error);
   callback_.Reset();
   resolver_->RemoveJob(this);
 }
 
+void ProxyResolverMojo::Job::LoadStateChanged(int32_t load_state) {
+  load_state_ = static_cast<LoadState>(load_state);
+}
+
 ProxyResolverMojo::ProxyResolverMojo(
     MojoProxyResolverFactory* mojo_proxy_resolver_factory,
     HostResolver* host_resolver)
     : ProxyResolver(true /* |expects_pac_bytes| */),
       mojo_proxy_resolver_factory_(mojo_proxy_resolver_factory),
       host_resolver_(host_resolver) {
 }
 
 ProxyResolverMojo::~ProxyResolverMojo() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 127 matching lines @@
 
 void ProxyResolverMojo::CancelRequest(RequestHandle request) {
   DCHECK(thread_checker_.CalledOnValidThread());
   Job* job = static_cast<Job*>(request);
   DCHECK(job);
   job->Cancel();
   RemoveJob(job);
 }
 
 LoadState ProxyResolverMojo::GetLoadState(RequestHandle request) const {
-  // TODO(amistry): Implement real LoadState.
-  return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
+  Job* job = static_cast<Job*>(request);
+  CHECK_EQ(1u, pending_jobs_.count(job));
+  return job->load_state();
 }
 
 }  // namespace net