Even more reordering the methods in headers and implementation in net/.

net/base/host_resolver_impl.cc

 // Copyright (c) 2010 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/base/host_resolver_impl.h"
 
 #if defined(OS_WIN)
 #include <Winsock2.h>
 #elif defined(OS_POSIX)
 #include <netdb.h>
@@ skipping 926 matching lines @@
   if (cur_completing_job_)
     cur_completing_job_->Cancel();
 
   NetworkChangeNotifier::RemoveObserver(this);
 
   // Delete the job pools.
   for (size_t i = 0u; i < arraysize(job_pools_); ++i)
     delete job_pools_[i];
 }
 
+void HostResolverImpl::ProbeIPv6Support() {
+  DCHECK(CalledOnValidThread());
+  DCHECK(!ipv6_probe_monitoring_);
+  ipv6_probe_monitoring_ = true;
+  OnIPAddressChanged();  // Give initial setup call.
+}
+
+void HostResolverImpl::SetPoolConstraints(JobPoolIndex pool_index,
+                                          size_t max_outstanding_jobs,
+                                          size_t max_pending_requests) {
+  DCHECK(CalledOnValidThread());
+  CHECK_GE(pool_index, 0);
+  CHECK_LT(pool_index, POOL_COUNT);
+  CHECK(jobs_.empty()) << "Can only set constraints during setup";
+  JobPool* pool = job_pools_[pool_index];
+  pool->SetConstraints(max_outstanding_jobs, max_pending_requests);
+}
+
 int HostResolverImpl::Resolve(const RequestInfo& info,
                               AddressList* addresses,
                               CompletionCallback* callback,
                               RequestHandle* out_req,
                               const BoundNetLog& source_net_log) {
   DCHECK(CalledOnValidThread());
 
   if (shutdown_)
     return ERR_UNEXPECTED;
 
@@ skipping 161 matching lines @@
   DCHECK(CalledOnValidThread());
   ipv6_probe_monitoring_ = false;
   DiscardIPv6ProbeJob();
   default_address_family_ = address_family;
 }
 
 AddressFamily HostResolverImpl::GetDefaultAddressFamily() const {
   return default_address_family_;
 }
 
-void HostResolverImpl::ProbeIPv6Support() {
-  DCHECK(CalledOnValidThread());
-  DCHECK(!ipv6_probe_monitoring_);
-  ipv6_probe_monitoring_ = true;
-  OnIPAddressChanged();  // Give initial setup call.
-}
-
 HostResolverImpl* HostResolverImpl::GetAsHostResolverImpl() {
   return this;
 }
 
 void HostResolverImpl::Shutdown() {
   DCHECK(CalledOnValidThread());
 
   // Cancel the outstanding jobs.
   CancelAllJobs();
   DiscardIPv6ProbeJob();
 
   shutdown_ = true;
 }
 
-void HostResolverImpl::SetPoolConstraints(JobPoolIndex pool_index,
-                                          size_t max_outstanding_jobs,
-                                          size_t max_pending_requests) {
-  DCHECK(CalledOnValidThread());
-  CHECK_GE(pool_index, 0);
-  CHECK_LT(pool_index, POOL_COUNT);
-  CHECK(jobs_.empty()) << "Can only set constraints during setup";
-  JobPool* pool = job_pools_[pool_index];
-  pool->SetConstraints(max_outstanding_jobs, max_pending_requests);
-}
-
 void HostResolverImpl::AddOutstandingJob(Job* job) {
   scoped_refptr<Job>& found_job = jobs_[job->key()];
   DCHECK(!found_job);
   found_job = job;
 
   JobPool* pool = GetPoolForRequest(job->initial_request());
   pool->AdjustNumOutstandingJobs(1);
 }
 
 HostResolverImpl::Job* HostResolverImpl::FindOutstandingJob(const Key& key) {
@@ skipping 128 matching lines @@
     for (ObserversList::iterator it = observers_.begin();
          it != observers_.end(); ++it) {
       (*it)->OnCancelResolution(request_id, info);
     }
   }
 
   request_net_log.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_REQUEST, NULL);
   source_net_log.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL, NULL);
 }
 
