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

net/base/mock_host_resolver.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/mock_host_resolver.h"
 
 #include "base/string_util.h"
 #include "base/ref_counted.h"
 #include "base/threading/platform_thread.h"
 #include "net/base/net_errors.h"
@@ skipping 27 matching lines @@
 
   AddressList result(ip_number, -1, false);
   struct addrinfo* ai = const_cast<struct addrinfo*>(result.head());
   ai->ai_canonname = do_strdup(canonical_name.c_str());
   *addrlist = result;
   return OK;
 }
 
 }  // namespace
 
-MockHostResolverBase::MockHostResolverBase(bool use_caching)
-    : use_caching_(use_caching) {
-  Reset(NULL);
-}
-
 MockHostResolverBase::~MockHostResolverBase() {}
 
-int MockHostResolverBase::Resolve(const RequestInfo& info,
-                                  AddressList* addresses,
-                                  CompletionCallback* callback,
-                                  RequestHandle* out_req,
-                                  const BoundNetLog& net_log) {
-  if (synchronous_mode_) {
-    callback = NULL;
-    out_req = NULL;
-  }
-  return impl_->Resolve(info, addresses, callback, out_req, net_log);
-}
-
-void MockHostResolverBase::CancelRequest(RequestHandle req) {
-  impl_->CancelRequest(req);
-}
-
-void MockHostResolverBase::AddObserver(Observer* observer) {
-  impl_->AddObserver(observer);
-}
-
-void MockHostResolverBase::RemoveObserver(Observer* observer) {
-  impl_->RemoveObserver(observer);
-}
-
 void MockHostResolverBase::Reset(HostResolverProc* interceptor) {
   synchronous_mode_ = false;
 
   // At the root of the chain, map everything to localhost.
   scoped_refptr<RuleBasedHostResolverProc> catchall(
       new RuleBasedHostResolverProc(NULL));
   catchall->AddRule("*", "127.0.0.1");
 
   // Next add a rules-based layer the use controls.
   rules_ = new RuleBasedHostResolverProc(catchall);
@@ skipping 11 matching lines @@
   if (use_caching_) {
     cache = new HostCache(
         100,  // max entries.
         base::TimeDelta::FromMinutes(1),
         base::TimeDelta::FromSeconds(0));
   }
 
   impl_.reset(new HostResolverImpl(proc, cache, 50u, NULL));
 }
 
+int MockHostResolverBase::Resolve(const RequestInfo& info,
+                                  AddressList* addresses,
+                                  CompletionCallback* callback,
+                                  RequestHandle* out_req,
+                                  const BoundNetLog& net_log) {
+  if (synchronous_mode_) {
+    callback = NULL;
+    out_req = NULL;
+  }
+  return impl_->Resolve(info, addresses, callback, out_req, net_log);
+}
+
+void MockHostResolverBase::CancelRequest(RequestHandle req) {
+  impl_->CancelRequest(req);
+}
+
+void MockHostResolverBase::AddObserver(Observer* observer) {
+  impl_->AddObserver(observer);
+}
+
+void MockHostResolverBase::RemoveObserver(Observer* observer) {
+  impl_->RemoveObserver(observer);
+}
+
+MockHostResolverBase::MockHostResolverBase(bool use_caching)
+    : use_caching_(use_caching) {
+  Reset(NULL);
+}
+
 //-----------------------------------------------------------------------------
 
 struct RuleBasedHostResolverProc::Rule {
   enum ResolverType {
     kResolverTypeFail,
     kResolverTypeSystem,
     kResolverTypeIPLiteral,
   };
 
   ResolverType resolver_type;
@@ skipping 17 matching lines @@
         host_resolver_flags(host_resolver_flags),
         replacement(replacement),
         canonical_name(canonical_name),
         latency_ms(latency_ms) {}
 };
 
 RuleBasedHostResolverProc::RuleBasedHostResolverProc(HostResolverProc* previous)
     : HostResolverProc(previous) {
 }
 
-RuleBasedHostResolverProc::~RuleBasedHostResolverProc() {
-}
-
 void RuleBasedHostResolverProc::AddRule(const std::string& host_pattern,
                                         const std::string& replacement) {
   AddRuleForAddressFamily(host_pattern, ADDRESS_FAMILY_UNSPECIFIED,
                           replacement);
 }
 
 void RuleBasedHostResolverProc::AddRuleForAddressFamily(
     const std::string& host_pattern,
     AddressFamily address_family,
     const std::string& replacement) {
@@ skipping 91 matching lines @@
         default:
           NOTREACHED();
           return ERR_UNEXPECTED;
       }
     }
   }
   return ResolveUsingPrevious(host, address_family,
                               host_resolver_flags, addrlist, os_error);
 }
 
+RuleBasedHostResolverProc::~RuleBasedHostResolverProc() {
+}
+
 //-----------------------------------------------------------------------------
 
 WaitingHostResolverProc::WaitingHostResolverProc(HostResolverProc* previous)
     : HostResolverProc(previous), event_(false, false) {}
 
 void WaitingHostResolverProc::Signal() {
   event_.Signal();
 }
 
 int WaitingHostResolverProc::Resolve(const std::string& host,
@@ skipping 23 matching lines @@
   CHECK_EQ(old_proc, current_proc_);
 }
 
 void ScopedDefaultHostResolverProc::Init(HostResolverProc* proc) {
   current_proc_ = proc;
   previous_proc_ = HostResolverProc::SetDefault(current_proc_);
   current_proc_->SetLastProc(previous_proc_);
 }
 
 }  // namespace net