Start reordering the methods in headers in net/.

net/disk_cache/backend_impl.h

 // Copyright (c) 2006-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.
 
 // See net/disk_cache/disk_cache.h for the public interface of the cache.
 
 #ifndef NET_DISK_CACHE_BACKEND_IMPL_H_
 #define NET_DISK_CACHE_BACKEND_IMPL_H_
 #pragma once
 
@@ skipping 42 matching lines @@
   // CreateCacheBackend().
   static int CreateBackend(const FilePath& full_path, bool force,
                            int max_bytes, net::CacheType type,
                            uint32 flags, base::MessageLoopProxy* thread,
                            net::NetLog* net_log, Backend** backend,
                            CompletionCallback* callback);
 
   // Performs general initialization for this current instance of the cache.
   int Init(CompletionCallback* callback);
 
-  // Backend interface.
-  virtual int32 GetEntryCount() const;
-  virtual int OpenEntry(const std::string& key, Entry** entry,
-                        CompletionCallback* callback);
-  virtual int CreateEntry(const std::string& key, Entry** entry,
-                          CompletionCallback* callback);
-  virtual int DoomEntry(const std::string& key, CompletionCallback* callback);
-  virtual int DoomAllEntries(CompletionCallback* callback);
-  virtual int DoomEntriesBetween(const base::Time initial_time,
-                                 const base::Time end_time,
-                                 CompletionCallback* callback);
-  virtual int DoomEntriesSince(const base::Time initial_time,
-                               CompletionCallback* callback);
-  virtual int OpenNextEntry(void** iter, Entry** next_entry,
-                            CompletionCallback* callback);
-  virtual void EndEnumeration(void** iter);
-  virtual void GetStats(StatsItems* stats);
-
   // Performs the actual initialization and final cleanup on destruction.
   int SyncInit();
   void CleanupCache();
 
   // Same bahavior as OpenNextEntry but walks the list from back to front.
   int OpenPrevEntry(void** iter, Entry** prev_entry,
                     CompletionCallback* callback);
 
   // Synchronous implementation of the asynchronous interface.
   int SyncOpenEntry(const std::string& key, Entry** entry);
@@ skipping 164 matching lines @@
   // deleted after it runs.
   int RunTaskForTest(Task* task, CompletionCallback* callback);
 
   // Starts or stops throttling requests.
   void ThrottleRequestsForTest(bool throttle);
 
   // Peforms a simple self-check, and returns the number of dirty items
   // or an error code (negative value).
   int SelfCheck();
 
+  // Backend interface.

[rvargas (doing something else), 2011/01/08 00:25:57]

Sorry to differ, but I *really* prefer the current order of these files: the
public interface is already clearly separated from implementation, and it is at
the beginning of the class, not at the end of the public section. As far as I
remember, there was not a clear decision to enforce this particular order on the
dev thread.

I know this doesn't make things easy for your plugin, but I believe the current
order is easier to follow for a human trying to understand what this code does.

+  virtual int32 GetEntryCount() const;
+  virtual int OpenEntry(const std::string& key, Entry** entry,
+                        CompletionCallback* callback);
+  virtual int CreateEntry(const std::string& key, Entry** entry,
+                          CompletionCallback* callback);
+  virtual int DoomEntry(const std::string& key, CompletionCallback* callback);
+  virtual int DoomAllEntries(CompletionCallback* callback);
+  virtual int DoomEntriesBetween(const base::Time initial_time,
+                                 const base::Time end_time,
+                                 CompletionCallback* callback);
+  virtual int DoomEntriesSince(const base::Time initial_time,
+                               CompletionCallback* callback);
+  virtual int OpenNextEntry(void** iter, Entry** next_entry,
+                            CompletionCallback* callback);
+  virtual void EndEnumeration(void** iter);
+  virtual void GetStats(StatsItems* stats);
+
  private:
   typedef base::hash_map<CacheAddr, EntryImpl*> EntriesMap;
 
   // Creates a new backing file for the cache index.
   bool CreateBackingStore(disk_cache::File* file);
   bool InitBackingStore(bool* file_created);
   void AdjustMaxCacheSize(int table_len);
 
   // Deletes the cache and starts again.
   void RestartCache(bool failure);
@@ skipping 99 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(BackendImpl);
 };
 
 // Returns the prefered max cache size given the available disk space.
 int PreferedCacheSize(int64 available);
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_BACKEND_IMPL_H_