// Copyright 2016 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.

module blink.mojom;

import "mojo/public/mojom/base/string16.mojom";
import "mojo/public/mojom/base/string16.mojom";
import "mojo/public/mojom/base/time.mojom";
import "third_party/blink/public/mojom/blob/blob.mojom";
import "third_party/blink/public/mojom/file_system_access/file_system_access_transfer_token.mojom";

// kIDBMaxMessageSize is 128MB, originally based on
// IPC::Channel::kMaximumMessageSize.  The "usable" size is this value less
// the overhead size.
const int32 kIDBMaxMessageSize = 134217728;

// kIDBMaxMessageOverhead is the size we expect to be used for the rest of
// the message we will send.  The "usable" size is the max size less this value.
const int32 kIDBMaxMessageOverhead = 1048576;  // 1MB; arbitrarily chosen.

// Default threshold for IDBValueWrapper::WrapIfBiggerThan().
//
// This should be tuned to achieve a compromise between short-term IndexedDB
// throughput and long-term I/O load and memory usage. LevelDB, the underlying
// storage for IndexedDB, was not designed with large values in mind. At the
// very least, large values will slow down compaction, causing occasional I/O
// spikes.
const int32 kIDBWrapThreshold = 65536;

// To avoid GetAll returning too much data in one mojo message, it is returned
// in chunks of keys or values.  This constant is the max number of keys/values
// returned per IDBDatabaseGetAllResultSink::Receive call.
const int32 kIDBGetAllChunkSize = 1000;

enum IDBCursorDirection {
  Next,
  NextNoDuplicate,
  Prev,
  PrevNoDuplicate,
};

enum IDBDataLoss {
  None,
  Total,
};

// In order of the least to the highest precedent in terms of sort order.
enum IDBKeyType {
  // Invalid is used in blink bindings code. When converting a V8 value that
  // is not a valid key, key of this type is returned. Outside of testing
  // it should only be used in blink code.
  Invalid,

  // The following indicate the type of a valid key, per the standard:
  // https://w3c.github.io/IndexedDB/#key-construct
  Array,
  Binary,
  String,
  Date,
  Number,

  // None is used to represent the lack of a key, e.g. when a key range
  // has no upper/lower bound.
  // TODO(jsbell): Consider using Optional<> instead.
  None,

  // Min is used to encode the lower bound of a construct in leveldb, e.g.
  // all entries in a store are in [{id, min}, {id+1, min}). It should
  // only appear in browser code.
  Min,
};

// Durability guarantees during a transaction.  This maps to whether or not
// the writes to disk are explicitly flushed or not.
enum IDBTransactionDurability {
  // Unspecified by caller, and so is implementation defined.
  // May map to either Strict or Relaxed.
  Default,

  // Always flush to disk after a write.
  Strict,

  // Do not flush to disk.  This is much faster.
  Relaxed,
};

union IDBKey {
  array<IDBKey> key_array;
  array<uint8> binary;
  mojo_base.mojom.String16 string;
  double date;
  double number;
  // TODO(jsbell): Consider using Optional<> instead.
  bool other_none;
};

// In order of the least to the highest precedent in terms of sort order.
// These values are written to logs. New enum values can be added, but
// existing enums must never be renumbered or deleted and reused.
enum IDBKeyPathType {
  Null,
  String,
  Array,
};

// Represents WebIDBKeyPathTypeString and WebIDBKeyPathTypeArray in a key path.
union IDBKeyPathData {
  mojo_base.mojom.String16 string;
  array<mojo_base.mojom.String16> string_array;
};

struct IDBKeyPath {
  // A null value here corresponds to WebIDBKeyPathTypeNull.
  IDBKeyPathData? data;
};

struct IDBKeyRange {
  IDBKey lower;
  IDBKey upper;
  bool lower_open;
  bool upper_open;
};

enum IDBOperationType {
  Add,
  Put,
  Delete,
  Clear,
};

enum IDBPutMode {
  AddOrUpdate,
  AddOnly,
  CursorUpdate,
};

enum IDBTaskType {
  Normal,
  Preemptive,
};

enum IDBTransactionMode {
  ReadOnly,
  ReadWrite,
  VersionChange,
};

enum IDBStatus {
  OK,
  NotFound,
  Corruption,
  NotSupported,
  InvalidArgument,
  IOError,
};

// These values need to match core/dom/exception_code.h
enum IDBException {
  kNoError = 0,
  kUnknownError = 28,
  kConstraintError = 29,
  kDataError = 30,
  kVersionError = 33,
  kAbortError = 20,
  kIgnorableAbortError = 11,
  kQuotaError = 22,
  kTimeoutError = 23,
};

struct IDBIndexMetadata {
  int64 id;
  mojo_base.mojom.String16 name;
  IDBKeyPath key_path;
  bool unique;
  bool multi_entry;
};

struct IDBObjectStoreMetadata {
  int64 id;
  mojo_base.mojom.String16 name;
  IDBKeyPath key_path;
  bool auto_increment;
  int64 max_index_id;
  map<int64, IDBIndexMetadata> indexes;
};

