Switch to standard integer types in content/browser/.

content/browser/indexed_db/indexed_db_backing_store.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_BACKING_STORE_H_
 #define CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_BACKING_STORE_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/files/file_path.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/strings/string_piece.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "content/browser/indexed_db/indexed_db.h"
 #include "content/browser/indexed_db/indexed_db_active_blob_registry.h"
 #include "content/browser/indexed_db/indexed_db_blob_info.h"
 #include "content/browser/indexed_db/indexed_db_leveldb_coding.h"
@@ skipping 33 matching lines @@
  public:
   class CONTENT_EXPORT Comparator : public LevelDBComparator {
    public:
     int Compare(const base::StringPiece& a,
                 const base::StringPiece& b) const override;
     const char* Name() const override;
   };
 
   class CONTENT_EXPORT RecordIdentifier {
    public:
-    RecordIdentifier(const std::string& primary_key, int64 version);
+    RecordIdentifier(const std::string& primary_key, int64_t version);
     RecordIdentifier();
     ~RecordIdentifier();
 
     const std::string& primary_key() const { return primary_key_; }
-    int64 version() const { return version_; }
-    void Reset(const std::string& primary_key, int64 version) {
+    int64_t version() const { return version_; }
+    void Reset(const std::string& primary_key, int64_t version) {
       primary_key_ = primary_key;
       version_ = version;
     }
 
    private:
     // TODO(jsbell): Make it more clear that this is the *encoded* version of
     // the key.
     std::string primary_key_;
-    int64 version_;
+    int64_t version_;
     DISALLOW_COPY_AND_ASSIGN(RecordIdentifier);
   };
 
   class BlobWriteCallback : public base::RefCounted<BlobWriteCallback> {
    public:
     virtual void Run(bool succeeded) = 0;
 
    protected:
     friend class base::RefCounted<BlobWriteCallback>;
     virtual ~BlobWriteCallback() {}
   };
 
   class BlobChangeRecord {
    public:
-    BlobChangeRecord(const std::string& key, int64 object_store_id);
+    BlobChangeRecord(const std::string& key, int64_t object_store_id);
     ~BlobChangeRecord();
 
     const std::string& key() const { return key_; }
-    int64 object_store_id() const { return object_store_id_; }
+    int64_t object_store_id() const { return object_store_id_; }
     void SetBlobInfo(std::vector<IndexedDBBlobInfo>* blob_info);
     std::vector<IndexedDBBlobInfo>& mutable_blob_info() { return blob_info_; }
     const std::vector<IndexedDBBlobInfo>& blob_info() const {
       return blob_info_;
     }
     void SetHandles(ScopedVector<storage::BlobDataHandle>* handles);
     scoped_ptr<BlobChangeRecord> Clone() const;
 
    private:
     std::string key_;
-    int64 object_store_id_;
+    int64_t object_store_id_;
     std::vector<IndexedDBBlobInfo> blob_info_;
     ScopedVector<storage::BlobDataHandle> handles_;
     DISALLOW_COPY_AND_ASSIGN(BlobChangeRecord);
   };
   typedef std::map<std::string, BlobChangeRecord*> BlobChangeMap;
 
   class CONTENT_EXPORT Transaction {
    public:
     explicit Transaction(IndexedDBBackingStore* backing_store);
     virtual ~Transaction();
@@ skipping 13 matching lines @@
     // including blob journal updates, then deletes any blob files deleted
     // by the transaction and not referenced by running scripts.
     virtual leveldb::Status CommitPhaseTwo();
 
     virtual void Rollback();
     void Reset() {
       backing_store_ = NULL;
       transaction_ = NULL;
     }
     leveldb::Status PutBlobInfoIfNeeded(
-        int64 database_id,
-        int64 object_store_id,
+        int64_t database_id,
+        int64_t object_store_id,
         const std::string& object_store_data_key,
         std::vector<IndexedDBBlobInfo>*,
         ScopedVector<storage::BlobDataHandle>* handles);
-    void PutBlobInfo(int64 database_id,
-                     int64 object_store_id,
+    void PutBlobInfo(int64_t database_id,
+                     int64_t object_store_id,
                      const std::string& object_store_data_key,
                      std::vector<IndexedDBBlobInfo>*,
                      ScopedVector<storage::BlobDataHandle>* handles);
 
     LevelDBTransaction* transaction() { return transaction_.get(); }
 
     leveldb::Status GetBlobInfoForRecord(
-        int64 database_id,
+        int64_t database_id,
         const std::string& object_store_data_key,
         IndexedDBValue* value);
 
     // This holds a BlobEntryKey and the encoded IndexedDBBlobInfo vector stored
     // under that key.
     typedef std::vector<std::pair<BlobEntryKey, std::string> >
         BlobEntryKeyValuePairVec;
 
     class CONTENT_EXPORT WriteDescriptor {
      public:
@@ skipping 32 matching lines @@
     };
 
     class ChainedBlobWriter
         : public base::RefCountedThreadSafe<ChainedBlobWriter> {
      public:
       virtual void set_delegate(
           scoped_ptr<storage::FileWriterDelegate> delegate) = 0;
 
       // TODO(ericu): Add a reason in the event of failure.
       virtual void ReportWriteCompletion(bool succeeded,
-                                         int64 bytes_written) = 0;
+                                         int64_t bytes_written) = 0;
 
       virtual void Abort() = 0;
 
      protected:
       friend class base::RefCountedThreadSafe<ChainedBlobWriter>;
       virtual ~ChainedBlobWriter() {}
     };
 
     class ChainedBlobWriterImpl;
 
@@ skipping 24 matching lines @@
 
     // Called by CommitPhaseTwo: Partition blob references in blobs_to_remove_
     // into live (active references) and dead (no references).
     void PartitionBlobsToRemove(BlobJournalType* dead_blobs,
                                 BlobJournalType* live_blobs) const;
 
     IndexedDBBackingStore* backing_store_;
     scoped_refptr<LevelDBTransaction> transaction_;
     BlobChangeMap blob_change_map_;
     BlobChangeMap incognito_blob_map_;
-    int64 database_id_;
+    int64_t database_id_;
 
     // List of blob files being newly written as part of this transaction.
     // These will be added to the primary blob journal prior to commit, then
     // removed after a successful commit.
     BlobJournalType blobs_to_write_;
 
     // List of blob files being deleted as part of this transaction. These will
     // be added to either the primary or live blob journal as appropriate
     // following a successful commit.
     BlobJournalType blobs_to_remove_;
     scoped_refptr<ChainedBlobWriter> chained_blob_writer_;
 
     // Set to true between CommitPhaseOne and CommitPhaseTwo/Rollback, to
     // indicate that the committing_transaction_count_ on the backing store
     // has been bumped, and journal cleaning should be deferred.
     bool committing_;
   };
 
   class Cursor {
    public:
     enum IteratorState { READY = 0, SEEK };
 
     virtual ~Cursor();
 
     struct CursorOptions {
       CursorOptions();
       ~CursorOptions();
-      int64 database_id;
-      int64 object_store_id;
-      int64 index_id;
+      int64_t database_id;
+      int64_t object_store_id;
+      int64_t index_id;
       std::string low_key;
       bool low_open;
       std::string high_key;
       bool high_open;
       bool forward;
       bool unique;
     };
 
     const IndexedDBKey& key() const { return *current_key_; }
     bool Continue(leveldb::Status* s) { return Continue(NULL, NULL, SEEK, s); }
     bool Continue(const IndexedDBKey* key,
                   IteratorState state,
                   leveldb::Status* s) {
       return Continue(key, NULL, state, s);
     }
     bool Continue(const IndexedDBKey* key,
                   const IndexedDBKey* primary_key,
                   IteratorState state,
                   leveldb::Status*);
-    bool Advance(uint32 count, leveldb::Status*);
+    bool Advance(uint32_t count, leveldb::Status*);
     bool FirstSeek(leveldb::Status*);
 
     virtual Cursor* Clone() = 0;
     virtual const IndexedDBKey& primary_key() const;
     virtual IndexedDBValue* value() = 0;
     virtual const RecordIdentifier& record_identifier() const;
     virtual bool LoadCurrentRow(leveldb::Status* s) = 0;
 
    protected:
     Cursor(scoped_refptr<IndexedDBBackingStore> backing_store,
            Transaction* transaction,
-           int64 database_id,
+           int64_t database_id,
            const CursorOptions& cursor_options);
     explicit Cursor(const IndexedDBBackingStore::Cursor* other);
 
     virtual std::string EncodeKey(const IndexedDBKey& key) = 0;
     virtual std::string EncodeKey(const IndexedDBKey& key,
                                   const IndexedDBKey& primary_key) = 0;
 
     bool IsPastBounds() const;
     bool HaveEnteredRange() const;
 
     IndexedDBBackingStore* backing_store_;
     Transaction* transaction_;
-    int64 database_id_;
+    int64_t database_id_;
     const CursorOptions cursor_options_;
     scoped_ptr<LevelDBIterator> iterator_;
     scoped_ptr<IndexedDBKey> current_key_;
     IndexedDBBackingStore::RecordIdentifier record_identifier_;
 
    private:
     // For cursors with direction Next or NextNoDuplicate.
     bool ContinueNext(const IndexedDBKey* key,
                       const IndexedDBKey* primary_key,
                       IteratorState state,
@@ skipping 55 matching lines @@
   // Compact is public for testing.
   virtual void Compact();
   virtual std::vector<base::string16> GetDatabaseNames(leveldb::Status*);
   virtual leveldb::Status GetIDBDatabaseMetaData(
       const base::string16& name,
       IndexedDBDatabaseMetadata* metadata,
       bool* success) WARN_UNUSED_RESULT;
   virtual leveldb::Status CreateIDBDatabaseMetaData(
       const base::string16& name,
       const base::string16& version,
-      int64 int_version,
-      int64* row_id);
+      int64_t int_version,
+      int64_t* row_id);
   virtual bool UpdateIDBDatabaseIntVersion(
       IndexedDBBackingStore::Transaction* transaction,
-      int64 row_id,
-      int64 int_version);
+      int64_t row_id,
+      int64_t int_version);
   virtual leveldb::Status DeleteDatabase(const base::string16& name);
 
   // Assumes caller has already closed the backing store.
   static leveldb::Status DestroyBackingStore(const base::FilePath& path_base,
                                              const GURL& origin_url);
   static bool RecordCorruptionInfo(const base::FilePath& path_base,
                                    const GURL& origin_url,
                                    const std::string& message);
   leveldb::Status GetObjectStores(
-      int64 database_id,
+      int64_t database_id,
       IndexedDBDatabaseMetadata::ObjectStoreMap* map) WARN_UNUSED_RESULT;
   virtual leveldb::Status CreateObjectStore(
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
-      int64 object_store_id,
+      int64_t database_id,
+      int64_t object_store_id,
       const base::string16& name,
       const IndexedDBKeyPath& key_path,
       bool auto_increment);
   virtual leveldb::Status DeleteObjectStore(
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
-      int64 object_store_id) WARN_UNUSED_RESULT;
+      int64_t database_id,
+      int64_t object_store_id) WARN_UNUSED_RESULT;
 
   virtual leveldb::Status GetRecord(
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
-      int64 object_store_id,
+      int64_t database_id,
+      int64_t object_store_id,
       const IndexedDBKey& key,
       IndexedDBValue* record) WARN_UNUSED_RESULT;
   virtual leveldb::Status PutRecord(
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
-      int64 object_store_id,
+      int64_t database_id,
+      int64_t object_store_id,
       const IndexedDBKey& key,
       IndexedDBValue* value,
       ScopedVector<storage::BlobDataHandle>* handles,
       RecordIdentifier* record) WARN_UNUSED_RESULT;
   virtual leveldb::Status ClearObjectStore(
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
-      int64 object_store_id) WARN_UNUSED_RESULT;
+      int64_t database_id,
+      int64_t object_store_id) WARN_UNUSED_RESULT;
   virtual leveldb::Status DeleteRecord(
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
-      int64 object_store_id,
+      int64_t database_id,
+      int64_t object_store_id,
       const RecordIdentifier& record) WARN_UNUSED_RESULT;
   virtual leveldb::Status DeleteRange(
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
-      int64 object_store_id,
+      int64_t database_id,
+      int64_t object_store_id,
       const IndexedDBKeyRange&) WARN_UNUSED_RESULT;
   virtual leveldb::Status GetKeyGeneratorCurrentNumber(
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
-      int64 object_store_id,
-      int64* current_number) WARN_UNUSED_RESULT;
+      int64_t database_id,
+      int64_t object_store_id,
+      int64_t* current_number) WARN_UNUSED_RESULT;
   virtual leveldb::Status MaybeUpdateKeyGeneratorCurrentNumber(
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
-      int64 object_store_id,
-      int64 new_state,
+      int64_t database_id,
+      int64_t object_store_id,
+      int64_t new_state,
       bool check_current) WARN_UNUSED_RESULT;
   virtual leveldb::Status KeyExistsInObjectStore(
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
-      int64 object_store_id,
+      int64_t database_id,
+      int64_t object_store_id,
       const IndexedDBKey& key,
       RecordIdentifier* found_record_identifier,
       bool* found) WARN_UNUSED_RESULT;
 
   virtual leveldb::Status CreateIndex(
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
-      int64 object_store_id,
-      int64 index_id,
+      int64_t database_id,
+      int64_t object_store_id,
+      int64_t index_id,
       const base::string16& name,
       const IndexedDBKeyPath& key_path,
       bool is_unique,
       bool is_multi_entry) WARN_UNUSED_RESULT;
   virtual leveldb::Status DeleteIndex(
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
-      int64 object_store_id,
-      int64 index_id) WARN_UNUSED_RESULT;
+      int64_t database_id,
+      int64_t object_store_id,
+      int64_t index_id) WARN_UNUSED_RESULT;
   virtual leveldb::Status PutIndexDataForRecord(
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
-      int64 object_store_id,
-      int64 index_id,
+      int64_t database_id,
+      int64_t object_store_id,
+      int64_t index_id,
       const IndexedDBKey& key,
       const RecordIdentifier& record) WARN_UNUSED_RESULT;
   virtual leveldb::Status GetPrimaryKeyViaIndex(
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
-      int64 object_store_id,
-      int64 index_id,
+      int64_t database_id,
+      int64_t object_store_id,
+      int64_t index_id,
       const IndexedDBKey& key,
       scoped_ptr<IndexedDBKey>* primary_key) WARN_UNUSED_RESULT;
   virtual leveldb::Status KeyExistsInIndex(
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
-      int64 object_store_id,
-      int64 index_id,
+      int64_t database_id,
+      int64_t object_store_id,
+      int64_t index_id,
       const IndexedDBKey& key,
       scoped_ptr<IndexedDBKey>* found_primary_key,
       bool* exists) WARN_UNUSED_RESULT;
 
   // Public for IndexedDBActiveBlobRegistry::ReleaseBlobRef.
