Reorder the methods in net/url_request/.

net/url_request/url_request.h

 // Copyright (c) 2011 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.
 
 #ifndef NET_URL_REQUEST_URL_REQUEST_H_
 #define NET_URL_REQUEST_URL_REQUEST_H_
 #pragma once
 
 #include <map>
 #include <string>
@@ skipping 40 matching lines @@
 // The lifetime of an instance of this class is completely controlled by the
 // consumer, and the instance is not required to live on the heap or be
 // allocated in any special way.  It is also valid to delete an URLRequest
 // object during the handling of a callback to its delegate.  Of course, once
 // the URLRequest is deleted, no further callbacks to its delegate will occur.
 //
 // NOTE: All usage of all instances of this class should be on the same thread.
 //
 class URLRequest : public base::NonThreadSafe {
  public:
+  // Callback function implemented by protocol handlers to create new jobs.
+  // The factory may return NULL to indicate an error, which will cause other
+  // factories to be queried.  If no factory handles the request, then the
+  // default job will be used.
+  typedef URLRequestJob* (ProtocolFactory)(URLRequest* request,
+                                           const std::string& scheme);
+
+  // HTTP request/response header IDs (via some preprocessor fun) for use with
+  // SetRequestHeaderById and GetResponseHeaderById.
+  enum {
+#define HTTP_ATOM(x) HTTP_ ## x,
+#include "net/http/http_atom_list.h"
+#undef HTTP_ATOM
+  };
+
   // Derive from this class and add your own data members to associate extra
   // information with a URLRequest. Use GetUserData(key) and SetUserData()
   class UserData {
    public:
     UserData() {}
     virtual ~UserData() {}
   };
 
-  // Callback function implemented by protocol handlers to create new jobs.
-  // The factory may return NULL to indicate an error, which will cause other
-  // factories to be queried.  If no factory handles the request, then the
-  // default job will be used.
-  typedef URLRequestJob* (ProtocolFactory)(URLRequest* request,
-                                           const std::string& scheme);
-
   // This class handles network interception.  Use with
   // (Un)RegisterRequestInterceptor.
   class Interceptor {
   public:
     virtual ~Interceptor() {}
 
     // Called for every request made.  Should return a new job to handle the
     // request if it should be intercepted, or NULL to allow the request to
     // be handled in the normal manner.
     virtual URLRequestJob* MaybeIntercept(URLRequest* request) = 0;
@@ skipping 416 matching lines @@
   // This method can be called after the user selects a client certificate to
   // instruct this URLRequest to continue with the request with the
   // certificate.  Pass NULL if the user doesn't have a client certificate.
   void ContinueWithCertificate(net::X509Certificate* client_cert);
 
   // This method can be called after some error notifications to instruct this
   // URLRequest to ignore the current error and continue with the request.  To
   // cancel the request instead, call Cancel().
   void ContinueDespiteLastError();
 
-  // HTTP request/response header IDs (via some preprocessor fun) for use with
-  // SetRequestHeaderById and GetResponseHeaderById.
-  enum {
-#define HTTP_ATOM(x) HTTP_ ## x,
-#include "net/http/http_atom_list.h"
-#undef HTTP_ATOM
-  };
-
   // Returns true if performance profiling should be enabled on the
   // URLRequestJob serving this request.
   bool enable_profiling() const { return enable_profiling_; }
 
   void set_enable_profiling(bool profiling) { enable_profiling_ = profiling; }
 
   // Used to specify the context (cookie store, cache) for this request.
   URLRequestContext* context();
   void set_context(URLRequestContext* context);
 
@@ skipping 31 matching lines @@
   // Called by URLRequestJob to allow interception when the final response
   // occurs.
   void ResponseStarted();
 
   // Allow an interceptor's URLRequestJob to restart this request.
   // Should only be called if the original job has not started a response.
   void Restart();
 
  private:
   friend class URLRequestJob;
+  typedef std::map<const void*, linked_ptr<UserData> > UserDataMap;
 
   void StartJob(URLRequestJob* job);
 
   // Restarting involves replacing the current job with a new one such as what
   // happens when following a HTTP redirect.
   void RestartWithJob(URLRequestJob* job);
   void PrepareToRestart();
 
   // Detaches the job from this request in preparation for this object going
   // away or the job being replaced. The job will not call us back when it has
@@ skipping 32 matching lines @@
 
   // The HTTP response info, lazily initialized.
   net::HttpResponseInfo response_info_;
 
   // Tells us whether the job is outstanding. This is true from the time
   // Start() is called to the time we dispatch RequestComplete and indicates
   // whether the job is active.
   bool is_pending_;
 
   // Externally-defined data accessible by key
-  typedef std::map<const void*, linked_ptr<UserData> > UserDataMap;
   UserDataMap user_data_;
 
   // Whether to enable performance profiling on the job serving this request.
   bool enable_profiling_;
 
   // Number of times we're willing to redirect.  Used to guard against
   // infinite redirects.
   int redirect_limit_;
 
   // Cached value for use after we've orphaned the job handling the
   // first transaction in a request involving redirects.
   uint64 final_upload_progress_;
 
   // The priority level for this request.  Objects like ClientSocketPool use
   // this to determine which URLRequest to allocate sockets to first.
   net::RequestPriority priority_;
 
   base::debug::LeakTracker<URLRequest> leak_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequest);
 };
 
 }  // namespace net
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_H_