struct IDBDatabaseMetadata {
  int64 id;
  mojo_base.mojom.String16 name;
  int64 version;
  int64 max_object_store_id;
  map<int64, IDBObjectStoreMetadata> object_stores;
  bool was_cold_open;
};

struct IDBNameAndVersion {
  mojo_base.mojom.String16 name;
  int64 version;
};

struct IDBIndexKeys {
  int64 index_id;
  array<IDBKey> index_keys;
};

struct IDBFileInfo {
  mojo_base.mojom.String16 name;
  mojo_base.mojom.Time last_modified;
};

struct IDBBlobInfo {
  pending_remote<blink.mojom.Blob> blob;
  string uuid;
  mojo_base.mojom.String16 mime_type;
  int64 size;
  IDBFileInfo? file;
};

union IDBExternalObject {
  IDBBlobInfo blob_or_file;
  pending_remote<FileSystemAccessTransferToken> file_system_access_token;
};

struct IDBValue {
  array<uint8> bits;
  array<IDBExternalObject> external_objects;
};

struct IDBReturnValue {
  IDBValue value;
  IDBKey primary_key;
  IDBKeyPath key_path;
};

// The IDBCallbacks interface is used to return results for individual requests.
// Some requests may return multiple results before completion, such as
// UpgradeNeeded before SuccessDatabase.
//
// TODO(https://crbug.com/627484): Many of these could be replaced with
// replies associated with particular messages.
interface IDBCallbacks {
  Error(IDBException code, mojo_base.mojom.String16 message);

  // Factory::GetDatabaseInfo
  SuccessNamesAndVersionsList(array<IDBNameAndVersion> value);

  // Factory::Open / DeleteDatabase
  Blocked(int64 existing_version);

  // Factory::Open
  UpgradeNeeded(pending_associated_remote<IDBDatabase> pending_database,
                int64 old_version, IDBDataLoss data_loss,
                string data_loss_message, IDBDatabaseMetadata db_metadata);

  // Factory::Open
  SuccessDatabase(pending_associated_remote<IDBDatabase>? pending_database,
                  IDBDatabaseMetadata metadata);

  // Database::Count / DeleteRange
  // Factory::DeleteDatabase
  SuccessInteger(int64 value);

  // Cursor::Continue / Advance
  Success();
};

// The IDBDatabaseCallbacks interface is used to notification of events out of
// band to individual requests. A single instance is used for the lifetime of
// a database connection.
interface IDBDatabaseCallbacks {
  ForcedClose();
  VersionChange(int64 old_version, int64 new_version);
  Abort(int64 transaction_id, IDBException code,
        mojo_base.mojom.String16 message);
  Complete(int64 transaction_id);
};

struct IDBError {
  IDBException error_code;
  mojo_base.mojom.String16 error_message;
};

struct IDBCursorValue {
  array<IDBKey> keys;
  array<IDBKey> primary_keys;
  array<IDBValue> values;
};

union IDBCursorResult {
  IDBError error_result;  // |error| is reserved, so call this |error_result|.
  bool empty;  // False values are not allowed.
  IDBCursorValue values;
};

// Advance(), CursorContinue(), and Prefetch() can call its return callback in
// one of 3 ways:
// * with |error| set and |value| unset, if an error occurs
// * with |error| unset and |value| set, under normal operation
// * with |error| unset and |value| unset, under normal operation when the end
//   of the source being iterated is reached
interface IDBCursor {
  Advance(uint32 count) => (IDBCursorResult result);
  CursorContinue(IDBKey key, IDBKey primary_key) => (IDBCursorResult result);
  Prefetch(int32 count) => (IDBCursorResult result);
  PrefetchReset(int32 used_prefetches, int32 unused_prefetches);
};

union IDBTransactionPutResult {
  IDBError error_result;  // |error| is reserved, so call this |error_result|.
  IDBKey key;
};

union IDBTransactionPutAllResult {
  IDBError error_result;  // |error| is reserved, so call this |error_result|.
  array<IDBKey> keys;
};

struct IDBPutParams {
  IDBValue value;
  IDBKey key;
  array<IDBIndexKeys> index_keys;
};

interface IDBTransaction {
  CreateObjectStore(int64 object_store_id,
                    mojo_base.mojom.String16 name,
                    IDBKeyPath key_path,
                    bool auto_increment);
  DeleteObjectStore(int64 object_store_id);
  Put(int64 object_store_id,
      IDBValue value,
      IDBKey key,
      IDBPutMode mode,
      array<IDBIndexKeys> index_keys)
    => (IDBTransactionPutResult result);
  PutAll(int64 object_store_id,
    array<IDBPutParams> put_params)
    => (IDBTransactionPutAllResult result);
  Commit(int64 num_errors_handled);
};

union IDBDatabaseGetResult {
  IDBError error_result;  // |error| is reserved, so call this |error_result|.
  bool empty;  // False values are not allowed.
  IDBKey key;
  IDBReturnValue value;
};

