Replacing Indexed DB Chromium IPC with Mojo

content/browser/indexed_db/indexed_db_database.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_DATABASE_H_
 #define CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_DATABASE_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <list>
 #include <map>
 #include <memory>
 #include <queue>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "content/browser/indexed_db/indexed_db.h"
 #include "content/browser/indexed_db/indexed_db_backing_store.h"
-#include "content/browser/indexed_db/indexed_db_callbacks.h"
 #include "content/browser/indexed_db/indexed_db_metadata.h"
 #include "content/browser/indexed_db/indexed_db_observer.h"
-#include "content/browser/indexed_db/indexed_db_pending_connection.h"
 #include "content/browser/indexed_db/indexed_db_transaction_coordinator.h"
 #include "content/browser/indexed_db/list_set.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBTypes.h"
 
 namespace url {
 class Origin;
 }
 
 namespace content {
 
 class IndexedDBBlobInfo;
+class IndexedDBChangeHandler;
 class IndexedDBConnection;
-class IndexedDBDatabaseCallbacks;
+class IndexedDBContext;
+class IndexedDBDatabaseError;
 class IndexedDBFactory;
 class IndexedDBKey;
 class IndexedDBKeyPath;
 class IndexedDBKeyRange;
 class IndexedDBObservation;
 class IndexedDBObserverChanges;
+class IndexedDBPendingConnection;
+class IndexedDBPendingDelete;
 class IndexedDBTransaction;
 struct IndexedDBValue;
 
 class CONTENT_EXPORT IndexedDBDatabase
     : NON_EXPORTED_BASE(public base::RefCounted<IndexedDBDatabase>) {
  public:
   // An index and corresponding set of keys
   using IndexKeys = std::pair<int64_t, std::vector<IndexedDBKey>>;
 
   // Identifier is pair of (origin, database name).
@@ skipping 17 matching lines @@
 
   void AddObjectStore(const IndexedDBObjectStoreMetadata& metadata,
                       int64_t new_max_object_store_id);
   void RemoveObjectStore(int64_t object_store_id);
   void AddIndex(int64_t object_store_id,
                 const IndexedDBIndexMetadata& metadata,
                 int64_t new_max_index_id);
   void RemoveIndex(int64_t object_store_id, int64_t index_id);
 
   void OpenConnection(std::unique_ptr<IndexedDBPendingConnection> connection);
-  void DeleteDatabase(scoped_refptr<IndexedDBCallbacks> callbacks);
+  void DeleteDatabase(std::unique_ptr<IndexedDBPendingDelete> pending_delete);
   const IndexedDBDatabaseMetadata& metadata() const { return metadata_; }
 
   void CreateObjectStore(int64_t transaction_id,
                          int64_t object_store_id,
                          const base::string16& name,
                          const IndexedDBKeyPath& key_path,
                          bool auto_increment);
   void DeleteObjectStore(int64_t transaction_id, int64_t object_store_id);
 
   // Returns a pointer to a newly created transaction. The object is owned
@@ skipping 49 matching lines @@
                          int64_t object_store_id,
                          blink::WebIDBOperationType type,
                          const IndexedDBKeyRange& key_range);
   void SendObservations(
       std::map<int32_t, std::unique_ptr<IndexedDBObserverChanges>> change_map);
 
   void Get(int64_t transaction_id,
            int64_t object_store_id,
            int64_t index_id,
            std::unique_ptr<IndexedDBKeyRange> key_range,
-           bool key_only,
-           scoped_refptr<IndexedDBCallbacks> callbacks);
+           bool key_only);
   void GetAll(int64_t transaction_id,
               int64_t object_store_id,
               int64_t index_id,
               std::unique_ptr<IndexedDBKeyRange> key_range,
               bool key_only,
-              int64_t max_count,
-              scoped_refptr<IndexedDBCallbacks> callbacks);
+              int64_t max_count);
   void Put(int64_t transaction_id,
            int64_t object_store_id,
            IndexedDBValue* value,
            ScopedVector<storage::BlobDataHandle>* handles,
            std::unique_ptr<IndexedDBKey> key,
            blink::WebIDBPutMode mode,
-           scoped_refptr<IndexedDBCallbacks> callbacks,
            const std::vector<IndexKeys>& index_keys);
   void SetIndexKeys(int64_t transaction_id,
                     int64_t object_store_id,
                     std::unique_ptr<IndexedDBKey> primary_key,
                     const std::vector<IndexKeys>& index_keys);
   void SetIndexesReady(int64_t transaction_id,
                        int64_t object_store_id,
                        const std::vector<int64_t>& index_ids);
   void OpenCursor(int64_t transaction_id,
                   int64_t object_store_id,
                   int64_t index_id,
                   std::unique_ptr<IndexedDBKeyRange> key_range,
                   blink::WebIDBCursorDirection,
                   bool key_only,
-                  blink::WebIDBTaskType task_type,
-                  scoped_refptr<IndexedDBCallbacks> callbacks);
+                  blink::WebIDBTaskType task_type);
   void Count(int64_t transaction_id,
              int64_t object_store_id,
              int64_t index_id,
-             std::unique_ptr<IndexedDBKeyRange> key_range,
-             scoped_refptr<IndexedDBCallbacks> callbacks);
+             std::unique_ptr<IndexedDBKeyRange> key_range);
   void DeleteRange(int64_t transaction_id,
                    int64_t object_store_id,
-                   std::unique_ptr<IndexedDBKeyRange> key_range,
-                   scoped_refptr<IndexedDBCallbacks> callbacks);
-  void Clear(int64_t transaction_id,
-             int64_t object_store_id,
-             scoped_refptr<IndexedDBCallbacks> callbacks);
+                   std::unique_ptr<IndexedDBKeyRange> key_range);
+  void Clear(int64_t transaction_id, int64_t object_store_id);
 
   // Number of connections that have progressed passed initial open call.
   size_t ConnectionCount() const { return connections_.size(); }
 
   // Number of active open/delete calls (running or blocked on other
   // connections).
   size_t ActiveOpenDeleteCount() const { return active_request_ ? 1 : 0; }
 
   // Number of open/delete calls that are waiting their turn.
   size_t PendingOpenDeleteCount() const { return pending_requests_.size(); }
 
   // Asynchronous tasks scheduled within transactions:
   void CreateObjectStoreAbortOperation(int64_t object_store_id,
                                        IndexedDBTransaction* transaction);
   void DeleteObjectStoreOperation(int64_t object_store_id,
                                   IndexedDBTransaction* transaction);
   void DeleteObjectStoreAbortOperation(
       const IndexedDBObjectStoreMetadata& object_store_metadata,
       IndexedDBTransaction* transaction);
