IndexedDB + Coding Style: re-order enums/typedefs/... to match guide

content/browser/indexed_db/indexed_db_leveldb_coding.h

 // Copyright (c) 2013 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 CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_LEVELDB_CODING_H_
 #define CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_LEVELDB_CODING_H_
 
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 72 matching lines @@
 CONTENT_EXPORT int CompareEncodedIDBKeys(base::StringPiece* slice1,
                                          base::StringPiece* slice2,
                                          bool* ok);
 
 CONTENT_EXPORT int Compare(const base::StringPiece& a,
                            const base::StringPiece& b,
                            bool index_keys);
 
 class KeyPrefix {
  public:
-  KeyPrefix();
-  explicit KeyPrefix(int64 database_id);
-  KeyPrefix(int64 database_id, int64 object_store_id);
-  KeyPrefix(int64 database_id, int64 object_store_id, int64 index_id);
-  static KeyPrefix CreateWithSpecialIndex(int64 database_id,
-                                          int64 object_store_id,
-                                          int64 index_id);
-
-  static bool Decode(base::StringPiece* slice, KeyPrefix* result);
-  std::string Encode() const;
-  static std::string EncodeEmpty();
-  int Compare(const KeyPrefix& other) const;
-
   // These are serialized to disk; any new items must be appended, and none can
   // be deleted.
   enum Type {
     GLOBAL_METADATA,
     DATABASE_METADATA,
     OBJECT_STORE_DATA,
     EXISTS_ENTRY,
     INDEX_DATA,
     INVALID_TYPE,
     BLOB_ENTRY
@@ skipping 15 matching lines @@
       kMaxObjectStoreIdSizeBytes * 8 - 1;                              // 63
   static const size_t kMaxIndexIdBits = kMaxIndexIdSizeBytes * 8 - 1;  // 31
 
   static const int64 kMaxDatabaseId =
       (1ULL << kMaxDatabaseIdBits) - 1;  // max signed int64
   static const int64 kMaxObjectStoreId =
       (1ULL << kMaxObjectStoreIdBits) - 1;  // max signed int64
   static const int64 kMaxIndexId =
       (1ULL << kMaxIndexIdBits) - 1;  // max signed int32
 
+  static const int64 kInvalidId = -1;
+
+  KeyPrefix();
+  explicit KeyPrefix(int64 database_id);
+  KeyPrefix(int64 database_id, int64 object_store_id);
+  KeyPrefix(int64 database_id, int64 object_store_id, int64 index_id);
+  static KeyPrefix CreateWithSpecialIndex(int64 database_id,
+                                          int64 object_store_id,
+                                          int64 index_id);
+
+  static bool Decode(base::StringPiece* slice, KeyPrefix* result);
+  std::string Encode() const;
+  static std::string EncodeEmpty();
+  int Compare(const KeyPrefix& other) const;
+
   CONTENT_EXPORT static bool IsValidDatabaseId(int64 database_id);
   static bool IsValidObjectStoreId(int64 index_id);
   static bool IsValidIndexId(int64 index_id);
   static bool ValidIds(int64 database_id,
                        int64 object_store_id,
                        int64 index_id) {
     return IsValidDatabaseId(database_id) &&
            IsValidObjectStoreId(object_store_id) && IsValidIndexId(index_id);
   }
   static bool ValidIds(int64 database_id, int64 object_store_id) {
     return IsValidDatabaseId(database_id) &&
            IsValidObjectStoreId(object_store_id);
   }
 
   Type type() const;
 
   int64 database_id_;
   int64 object_store_id_;
   int64 index_id_;
 
-  static const int64 kInvalidId = -1;
-
  private:
-  static std::string EncodeInternal(int64 database_id,
-                                    int64 object_store_id,
-                                    int64 index_id);
   // Special constructor for CreateWithSpecialIndex()
   KeyPrefix(enum Type,
             int64 database_id,
             int64 object_store_id,
             int64 index_id);
+
+  static std::string EncodeInternal(int64 database_id,
+                                    int64 object_store_id,
+                                    int64 index_id);
 };
 
 class SchemaVersionKey {
  public:
   CONTENT_EXPORT static std::string Encode();
 };
 
 class MaxDatabaseIdKey {
  public:
   CONTENT_EXPORT static std::string Encode();
@@ skipping 189 matching lines @@
   int Compare(const IndexNamesKey& other);
   base::string16 index_name() const { return index_name_; }
 
  private:
   int64 object_store_id_;
   base::string16 index_name_;
 };
 
 class ObjectStoreDataKey {
  public:
+  static const int64 kSpecialIndexNumber;
+
+  ObjectStoreDataKey();
+  ~ObjectStoreDataKey();
+
   static bool Decode(base::StringPiece* slice, ObjectStoreDataKey* result);
   CONTENT_EXPORT static std::string Encode(int64 database_id,
                                            int64 object_store_id,
                                            const std::string encoded_user_key);
   static std::string Encode(int64 database_id,
                             int64 object_store_id,
                             const IndexedDBKey& user_key);
   scoped_ptr<IndexedDBKey> user_key() const;
-  static const int64 kSpecialIndexNumber;
-  ObjectStoreDataKey();
-  ~ObjectStoreDataKey();
-
  private:
   std::string encoded_user_key_;
 };
 
 class ExistsEntryKey {
  public:
+  static const int64 kSpecialIndexNumber;

[cmumford, 2014/08/20 19:43:05]

Unrelated to your change, but can be private? Same for two other special index
number constants?

[jsbell, 2014/08/22 20:50:01]

Compiler says... 2/3 can be made private, another is used in a DCHECK, so
leaving it alone.

+
   ExistsEntryKey();
   ~ExistsEntryKey();
 
   static bool Decode(base::StringPiece* slice, ExistsEntryKey* result);
   CONTENT_EXPORT static std::string Encode(int64 database_id,
                                            int64 object_store_id,
                                            const std::string& encoded_key);
   static std::string Encode(int64 database_id,
                             int64 object_store_id,
                             const IndexedDBKey& user_key);
   scoped_ptr<IndexedDBKey> user_key() const;
 
-  static const int64 kSpecialIndexNumber;
-
  private:
   std::string encoded_user_key_;
   DISALLOW_COPY_AND_ASSIGN(ExistsEntryKey);
 };
 
 class BlobEntryKey {
  public:
+  static const int64 kSpecialIndexNumber;
+
   BlobEntryKey() : database_id_(0), object_store_id_(0) {}
   static bool Decode(base::StringPiece* slice, BlobEntryKey* result);
   static bool FromObjectStoreDataKey(base::StringPiece* slice,
                                      BlobEntryKey* result);
   static std::string ReencodeToObjectStoreDataKey(base::StringPiece* slice);
   static std::string EncodeMinKeyForObjectStore(int64 database_id,
                                                 int64 object_store_id);
   static std::string EncodeStopKeyForObjectStore(int64 database_id,
                                                  int64 object_store_id);
   static std::string Encode(int64 database_id,
                             int64 object_store_id,
                             const IndexedDBKey& user_key);
   std::string Encode() const;
   int64 database_id() const { return database_id_; }
   int64 object_store_id() const { return object_store_id_; }
 
-  static const int64 kSpecialIndexNumber;
-
  private:
   static std::string Encode(int64 database_id,
                             int64 object_store_id,
                             const std::string& encoded_user_key);
   int64 database_id_;
   int64 object_store_id_;
   // This is the user's ObjectStoreDataKey, not the BlobEntryKey itself.
   std::string encoded_user_key_;
 };
 
@@ skipping 37 matching lines @@
   std::string encoded_user_key_;
   std::string encoded_primary_key_;
   int64 sequence_number_;
 
   DISALLOW_COPY_AND_ASSIGN(IndexDataKey);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_LEVELDB_CODING_H_