// Result receiver type for GetAll to incrementally receive chunks of results.
// When the mojo connection disconnects, this signals that all of the results
// have been sent.
interface IDBDatabaseGetAllResultSink {
  // Incrementally receive some values.
  ReceiveValues(array<IDBReturnValue> values);

  // Incrementally receive some keys.
  ReceiveKeys(array<IDBKey> keys);

  // If any error occurs, call this function.  Once this function has been
  // called, ReceiveValues/ReceiveKeys should not be called again and
  // the entire result should be considered an error.
  OnError(IDBError error);
};

struct IDBDatabaseOpenCursorValue {
  pending_associated_remote<IDBCursor> cursor;
  IDBKey key;
  IDBKey primary_key;
  IDBValue? value;
};

union IDBDatabaseOpenCursorResult {
  IDBError error_result;  // |error| is reserved, so call this |error_result|.
  bool empty;  // Only true values are allowed.
  IDBDatabaseOpenCursorValue value;
};

interface IDBDatabase {
  RenameObjectStore(int64 transaction_id,
                    int64 object_store_id,
                    mojo_base.mojom.String16 new_name);
  CreateTransaction(pending_associated_receiver<IDBTransaction> transaction_receiver,
                    int64 transaction_id,
                    array<int64> object_store_ids,
                    IDBTransactionMode mode,
                    IDBTransactionDurability durability);
  Close();
  VersionChangeIgnored();
  Get(int64 transaction_id,
      int64 object_store_id,
      int64 index_id,
      IDBKeyRange key_range,
      bool key_only)
    => (IDBDatabaseGetResult result);
  GetAll(int64 transaction_id,
         int64 object_store_id,
         int64 index_id,
         IDBKeyRange key_range,
         bool key_only,
         int64 max_count)
    => (pending_receiver<IDBDatabaseGetAllResultSink> receiver);
  SetIndexKeys(int64 transaction_id,
               int64 object_store_id,
               IDBKey primary_key,
               array<IDBIndexKeys> index_keys);
  SetIndexesReady(int64 transaction_id,
                  int64 object_store_id,
                  array<int64> index_ids);
  OpenCursor(int64 transaction_id,
             int64 object_store_id,
             int64 index_id,
             IDBKeyRange key_range,
             IDBCursorDirection direction,
             bool key_only,
             IDBTaskType task_type)
    => (IDBDatabaseOpenCursorResult result);
  Count(int64 transaction_id,
        int64 object_store_id,
        int64 index_id,
        IDBKeyRange key_range,
        pending_associated_remote<IDBCallbacks> pending_callbacks);
  DeleteRange(int64 transaction_id,
              int64 object_store_id,
              IDBKeyRange key_range,
              pending_associated_remote<IDBCallbacks> pending_callbacks);
  // Gets the current number of an IndexedDB ObjectStore's key generator. It
  // is implemented in the browser (more priviledged) and handles requests in
  // the renderer process: WebIDBDatabaseImpl::GetKeyGeneratorCurrentNumber()
  GetKeyGeneratorCurrentNumber(int64 transaction_id,
                               int64 object_store_id,
                               pending_associated_remote<IDBCallbacks> pending_callbacks);
  Clear(int64 transaction_id,
        int64 object_store_id,
        pending_associated_remote<IDBCallbacks> pending_callbacks);
  CreateIndex(int64 transaction_id,
              int64 object_store_id,
              int64 index_id,
              mojo_base.mojom.String16 name,
              IDBKeyPath key_path,
              bool unique,
              bool multi_entry);
  DeleteIndex(int64 transaction_id,
              int64 object_store_id,
              int64 index_id);
  RenameIndex(int64 transaction_id,
              int64 object_store_id,
              int64 index_id,
              mojo_base.mojom.String16 new_name);
  Abort(int64 transaction_id);
};

interface IDBFactory {
  // Gets high level info about databases that exist in the frame's
  // origin. Posts results to |pending_callbacks|.
  GetDatabaseInfo(pending_associated_remote<IDBCallbacks> pending_callbacks);

  // Opens a database |name| in the frame's origin at version |version|.
  // |version_change_transaction_receiver| will have version change
  // transaction operations posted to it. |transaction_id| corresponds
  // to the transaction number for this connection's context.
  // Posts request events and results to |pending_callbacks| and database-level
  // events and results to |database_callbacks|.
  Open(pending_associated_remote<IDBCallbacks> pending_callbacks,
       pending_associated_remote<IDBDatabaseCallbacks> database_callbacks,
       mojo_base.mojom.String16 name,
       int64 version,
       pending_associated_receiver<IDBTransaction> version_change_transaction_receiver,
       int64 transaction_id);

  // Deletes a database |name| in the frame's origin. If |force_close|
  // is true, any existing connections to that database will be closed
  // immediately.
  DeleteDatabase(pending_associated_remote<IDBCallbacks> pending_callbacks,
                 mojo_base.mojom.String16 name, bool force_close);

  AbortTransactionsAndCompactDatabase() => (IDBStatus status);
  AbortTransactionsForDatabase() => (IDBStatus status);
};