-  void VersionChangeOperation(int64_t version,
-                              scoped_refptr<IndexedDBCallbacks> callbacks,
-                              IndexedDBTransaction* transaction);
+  void VersionChangeOperation(
+      const IndexedDBPendingConnection* pending_connection,
+      IndexedDBTransaction* transaction);
   void VersionChangeAbortOperation(int64_t previous_version,
                                    IndexedDBTransaction* transaction);
   void DeleteIndexOperation(int64_t object_store_id,
                             int64_t index_id,
                             IndexedDBTransaction* transaction);
   void CreateIndexAbortOperation(int64_t object_store_id,
                                  int64_t index_id,
                                  IndexedDBTransaction* transaction);
   void DeleteIndexAbortOperation(int64_t object_store_id,
                                  const IndexedDBIndexMetadata& index_metadata,
                                  IndexedDBTransaction* transaction);
   void GetOperation(int64_t object_store_id,
                     int64_t index_id,
                     std::unique_ptr<IndexedDBKeyRange> key_range,
                     indexed_db::CursorType cursor_type,
-                    scoped_refptr<IndexedDBCallbacks> callbacks,
                     IndexedDBTransaction* transaction);
   void GetAllOperation(int64_t object_store_id,
                        int64_t index_id,
                        std::unique_ptr<IndexedDBKeyRange> key_range,
                        indexed_db::CursorType cursor_type,
                        int64_t max_count,
-                       scoped_refptr<IndexedDBCallbacks> callbacks,
                        IndexedDBTransaction* transaction);
   struct PutOperationParams;
   void PutOperation(std::unique_ptr<PutOperationParams> params,
                     IndexedDBTransaction* transaction);
   void SetIndexesReadyOperation(size_t index_count,
                                 IndexedDBTransaction* transaction);
   struct OpenCursorOperationParams;
   void OpenCursorOperation(std::unique_ptr<OpenCursorOperationParams> params,
                            IndexedDBTransaction* transaction);
   void CountOperation(int64_t object_store_id,
                       int64_t index_id,
                       std::unique_ptr<IndexedDBKeyRange> key_range,
-                      scoped_refptr<IndexedDBCallbacks> callbacks,
                       IndexedDBTransaction* transaction);
   void DeleteRangeOperation(int64_t object_store_id,
                             std::unique_ptr<IndexedDBKeyRange> key_range,
-                            scoped_refptr<IndexedDBCallbacks> callbacks,
                             IndexedDBTransaction* transaction);
   void ClearOperation(int64_t object_store_id,
-                      scoped_refptr<IndexedDBCallbacks> callbacks,
                       IndexedDBTransaction* transaction);
 
+  IndexedDBContext* context() const;
+
  protected:
   IndexedDBDatabase(const base::string16& name,
                     IndexedDBBackingStore* backing_store,
                     IndexedDBFactory* factory,
                     const Identifier& unique_identifier);
   virtual ~IndexedDBDatabase();
 
   // May be overridden in tests.
   virtual size_t GetMaxMessageSizeInBytes() const;
 
@@ skipping 13 matching lines @@
 
   // Called by requests when complete. The request will be freed, so the
   // request must do no other work after calling this. If there are pending
   // requests, the queue will be synchronously processed.
   void RequestComplete(ConnectionRequest* request);
 
   // Pop the first request from the queue and start it.
   void ProcessRequestQueue();
 
   std::unique_ptr<IndexedDBConnection> CreateConnection(
-      scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
+      scoped_refptr<IndexedDBChangeHandler> change_handler,
       int child_process_id);
 
   IndexedDBTransaction* GetTransaction(int64_t transaction_id) const;
 
   bool ValidateObjectStoreId(int64_t object_store_id) const;
   bool ValidateObjectStoreIdAndIndexId(int64_t object_store_id,
                                        int64_t index_id) const;
   bool ValidateObjectStoreIdAndOptionalIndexId(int64_t object_store_id,
                                                int64_t index_id) const;
   bool ValidateObjectStoreIdAndNewIndexId(int64_t object_store_id,
@@ skipping 27 matching lines @@
   bool processing_pending_requests_ = false;
 
   bool experimental_web_platform_features_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(IndexedDBDatabase);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_DATABASE_H_