-  virtual void ReportBlobUnused(int64 database_id, int64 blob_key);
+  virtual void ReportBlobUnused(int64_t database_id, int64_t blob_key);
 
-  base::FilePath GetBlobFileName(int64 database_id, int64 key) const;
+  base::FilePath GetBlobFileName(int64_t database_id, int64_t key) const;
 
   virtual scoped_ptr<Cursor> OpenObjectStoreKeyCursor(
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
-      int64 object_store_id,
+      int64_t database_id,
+      int64_t object_store_id,
       const IndexedDBKeyRange& key_range,
       blink::WebIDBCursorDirection,
       leveldb::Status*);
   virtual scoped_ptr<Cursor> OpenObjectStoreCursor(
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
-      int64 object_store_id,
+      int64_t database_id,
+      int64_t object_store_id,
       const IndexedDBKeyRange& key_range,
       blink::WebIDBCursorDirection,
       leveldb::Status*);
   virtual scoped_ptr<Cursor> OpenIndexKeyCursor(
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
-      int64 object_store_id,
-      int64 index_id,
+      int64_t database_id,
+      int64_t object_store_id,
+      int64_t index_id,
       const IndexedDBKeyRange& key_range,
       blink::WebIDBCursorDirection,
       leveldb::Status*);
   virtual scoped_ptr<Cursor> OpenIndexCursor(
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
-      int64 object_store_id,
-      int64 index_id,
+      int64_t database_id,
+      int64_t object_store_id,
+      int64_t index_id,
       const IndexedDBKeyRange& key_range,
       blink::WebIDBCursorDirection,
       leveldb::Status*);
 
  protected:
   friend class base::RefCounted<IndexedDBBackingStore>;
 
   IndexedDBBackingStore(IndexedDBFactory* indexed_db_factory,
                         const GURL& origin_url,
                         const base::FilePath& blob_path,
                         net::URLRequestContext* request_context,
                         scoped_ptr<LevelDBDatabase> db,
                         scoped_ptr<LevelDBComparator> comparator,
                         base::SequencedTaskRunner* task_runner);
   virtual ~IndexedDBBackingStore();
 
   bool is_incognito() const { return !indexed_db_factory_; }
 
   leveldb::Status SetUpMetadata();
 
   virtual bool WriteBlobFile(
-      int64 database_id,
+      int64_t database_id,
       const Transaction::WriteDescriptor& descriptor,
       Transaction::ChainedBlobWriter* chained_blob_writer);
 
   // Remove the referenced file on disk.
