More net/ method ordering.

net/http/http_cache_transaction.h

 // 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.
 
 // This file declares HttpCache::Transaction, a private class of HttpCache so
 // it should only be included by http_cache.cc
 
 #ifndef NET_HTTP_HTTP_CACHE_TRANSACTION_H_
 #define NET_HTTP_HTTP_CACHE_TRANSACTION_H_
 #pragma once
@@ skipping 10 matching lines @@
 namespace net {
 
 class HttpResponseHeaders;
 class PartialData;
 struct HttpRequestInfo;
 
 // This is the transaction that is returned by the HttpCache transaction
 // factory.
 class HttpCache::Transaction : public HttpTransaction {
  public:
-  Transaction(HttpCache* cache);
-  virtual ~Transaction();
-
-  // HttpTransaction methods:
-  virtual int Start(const HttpRequestInfo*, CompletionCallback*,
-                    const BoundNetLog&);
-  virtual int RestartIgnoringLastError(CompletionCallback* callback);
-  virtual int RestartWithCertificate(X509Certificate* client_cert,
-                                     CompletionCallback* callback);
-  virtual int RestartWithAuth(const string16& username,
-                              const string16& password,
-                              CompletionCallback* callback);
-  virtual bool IsReadyToRestartForAuth();
-  virtual int Read(IOBuffer* buf, int buf_len, CompletionCallback* callback);
-  virtual void StopCaching();
-  virtual const HttpResponseInfo* GetResponseInfo() const;
-  virtual LoadState GetLoadState() const;
-  virtual uint64 GetUploadProgress(void) const;
-
   // The transaction has the following modes, which apply to how it may access
   // its cache entry.
   //
   //  o If the mode of the transaction is NONE, then it is in "pass through"
   //    mode and all methods just forward to the inner network transaction.
   //
   //  o If the mode of the transaction is only READ, then it may only read from
   //    the cache entry.
   //
   //  o If the mode of the transaction is only WRITE, then it may only write to
   //    the cache entry.
   //
   //  o If the mode of the transaction is READ_WRITE, then the transaction may
   //    optionally modify the cache entry (e.g., possibly corresponding to
   //    cache validation).
   //
   //  o If the mode of the transaction is UPDATE, then the transaction may
   //    update existing cache entries, but will never create a new entry or
   //    respond using the entry read from the cache.
   enum Mode {
     NONE            = 0,
     READ_META       = 1 << 0,
     READ_DATA       = 1 << 1,
     READ            = READ_META | READ_DATA,
     WRITE           = 1 << 2,
     READ_WRITE      = READ | WRITE,
     UPDATE          = READ_META | WRITE,  // READ_WRITE & ~READ_DATA
   };
 
+  Transaction(HttpCache* cache);
+  virtual ~Transaction();
+
   Mode mode() const { return mode_; }
 
   const std::string& key() const { return cache_key_; }
 
   // Writes |buf_len| bytes of meta-data from the provided buffer |buf|. to the
   // HTTP cache entry that backs this transaction (if any).
   // Returns the number of bytes actually written, or a net error code. If the
   // operation cannot complete immediately, returns ERR_IO_PENDING, grabs a
   // reference to the buffer (until completion), and notifies the caller using
   // the provided |callback| when the operatiopn finishes.
@@ skipping 16 matching lines @@
   // Returns the LoadState of the writer transaction of a given ActiveEntry. In
   // other words, returns the LoadState of this transaction without asking the
   // http cache, because this transaction should be the one currently writing
   // to the cache entry.
   LoadState GetWriterLoadState() const;
 
   CompletionCallback* io_callback() { return &io_callback_; }
 
   const BoundNetLog& net_log() const;
 
+  // HttpTransaction methods:
+  virtual int Start(const HttpRequestInfo*, CompletionCallback*,
+                    const BoundNetLog&);
+  virtual int RestartIgnoringLastError(CompletionCallback* callback);
+  virtual int RestartWithCertificate(X509Certificate* client_cert,
+                                     CompletionCallback* callback);
+  virtual int RestartWithAuth(const string16& username,
+                              const string16& password,
+                              CompletionCallback* callback);
+  virtual bool IsReadyToRestartForAuth();
+  virtual int Read(IOBuffer* buf, int buf_len, CompletionCallback* callback);
+  virtual void StopCaching();
+  virtual const HttpResponseInfo* GetResponseInfo() const;
+  virtual LoadState GetLoadState() const;
+  virtual uint64 GetUploadProgress(void) const;
+
  private:
   static const size_t kNumValidationHeaders = 2;
   // Helper struct to pair a header name with its value, for
   // headers used to validate cache entries.
   struct ValidationHeaders {
     ValidationHeaders() : initialized(false) {}
 
     std::string values[kNumValidationHeaders];
     bool initialized;
   };
@@ skipping 226 matching lines @@
   uint64 final_upload_progress_;
   CompletionCallbackImpl<Transaction> io_callback_;
   scoped_refptr<CancelableCompletionCallback<Transaction> > cache_callback_;
   scoped_refptr<CancelableCompletionCallback<Transaction> >
       write_headers_callback_;
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_CACHE_TRANSACTION_H_