-void HostResolverImpl::OnIPAddressChanged() {
-  if (cache_.get())
-    cache_->clear();
-  if (ipv6_probe_monitoring_) {
-    DCHECK(!shutdown_);
-    if (shutdown_)
-      return;
-    DiscardIPv6ProbeJob();
-    ipv6_probe_job_ = new IPv6ProbeJob(this);
-    ipv6_probe_job_->Start();
-  }
-#if defined(OS_LINUX)
-  if (HaveOnlyLoopbackAddresses()) {
-    additional_resolver_flags_ |= HOST_RESOLVER_LOOPBACK_ONLY;
-  } else {
-    additional_resolver_flags_ &= ~HOST_RESOLVER_LOOPBACK_ONLY;
-  }
-#endif
-  AbortAllInProgressJobs();
-  // |this| may be deleted inside AbortAllInProgressJobs().
-}
-
 void HostResolverImpl::DiscardIPv6ProbeJob() {
   if (ipv6_probe_job_.get()) {
     ipv6_probe_job_->Cancel();
     ipv6_probe_job_ = NULL;
   }
 }
 
 void HostResolverImpl::IPv6ProbeSetDefaultAddressFamily(
     AddressFamily address_family) {
   DCHECK(address_family == ADDRESS_FAMILY_UNSPECIFIED ||
          address_family == ADDRESS_FAMILY_IPV4);
   if (default_address_family_ != address_family) {
     VLOG(1) << "IPv6Probe forced AddressFamily setting to "
             << ((address_family == ADDRESS_FAMILY_UNSPECIFIED) ?
                 "ADDRESS_FAMILY_UNSPECIFIED" : "ADDRESS_FAMILY_IPV4");
   }
   default_address_family_ = address_family;
   // Drop reference since the job has called us back.
   DiscardIPv6ProbeJob();
 }
 
-// static
-HostResolverImpl::JobPoolIndex HostResolverImpl::GetJobPoolIndexForRequest(
-    const Request* req) {
-  return POOL_NORMAL;
-}
-
 bool HostResolverImpl::CanCreateJobForPool(const JobPool& pool) const {
   DCHECK_LE(jobs_.size(), max_jobs_);
 
   // We can't create another job if it would exceed the global total.
   if (jobs_.size() + 1 > max_jobs_)
     return false;
 
   // Check whether the pool's constraints are met.
   return pool.CanCreateJob();
 }
 
+// static
+HostResolverImpl::JobPoolIndex HostResolverImpl::GetJobPoolIndexForRequest(
+    const Request* req) {
+  return POOL_NORMAL;
+}
+
 void HostResolverImpl::ProcessQueuedRequests() {
   // Find the highest priority request that can be scheduled.
   Request* top_req = NULL;
   for (size_t i = 0; i < arraysize(job_pools_); ++i) {
     JobPool* pool = job_pools_[i];
     if (pool->HasPendingRequests() && CanCreateJobForPool(*pool)) {
       top_req = pool->RemoveTopPendingRequest();
       break;
     }
   }
@@ skipping 73 matching lines @@
   for (size_t i = 0; i < arraysize(job_pools_); ++i)
     job_pools_[i]->ResetNumOutstandingJobs();
   JobMap jobs;
   jobs.swap(jobs_);
   for (JobMap::iterator it = jobs.begin(); it != jobs.end(); ++it) {
     AbortJob(it->second);
     it->second->Cancel();
   }
 }
 
+void HostResolverImpl::OnIPAddressChanged() {
+  if (cache_.get())
+    cache_->clear();
+  if (ipv6_probe_monitoring_) {
+    DCHECK(!shutdown_);
+    if (shutdown_)
+      return;
+    DiscardIPv6ProbeJob();
+    ipv6_probe_job_ = new IPv6ProbeJob(this);
+    ipv6_probe_job_->Start();
+  }
+#if defined(OS_LINUX)
+  if (HaveOnlyLoopbackAddresses()) {
+    additional_resolver_flags_ |= HOST_RESOLVER_LOOPBACK_ONLY;
+  } else {
+    additional_resolver_flags_ &= ~HOST_RESOLVER_LOOPBACK_ONLY;
+  }
+#endif
+  AbortAllInProgressJobs();
+  // |this| may be deleted inside AbortAllInProgressJobs().
+}
+
 }  // namespace net