-  virtual bool RemoveBlobFile(int64 database_id, int64 key) const;
+  virtual bool RemoveBlobFile(int64_t database_id, int64_t key) const;
 
   // Schedule a call to CleanPrimaryJournalIgnoreReturn() via
   // an owned timer. If this object is destroyed, the timer
   // will automatically be cancelled.
   virtual void StartJournalCleaningTimer();
 
   // Attempt to clean the primary journal. This will remove
   // any referenced files and delete the journal entry. If any
   // transaction is currently committing this will be deferred
   // via StartJournalCleaningTimer().
   void CleanPrimaryJournalIgnoreReturn();
 
  private:
   static scoped_refptr<IndexedDBBackingStore> Create(
       IndexedDBFactory* indexed_db_factory,
       const GURL& origin_url,
       const base::FilePath& blob_path,
       net::URLRequestContext* request_context,
       scoped_ptr<LevelDBDatabase> db,
       scoped_ptr<LevelDBComparator> comparator,
       base::SequencedTaskRunner* task_runner,
       leveldb::Status* status);
 
   static bool ReadCorruptionInfo(const base::FilePath& path_base,
                                  const GURL& origin_url,
                                  std::string* message);
 
   leveldb::Status FindKeyInIndex(
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
-      int64 object_store_id,
-      int64 index_id,
+      int64_t database_id,
+      int64_t object_store_id,
+      int64_t index_id,
       const IndexedDBKey& key,
       std::string* found_encoded_primary_key,
       bool* found);
-  leveldb::Status GetIndexes(int64 database_id,
-                             int64 object_store_id,
+  leveldb::Status GetIndexes(int64_t database_id,
+                             int64_t object_store_id,
                              IndexedDBObjectStoreMetadata::IndexMap* map)
       WARN_UNUSED_RESULT;
 
   // Remove the blob directory for the specified database and all contained
   // blob files.
-  bool RemoveBlobDirectory(int64 database_id) const;
+  bool RemoveBlobDirectory(int64_t database_id) const;
 
   // Synchronously read the key-specified blob journal entry from the backing
   // store, delete all referenced blob files, and erase the journal entry.
   // This must not be used while temporary entries are present e.g. during
   // a two-stage transaction commit with blobs.
   leveldb::Status CleanUpBlobJournal(const std::string& level_db_key) const;
 
   // Synchronously delete the files and/or directories on disk referenced by
   // the blob journal.
   leveldb::Status CleanUpBlobJournalEntries(
@@ skipping 28 matching lines @@
   // complete. While > 0, temporary journal entries may exist so out-of-band
   // journal cleaning must be deferred.
   size_t committing_transaction_count_;
 
   DISALLOW_COPY_AND_ASSIGN(IndexedDBBackingStore);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_BACKING_STORE_H_