Add LoadState reporting to the mojo proxy resolver.

net/proxy/proxy_resolver_v8_tracing.cc

 // Copyright (c) 2013 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_v8_tracing.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/stringprintf.h"
@@ skipping 689 matching lines @@
     if (!pending_dns_completed_synchronously_)
       host_resolver()->CancelRequest(dns_request);
     return;
   }
 
   if (pending_dns_completed_synchronously_) {
     OnDnsOperationComplete(result);
   } else {
     DCHECK(dns_request);
     pending_dns_ = dns_request;
+    if (!parent_->on_load_state_changed_.is_null()) {
+      parent_->on_load_state_changed_.Run(
+          this, LOAD_STATE_RESOLVING_HOST_IN_PROXY_SCRIPT);
+    }
     // OnDnsOperationComplete() will be called by host resolver on completion.
   }
 
   if (!blocking_dns_) {
     // The worker thread always blocks waiting to see if the result can be
     // serviced from cache before restarting.
     event_.Signal();
   }
 }
 
 void ProxyResolverV8Tracing::Job::OnDnsOperationComplete(int result) {
   // TODO(vadimt): Remove ScopedTracker below once crbug.com/436634 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "436634 ProxyResolverV8Tracing::Job::OnDnsOperationComplete"));
 
   CheckIsOnOriginThread();
 
   DCHECK(!cancelled_.IsSet());
   DCHECK(pending_dns_completed_synchronously_ == (pending_dns_ == NULL));
 
   SaveDnsToLocalCache(pending_dns_host_, pending_dns_op_, result,
                       pending_dns_addresses_);
   pending_dns_ = NULL;
 
+  if (!pending_dns_completed_synchronously_ && !cancelled_.IsSet() &&
+      !parent_->on_load_state_changed_.is_null()) {

[eroman, 2015/03/06 05:13:02]

nit: can you move this check to be the first?

[Sam McNally, 2015/03/06 09:33:02]

Done.

+    parent_->on_load_state_changed_.Run(this,
+                                        LOAD_STATE_RESOLVING_PROXY_FOR_URL);
+  }
+
   if (blocking_dns_) {
     event_.Signal();
     return;
   }
 
   if (!blocking_dns_ && !pending_dns_completed_synchronously_) {
     // Restart. This time it should make more progress due to having
     // cached items.
     worker_loop()->PostTask(FROM_HERE,
                             base::Bind(&Job::ExecuteNonBlocking, this));
@@ skipping 182 matching lines @@
 
   // Emit to the global NetLog event stream.
   if (net_log())
     net_log()->AddGlobalEntry(type, parameters_callback);
 }
 
 ProxyResolverV8Tracing::ProxyResolverV8Tracing(
     HostResolver* host_resolver,
     ProxyResolverErrorObserver* error_observer,
     NetLog* net_log)
+    : ProxyResolverV8Tracing(host_resolver,
+                             error_observer,
+                             net_log,
+                             LoadStateChangedCallback<RequestHandle>()) {
+}
+
+ProxyResolverV8Tracing::ProxyResolverV8Tracing(
+    HostResolver* host_resolver,
+    ProxyResolverErrorObserver* error_observer,
+    NetLog* net_log,
+    const LoadStateChangedCallback<RequestHandle>& on_load_state_changed)
     : ProxyResolver(true /*expects_pac_bytes*/),
       host_resolver_(host_resolver),
       error_observer_(error_observer),
       net_log_(net_log),
-      num_outstanding_callbacks_(0) {
+      num_outstanding_callbacks_(0),
+      on_load_state_changed_(on_load_state_changed) {
   DCHECK(host_resolver);
   // Start up the thread.
   thread_.reset(new base::Thread("Proxy resolver"));
   base::Thread::Options options;
   options.timer_slack = base::TIMER_SLACK_MAXIMUM;
   CHECK(thread_->StartWithOptions(options));
 
   v8_resolver_.reset(new ProxyResolverV8);
 }
 
@@ skipping 55 matching lines @@
   DCHECK(!set_pac_script_job_.get());
   CHECK_EQ(0, num_outstanding_callbacks_);
 
   set_pac_script_job_ = new Job(this);
   set_pac_script_job_->StartSetPacScript(script_data, callback);
 
   return ERR_IO_PENDING;
 }
 
 }  // namespace net