IndexedDB: Remap Blink variant metadata typemaps to modules types

Bug: 717812
Change-Id: I6d53865348171ba2fe777a8730b08248d05e7f26
Reviewed-on: https://chromium-review.googlesource.com/c/1344222
Commit-Queue: Chase Phillips <cmp@chromium.org>
Reviewed-by: Daniel Murphy <dmurph@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Cr-Commit-Position: refs/heads/master@{#613193}

third_party/blink/common/indexeddb/indexed_db_default_mojom_traits.cc

@@ -26,16 +26,16 @@ bool StructTraits<blink::mojom::IDBDatabaseMetadataDataView,
     return false;
   out->version = data.version();
   out->max_object_store_id = data.max_object_store_id();
-  ArrayDataView<blink::mojom::IDBObjectStoreMetadataDataView> object_stores;
+  MapDataView<int64_t, blink::mojom::IDBObjectStoreMetadataDataView>
+      object_stores;
   data.GetObjectStoresDataView(&object_stores);
   for (size_t i = 0; i < object_stores.size(); ++i) {
-    blink::mojom::IDBObjectStoreMetadataDataView object_store;
-    object_stores.GetDataView(i, &object_store);
-    DCHECK(!base::ContainsKey(out->object_stores, object_store.id()));
-    if (!StructTraits<blink::mojom::IDBObjectStoreMetadataDataView,
-                      blink::IndexedDBObjectStoreMetadata>::
-            Read(object_store, &out->object_stores[object_store.id()]))
+    const int64_t key = object_stores.keys()[i];
+    blink::IndexedDBObjectStoreMetadata object_store;
+    if (!object_stores.values().Read(i, &object_store))
       return false;
+    DCHECK_EQ(out->object_stores.count(key), 0UL);
+    out->object_stores[key] = object_store;
   }
   return true;
 }
@@ -231,17 +231,15 @@ bool StructTraits<blink::mojom::IDBObjectStoreMetadataDataView,
     return false;
   out->auto_increment = data.auto_increment();
   out->max_index_id = data.max_index_id();
-  ArrayDataView<blink::mojom::IDBIndexMetadataDataView> indexes;
+  MapDataView<int64_t, blink::mojom::IDBIndexMetadataDataView> indexes;
   data.GetIndexesDataView(&indexes);
   for (size_t i = 0; i < indexes.size(); ++i) {
-    blink::mojom::IDBIndexMetadataDataView index;
-    indexes.GetDataView(i, &index);
-    DCHECK(!base::ContainsKey(out->indexes, index.id()));
-    if (!StructTraits<
-            blink::mojom::IDBIndexMetadataDataView,
-            blink::IndexedDBIndexMetadata>::Read(index,
-                                                 &out->indexes[index.id()]))
+    const int64_t key = indexes.keys()[i];
+    blink::IndexedDBIndexMetadata index;
+    if (!indexes.values().Read(i, &index))
       return false;
+    DCHECK_EQ(out->indexes.count(key), 0UL);
+    out->indexes[key] = index;
   }
   return true;
 }

third_party/blink/public/BUILD.gn

@@ -136,7 +136,6 @@ source_set("blink_headers") {
     "platform/modules/indexeddb/web_idb_key.h",
     "platform/modules/indexeddb/web_idb_key_path.h",
     "platform/modules/indexeddb/web_idb_key_range.h",
-    "platform/modules/indexeddb/web_idb_metadata.h",
     "platform/modules/indexeddb/web_idb_name_and_version.h",
     "platform/modules/indexeddb/web_idb_observation.h",
     "platform/modules/indexeddb/web_idb_value.h",

third_party/blink/public/common/indexeddb/indexed_db_default_mojom_traits.h

@@ -30,9 +30,9 @@ struct BLINK_COMMON_EXPORT
       const blink::IndexedDBDatabaseMetadata& metadata) {
     return metadata.max_object_store_id;
   }
-  static MapValuesArrayView<int64_t, blink::IndexedDBObjectStoreMetadata>
-  object_stores(const blink::IndexedDBDatabaseMetadata& metadata) {
-    return MapValuesToArray(metadata.object_stores);
+  static std::map<int64_t, blink::IndexedDBObjectStoreMetadata> object_stores(
+      const blink::IndexedDBDatabaseMetadata& metadata) {
+    return metadata.object_stores;
   }
   static bool Read(blink::mojom::IDBDatabaseMetadataDataView data,
                    blink::IndexedDBDatabaseMetadata* out);
@@ -171,9 +171,9 @@ struct BLINK_COMMON_EXPORT
       const blink::IndexedDBObjectStoreMetadata& metadata) {
     return metadata.max_index_id;
   }
-  static MapValuesArrayView<int64_t, blink::IndexedDBIndexMetadata> indexes(
+  static std::map<int64_t, blink::IndexedDBIndexMetadata> indexes(
       const blink::IndexedDBObjectStoreMetadata& metadata) {
-    return MapValuesToArray(metadata.indexes);
+    return metadata.indexes;
   }
   static bool Read(blink::mojom::IDBObjectStoreMetadataDataView data,
                    blink::IndexedDBObjectStoreMetadata* out);

third_party/blink/public/mojom/indexeddb/indexeddb.mojom

@@ -120,7 +120,7 @@ struct IDBObjectStoreMetadata {
   IDBKeyPath key_path;
   bool auto_increment;
   int64 max_index_id;
-  array<IDBIndexMetadata> indexes;
+  map<int64, IDBIndexMetadata> indexes;
 };
 
 struct IDBDatabaseMetadata {
@@ -128,7 +128,7 @@ struct IDBDatabaseMetadata {
   mojo_base.mojom.String16 name;
   int64 version;
   int64 max_object_store_id;
-  array<IDBObjectStoreMetadata> object_stores;
+  map<int64, IDBObjectStoreMetadata> object_stores;
 };
 
 struct IDBNameAndVersion {

third_party/blink/public/platform/modules/indexeddb/web_idb_callbacks.h

@@ -33,11 +33,11 @@
 
 namespace blink {
 
+struct IDBDatabaseMetadata;
 class WebIDBCursor;
 class WebIDBDatabase;
 class WebIDBDatabaseError;
 class WebIDBKey;
-struct WebIDBMetadata;
 struct WebIDBNameAndVersion;
 class WebIDBValue;
 
@@ -53,7 +53,7 @@ class WebIDBCallbacks {
                          WebIDBKey,
                          WebIDBKey primary_key,
                          WebIDBValue) = 0;
-  virtual void OnSuccess(WebIDBDatabase*, const WebIDBMetadata&) = 0;
+  virtual void OnSuccess(WebIDBDatabase*, const IDBDatabaseMetadata&) = 0;
   virtual void OnSuccess(WebIDBKey) = 0;
   virtual void OnSuccess(WebIDBValue) = 0;
   virtual void OnSuccess(WebVector<WebIDBValue>) = 0;
@@ -63,7 +63,7 @@ class WebIDBCallbacks {
   virtual void OnBlocked(long long old_version) = 0;
   virtual void OnUpgradeNeeded(long long old_version,
                                WebIDBDatabase*,
-                               const WebIDBMetadata&,
+                               const IDBDatabaseMetadata&,
                                mojom::IDBDataLoss data_loss,
                                WebString data_loss_message) = 0;
   virtual void Detach() = 0;

third_party/blink/public/platform/modules/indexeddb/web_idb_metadata.h

-/*
- * Copyright (C) 2012 Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1.  Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- * 2.  Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_INDEXEDDB_WEB_IDB_METADATA_H_
-#define THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_INDEXEDDB_WEB_IDB_METADATA_H_
-
-#include "third_party/blink/public/platform/modules/indexeddb/web_idb_key_path.h"
-#include "third_party/blink/public/platform/web_common.h"
-#include "third_party/blink/public/platform/web_string.h"
-#include "third_party/blink/public/platform/web_vector.h"
-
-namespace blink {
-
-struct WebIDBMetadata {
-  enum { kNoVersion = -1 };
-  struct Index;
-  struct ObjectStore;
-
-  WebString name;
-  long long version;
-  long long id;
-  long long max_object_store_id;
-  WebVector<ObjectStore> object_stores;
-  WebIDBMetadata() : version(kNoVersion) {}
-
-  struct ObjectStore {
-    WebString name;
-    WebIDBKeyPath key_path;
-    bool auto_increment;
-    long long id;
-    long long max_index_id;
-    WebVector<Index> indexes;
-    ObjectStore()
-        : key_path(WebIDBKeyPath::CreateNull()), auto_increment(false) {}
-  };
-
-  struct Index {
-    WebString name;
-    WebIDBKeyPath key_path;
-    bool unique;
-    bool multi_entry;
-    long long id;
-    Index()
-        : key_path(WebIDBKeyPath::CreateNull()),
-          unique(false),
-          multi_entry(false) {}
-  };
-};
-
-}  // namespace blink
-
-#endif  // THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_INDEXEDDB_WEB_IDB_METADATA_H_

third_party/blink/renderer/modules/indexeddb/idb_factory.cc

@@ -135,7 +135,7 @@ class WebIDBGetDBNamesCallbacksImpl : public WebIDBCallbacks {
   }
 
   void OnSuccess(WebIDBDatabase* backend,
-                 const WebIDBMetadata& metadata) override {
+                 const IDBDatabaseMetadata& metadata) override {
     NOTREACHED();
   }
 
@@ -159,7 +159,7 @@ class WebIDBGetDBNamesCallbacksImpl : public WebIDBCallbacks {
 
   void OnUpgradeNeeded(long long old_version,
                        WebIDBDatabase* database,
-                       const WebIDBMetadata& metadata,
+                       const IDBDatabaseMetadata& metadata,
                        mojom::IDBDataLoss data_loss,
                        WebString data_loss_message) override {
     NOTREACHED();

third_party/blink/renderer/modules/indexeddb/idb_metadata.cc

@@ -4,9 +4,6 @@
 
 #include "third_party/blink/renderer/modules/indexeddb/idb_metadata.h"
 
-#include "third_party/blink/public/platform/modules/indexeddb/web_idb_metadata.h"
-#include "third_party/blink/renderer/platform/wtf/assertions.h"
-
 namespace blink {
 
 constexpr int64_t IDBIndexMetadata::kInvalidId;
@@ -26,6 +23,11 @@ IDBIndexMetadata::IDBIndexMetadata(const String& name,
       unique(unique),
       multi_entry(multi_entry) {}
 
+// static
+scoped_refptr<IDBIndexMetadata> IDBIndexMetadata::Create() {
+  return base::AdoptRef(new IDBIndexMetadata());
+}
+
 IDBObjectStoreMetadata::IDBObjectStoreMetadata() = default;
 
 IDBObjectStoreMetadata::IDBObjectStoreMetadata(const String& name,
@@ -39,6 +41,11 @@ IDBObjectStoreMetadata::IDBObjectStoreMetadata(const String& name,
       auto_increment(auto_increment),
       max_index_id(max_index_id) {}
 
+// static
+scoped_refptr<IDBObjectStoreMetadata> IDBObjectStoreMetadata::Create() {
+  return base::AdoptRef(new IDBObjectStoreMetadata());
+}
+
 scoped_refptr<IDBObjectStoreMetadata> IDBObjectStoreMetadata::CreateCopy()
     const {
   scoped_refptr<IDBObjectStoreMetadata> copy =
@@ -67,32 +74,6 @@ IDBDatabaseMetadata::IDBDatabaseMetadata(const String& name,
       version(version),
       max_object_store_id(max_object_store_id) {}
 
-IDBDatabaseMetadata::IDBDatabaseMetadata(const WebIDBMetadata& web_metadata)
-    : name(web_metadata.name),
-      id(web_metadata.id),
-      version(web_metadata.version),
-      max_object_store_id(web_metadata.max_object_store_id) {
-  for (size_t i = 0; i < web_metadata.object_stores.size(); ++i) {
-    const WebIDBMetadata::ObjectStore& web_object_store =
-        web_metadata.object_stores[i];
-    scoped_refptr<IDBObjectStoreMetadata> object_store =
-        base::AdoptRef(new IDBObjectStoreMetadata(
-            web_object_store.name, web_object_store.id,
-            IDBKeyPath(web_object_store.key_path),
-            web_object_store.auto_increment, web_object_store.max_index_id));
-
-    for (size_t j = 0; j < web_object_store.indexes.size(); ++j) {
-      const WebIDBMetadata::Index& web_index = web_object_store.indexes[j];
-      scoped_refptr<IDBIndexMetadata> index =
-          base::AdoptRef(new IDBIndexMetadata(
-              web_index.name, web_index.id, IDBKeyPath(web_index.key_path),
-              web_index.unique, web_index.multi_entry));
-      object_store->indexes.Set(web_index.id, std::move(index));
-    }
-    object_stores.Set(web_object_store.id, std::move(object_store));
-  }
-}
-
 void IDBDatabaseMetadata::CopyFrom(const IDBDatabaseMetadata& metadata) {
   name = metadata.name;
   id = metadata.id;
@@ -100,6 +81,4 @@ void IDBDatabaseMetadata::CopyFrom(const IDBDatabaseMetadata& metadata) {
   max_object_store_id = metadata.max_object_store_id;
 }
 
-STATIC_ASSERT_ENUM(WebIDBMetadata::kNoVersion, IDBDatabaseMetadata::kNoVersion);
-
 }  // namespace blink

third_party/blink/renderer/modules/indexeddb/idb_metadata.h

@@ -30,7 +30,6 @@
 #define THIRD_PARTY_BLINK_RENDERER_MODULES_INDEXEDDB_IDB_METADATA_H_
 
 #include "base/memory/scoped_refptr.h"
-#include "third_party/blink/public/platform/modules/indexeddb/web_idb_metadata.h"
 #include "third_party/blink/renderer/modules/indexeddb/idb_key_path.h"
 #include "third_party/blink/renderer/platform/wtf/allocator.h"
 #include "third_party/blink/renderer/platform/wtf/hash_map.h"
@@ -58,6 +57,8 @@ class IDBIndexMetadata : public RefCounted<IDBIndexMetadata> {
                    bool unique,
                    bool multi_entry);
 
+  static scoped_refptr<IDBIndexMetadata> Create();
+
   String name;
   int64_t id;
   IDBKeyPath key_path;
@@ -79,6 +80,8 @@ class MODULES_EXPORT IDBObjectStoreMetadata
                          bool auto_increment,
                          int64_t max_index_id);
 
+  static scoped_refptr<IDBObjectStoreMetadata> Create();
+
   // Creates a deep copy of the object metadata, which includes copies of index
   // metadata items.
   scoped_refptr<IDBObjectStoreMetadata> CreateCopy() const;
@@ -103,8 +106,6 @@ struct MODULES_EXPORT IDBDatabaseMetadata {
                       int64_t version,
                       int64_t max_object_store_id);
 
-  explicit IDBDatabaseMetadata(const WebIDBMetadata&);
-
   // Overwrites the database metadata, but does not change the object store and
   // index metadata.
   void CopyFrom(const IDBDatabaseMetadata&);

third_party/blink/renderer/modules/indexeddb/idb_request_test.cc

@@ -243,7 +243,7 @@ TEST_F(IDBRequestTest, ConnectionsAfterStopping) {
   const int64_t kTransactionId = 1234;
   const int64_t kVersion = 1;
   const int64_t kOldVersion = 0;
-  const WebIDBMetadata metadata;
+  const IDBDatabaseMetadata metadata;
   Persistent<IDBDatabaseCallbacks> callbacks = IDBDatabaseCallbacks::Create();
 
   {

third_party/blink/renderer/modules/indexeddb/indexed_db_blink.typemap

@@ -8,9 +8,9 @@ public_headers = [
   "//third_party/blink/public/platform/modules/indexeddb/web_idb_key.h",
   "//third_party/blink/public/platform/modules/indexeddb/web_idb_key_path.h",
   "//third_party/blink/public/platform/modules/indexeddb/web_idb_key_range.h",
-  "//third_party/blink/public/platform/modules/indexeddb/web_idb_metadata.h",
   "//third_party/blink/public/platform/modules/indexeddb/web_idb_name_and_version.h",
   "//third_party/blink/renderer/modules/indexeddb/idb_key_range.h",
+  "//third_party/blink/renderer/modules/indexeddb/idb_metadata.h",
 ]
 traits_headers = [
   "//mojo/public/cpp/base/string16_mojom_traits.h",
@@ -25,11 +25,11 @@ deps = [
   "//third_party/blink/renderer/platform/wtf",
 ]
 type_mappings = [
-  "blink.mojom.IDBDatabaseMetadata=::blink::WebIDBMetadata",
+  "blink.mojom.IDBDatabaseMetadata=::blink::IDBDatabaseMetadata",
   "blink.mojom.IDBIndexKeys=::blink::WebIDBIndexKeys",
-  "blink.mojom.IDBIndexMetadata=::blink::WebIDBMetadata::Index",
+  "blink.mojom.IDBIndexMetadata=scoped_refptr<::blink::IDBIndexMetadata>",
   "blink.mojom.IDBKey=::blink::WebIDBKey[move_only]",
-  "blink.mojom.IDBKeyPath=::blink::WebIDBKeyPath",
+  "blink.mojom.IDBKeyPath=::blink::IDBKeyPath",
   "blink.mojom.IDBKeyRange=::blink::WebIDBKeyRange",
-  "blink.mojom.IDBObjectStoreMetadata=::blink::WebIDBMetadata::ObjectStore",
+  "blink.mojom.IDBObjectStoreMetadata=scoped_refptr<::blink::IDBObjectStoreMetadata>",
 ]

third_party/blink/renderer/modules/indexeddb/indexed_db_blink_mojom_traits.cc

@@ -10,7 +10,6 @@
 #include "third_party/blink/public/common/indexeddb/indexed_db_default_mojom_traits.h"
 #include "third_party/blink/public/common/indexeddb/indexeddb_key.h"
 #include "third_party/blink/public/common/indexeddb/indexeddb_key_range.h"
-#include "third_party/blink/public/common/indexeddb/indexeddb_metadata.h"
 #include "third_party/blink/renderer/modules/indexeddb/idb_key_range.h"
 #include "third_party/blink/renderer/platform/mojo/string16_mojom_traits.h"
 #include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
@@ -23,10 +22,10 @@ using blink::mojom::IDBOperationType;
 namespace mojo {
 
 // static
-bool StructTraits<
-    blink::mojom::IDBDatabaseMetadataDataView,
-    blink::WebIDBMetadata>::Read(blink::mojom::IDBDatabaseMetadataDataView data,
-                                 blink::WebIDBMetadata* out) {
+bool StructTraits<blink::mojom::IDBDatabaseMetadataDataView,
+                  blink::IDBDatabaseMetadata>::
+    Read(blink::mojom::IDBDatabaseMetadataDataView data,
+         blink::IDBDatabaseMetadata* out) {
   out->id = data.id();
   String name;
   if (!data.ReadName(&name))
@@ -34,8 +33,19 @@ bool StructTraits<
   out->name = name;
   out->version = data.version();
   out->max_object_store_id = data.max_object_store_id();
-  if (!data.ReadObjectStores(&out->object_stores))
+  MapDataView<int64_t, blink::mojom::IDBObjectStoreMetadataDataView>
+      object_stores;
+  data.GetObjectStoresDataView(&object_stores);
+  out->object_stores.ReserveCapacityForSize(object_stores.size());
+  for (size_t i = 0; i < object_stores.size(); ++i) {
+    const int64_t key = object_stores.keys()[i];
+    scoped_refptr<blink::IDBObjectStoreMetadata> object_store;
+    if (!object_stores.values().Read(i, &object_store)) {
       return false;
+    }
+    DCHECK(!out->object_stores.Contains(key));
+    out->object_stores.insert(key, object_store);
+  }
   return true;
 }
 
@@ -50,18 +60,21 @@ bool StructTraits<blink::mojom::IDBIndexKeysDataView, blink::WebIDBIndexKeys>::
 
 // static
 bool StructTraits<blink::mojom::IDBIndexMetadataDataView,
-                  blink::WebIDBMetadata::Index>::
+                  scoped_refptr<blink::IDBIndexMetadata>>::
     Read(blink::mojom::IDBIndexMetadataDataView data,
-         blink::WebIDBMetadata::Index* out) {
-  out->id = data.id();
+         scoped_refptr<blink::IDBIndexMetadata>* out) {
+  scoped_refptr<blink::IDBIndexMetadata> value =
+      blink::IDBIndexMetadata::Create();
+  value->id = data.id();
   String name;
   if (!data.ReadName(&name))
     return false;
-  out->name = name;
-  if (!data.ReadKeyPath(&out->key_path))
+  value->name = name;
+  if (!data.ReadKeyPath(&value->key_path))
     return false;
-  out->unique = data.unique();
-  out->multi_entry = data.multi_entry();
+  value->unique = data.unique();
+  value->multi_entry = data.multi_entry();
+  *out = std::move(value);
   return true;
 }
 
@@ -191,21 +204,21 @@ bool StructTraits<blink::mojom::IDBKeyDataView, blink::WebIDBKey>::Read(
 
 // static
 blink::mojom::blink::IDBKeyPathDataPtr
-StructTraits<blink::mojom::IDBKeyPathDataView, blink::WebIDBKeyPath>::data(
-    const blink::WebIDBKeyPath& key_path) {
-  if (key_path.KeyPathType() == blink::kWebIDBKeyPathTypeNull)
+StructTraits<blink::mojom::IDBKeyPathDataView, blink::IDBKeyPath>::data(
+    const blink::IDBKeyPath& key_path) {
+  if (key_path.GetType() == blink::IDBKeyPath::Type::kNullType)
     return nullptr;
 
   auto data = blink::mojom::blink::IDBKeyPathData::New();
-  switch (key_path.KeyPathType()) {
-    case blink::kWebIDBKeyPathTypeString: {
-      String key_path_string = key_path.String();
+  switch (key_path.GetType()) {
+    case blink::IDBKeyPath::Type::kStringType: {
+      String key_path_string = key_path.GetString();
       if (key_path_string.IsNull())
         key_path_string = g_empty_string;
       data->set_string(key_path_string);
       return data;
     }
-    case blink::kWebIDBKeyPathTypeArray: {
+    case blink::IDBKeyPath::Type::kArrayType: {
       const auto& array = key_path.Array();
       Vector<String> result;
       result.ReserveInitialCapacity(SafeCast<wtf_size_t>(array.size()));
@@ -215,7 +228,7 @@ StructTraits<blink::mojom::IDBKeyPathDataView, blink::WebIDBKeyPath>::data(
       return data;
     }
 
-    case blink::kWebIDBKeyPathTypeNull:
+    case blink::IDBKeyPath::Type::kNullType:
       break;  // Not used, NOTREACHED.
   }
   NOTREACHED();
@@ -223,14 +236,14 @@ StructTraits<blink::mojom::IDBKeyPathDataView, blink::WebIDBKeyPath>::data(
 }
 
 // static
-bool StructTraits<blink::mojom::IDBKeyPathDataView, blink::WebIDBKeyPath>::Read(
+bool StructTraits<blink::mojom::IDBKeyPathDataView, blink::IDBKeyPath>::Read(
     blink::mojom::IDBKeyPathDataView data,
-    blink::WebIDBKeyPath* out) {
+    blink::IDBKeyPath* out) {
   blink::mojom::IDBKeyPathDataDataView data_view;
   data.GetDataDataView(&data_view);
 
   if (data_view.is_null()) {
-    *out = blink::WebIDBKeyPath();
+    *out = blink::IDBKeyPath();
     return true;
   }
 
@@ -239,14 +252,14 @@ bool StructTraits<blink::mojom::IDBKeyPathDataView, blink::WebIDBKeyPath>::Read(
       String string;
       if (!data_view.ReadString(&string))
         return false;
-      *out = blink::WebIDBKeyPath(blink::WebString(string));
+      *out = blink::IDBKeyPath(string);
       return true;
     }
     case blink::mojom::IDBKeyPathDataDataView::Tag::STRING_ARRAY: {
       Vector<String> array;
       if (!data_view.ReadStringArray(&array))
         return false;
-      *out = blink::WebIDBKeyPath(array);
+      *out = blink::IDBKeyPath(array);
       return true;
     }
   }
@@ -271,20 +284,32 @@ bool StructTraits<blink::mojom::IDBKeyRangeDataView, blink::WebIDBKeyRange>::
 
 // static
 bool StructTraits<blink::mojom::IDBObjectStoreMetadataDataView,
-                  blink::WebIDBMetadata::ObjectStore>::
+                  scoped_refptr<blink::IDBObjectStoreMetadata>>::
     Read(blink::mojom::IDBObjectStoreMetadataDataView data,
-         blink::WebIDBMetadata::ObjectStore* out) {
-  out->id = data.id();
+         scoped_refptr<blink::IDBObjectStoreMetadata>* out) {
+  scoped_refptr<blink::IDBObjectStoreMetadata> value =
+      blink::IDBObjectStoreMetadata::Create();
+  value->id = data.id();
   String name;
   if (!data.ReadName(&name))
     return false;
-  out->name = name;
-  if (!data.ReadKeyPath(&out->key_path))
+  value->name = name;
+  if (!data.ReadKeyPath(&value->key_path))
     return false;
-  out->auto_increment = data.auto_increment();
-  out->max_index_id = data.max_index_id();
-  if (!data.ReadIndexes(&out->indexes))
+  value->auto_increment = data.auto_increment();
+  value->max_index_id = data.max_index_id();
+  MapDataView<int64_t, blink::mojom::IDBIndexMetadataDataView> indexes;
+  data.GetIndexesDataView(&indexes);
+  value->indexes.ReserveCapacityForSize(indexes.size());
+  for (size_t i = 0; i < indexes.size(); ++i) {
+    const int64_t key = indexes.keys()[i];
+    scoped_refptr<blink::IDBIndexMetadata> index;
+    if (!indexes.values().Read(i, &index))
       return false;
+    DCHECK(!value->indexes.Contains(key));
+    value->indexes.insert(key, index);
+  }
+  *out = std::move(value);
   return true;
 }
 

third_party/blink/renderer/modules/indexeddb/indexed_db_blink_mojom_traits.h

@@ -7,6 +7,7 @@
 
 #include <stdint.h>
 
+#include "mojo/public/cpp/bindings/map_traits_wtf_hash_map.h"
 #include "third_party/blink/public/common/indexeddb/indexeddb_key.h"
 #include "third_party/blink/public/common/indexeddb/indexeddb_key_range.h"
 #include "third_party/blink/public/common/indexeddb/indexeddb_metadata.h"
@@ -14,8 +15,8 @@
 #include "third_party/blink/public/platform/modules/indexeddb/indexed_db_key_builder.h"
 #include "third_party/blink/public/platform/modules/indexeddb/web_idb_key.h"
 #include "third_party/blink/public/platform/modules/indexeddb/web_idb_key_range.h"
-#include "third_party/blink/public/platform/modules/indexeddb/web_idb_metadata.h"
 #include "third_party/blink/public/platform/web_vector.h"
+#include "third_party/blink/renderer/modules/indexeddb/idb_metadata.h"
 #include "third_party/blink/renderer/modules/modules_export.h"
 #include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"
 
@@ -23,27 +24,28 @@ namespace mojo {
 
 template <>
 struct MODULES_EXPORT StructTraits<blink::mojom::IDBDatabaseMetadataDataView,
-                                   blink::WebIDBMetadata> {
-  static int64_t id(const blink::WebIDBMetadata& metadata) {
+                                   blink::IDBDatabaseMetadata> {
+  static int64_t id(const blink::IDBDatabaseMetadata& metadata) {
     return metadata.id;
   }
-  static WTF::String name(const blink::WebIDBMetadata& metadata) {
+  static WTF::String name(const blink::IDBDatabaseMetadata& metadata) {
     if (metadata.name.IsNull())
       return g_empty_string;
     return metadata.name;
   }
-  static int64_t version(const blink::WebIDBMetadata& metadata) {
+  static int64_t version(const blink::IDBDatabaseMetadata& metadata) {
     return metadata.version;
   }
-  static int64_t max_object_store_id(const blink::WebIDBMetadata& metadata) {
+  static int64_t max_object_store_id(
+      const blink::IDBDatabaseMetadata& metadata) {
     return metadata.max_object_store_id;
   }
-  static const blink::WebVector<blink::WebIDBMetadata::ObjectStore>&
-  object_stores(const blink::WebIDBMetadata& metadata) {
+  static const HashMap<int64_t, scoped_refptr<blink::IDBObjectStoreMetadata>>&
+  object_stores(const blink::IDBDatabaseMetadata& metadata) {
     return metadata.object_stores;
   }
   static bool Read(blink::mojom::IDBDatabaseMetadataDataView data,
-                   blink::WebIDBMetadata* out);
+                   blink::IDBDatabaseMetadata* out);
 };
 
 template <>
@@ -62,27 +64,29 @@ struct MODULES_EXPORT
 
 template <>
 struct MODULES_EXPORT StructTraits<blink::mojom::IDBIndexMetadataDataView,
-                                   blink::WebIDBMetadata::Index> {
-  static int64_t id(const blink::WebIDBMetadata::Index& metadata) {
-    return metadata.id;
+                                   scoped_refptr<blink::IDBIndexMetadata>> {
+  static int64_t id(const scoped_refptr<blink::IDBIndexMetadata>& metadata) {
+    return metadata->id;
   }
-  static WTF::String name(const blink::WebIDBMetadata::Index& metadata) {
-    if (metadata.name.IsNull())
+  static WTF::String name(
+      const scoped_refptr<blink::IDBIndexMetadata>& metadata) {
+    if (metadata->name.IsNull())
       return g_empty_string;
-    return metadata.name;
+    return metadata->name;
   }
-  static const blink::WebIDBKeyPath& key_path(
-      const blink::WebIDBMetadata::Index& metadata) {
-    return metadata.key_path;
+  static const blink::IDBKeyPath& key_path(
+      const scoped_refptr<blink::IDBIndexMetadata>& metadata) {
+    return metadata->key_path;
   }
-  static bool unique(const blink::WebIDBMetadata::Index& metadata) {
-    return metadata.unique;
+  static bool unique(const scoped_refptr<blink::IDBIndexMetadata>& metadata) {
+    return metadata->unique;
   }
-  static bool multi_entry(const blink::WebIDBMetadata::Index& metadata) {
-    return metadata.multi_entry;
+  static bool multi_entry(
+      const scoped_refptr<blink::IDBIndexMetadata>& metadata) {
+    return metadata->multi_entry;
   }
   static bool Read(blink::mojom::IDBIndexMetadataDataView data,
-                   blink::WebIDBMetadata::Index* out);
+                   scoped_refptr<blink::IDBIndexMetadata>* out);
 };
 
 template <>
@@ -127,11 +131,11 @@ struct MODULES_EXPORT
 
 template <>
 struct MODULES_EXPORT
-    StructTraits<blink::mojom::IDBKeyPathDataView, blink::WebIDBKeyPath> {
+    StructTraits<blink::mojom::IDBKeyPathDataView, blink::IDBKeyPath> {
   static blink::mojom::blink::IDBKeyPathDataPtr data(
-      const blink::WebIDBKeyPath& key_path);
+      const blink::IDBKeyPath& key_path);
   static bool Read(blink::mojom::IDBKeyPathDataView data,
-                   blink::WebIDBKeyPath* out);
+                   blink::IDBKeyPath* out);
 };
 
 template <>
@@ -154,32 +158,37 @@ struct MODULES_EXPORT
 };
 
 template <>
-struct MODULES_EXPORT StructTraits<blink::mojom::IDBObjectStoreMetadataDataView,
-                                   blink::WebIDBMetadata::ObjectStore> {
-  static int64_t id(const blink::WebIDBMetadata::ObjectStore& metadata) {
-    return metadata.id;
-  }
-  static WTF::String name(const blink::WebIDBMetadata::ObjectStore& metadata) {
-    return metadata.name;
+struct MODULES_EXPORT
+    StructTraits<blink::mojom::IDBObjectStoreMetadataDataView,
+                 scoped_refptr<blink::IDBObjectStoreMetadata>> {
+  static int64_t id(
+      const scoped_refptr<blink::IDBObjectStoreMetadata>& metadata) {
+    return metadata->id;
+  }
+  static WTF::String name(
+      const scoped_refptr<blink::IDBObjectStoreMetadata>& metadata) {
+    if (metadata->name.IsNull())
+      return g_empty_string;
+    return metadata->name;
   }
-  static const blink::WebIDBKeyPath& key_path(
-      const blink::WebIDBMetadata::ObjectStore& metadata) {
-    return metadata.key_path;
+  static const blink::IDBKeyPath& key_path(
+      const scoped_refptr<blink::IDBObjectStoreMetadata>& metadata) {
+    return metadata->key_path;
   }
   static bool auto_increment(
-      const blink::WebIDBMetadata::ObjectStore& metadata) {
-    return metadata.auto_increment;
+      const scoped_refptr<blink::IDBObjectStoreMetadata>& metadata) {
+    return metadata->auto_increment;
   }
   static int64_t max_index_id(
-      const blink::WebIDBMetadata::ObjectStore& metadata) {
-    return metadata.max_index_id;
+      const scoped_refptr<blink::IDBObjectStoreMetadata>& metadata) {
+    return metadata->max_index_id;
   }
-  static const blink::WebVector<blink::WebIDBMetadata::Index>& indexes(
-      const blink::WebIDBMetadata::ObjectStore& metadata) {
-    return metadata.indexes;
+  static const HashMap<int64_t, scoped_refptr<blink::IDBIndexMetadata>>&
+  indexes(const scoped_refptr<blink::IDBObjectStoreMetadata>& metadata) {
+    return metadata->indexes;
   }
   static bool Read(blink::mojom::IDBObjectStoreMetadataDataView data,
-                   blink::WebIDBMetadata::ObjectStore* out);
+                   scoped_refptr<blink::IDBObjectStoreMetadata>* out);
 };
 
 }  // namespace mojo

third_party/blink/renderer/modules/indexeddb/indexed_db_callbacks_impl.cc

@@ -8,7 +8,6 @@
 #include "third_party/blink/public/platform/modules/indexeddb/indexed_db_key_builder.h"
 #include "third_party/blink/public/platform/modules/indexeddb/web_idb_callbacks.h"
 #include "third_party/blink/public/platform/modules/indexeddb/web_idb_database_error.h"
-#include "third_party/blink/public/platform/modules/indexeddb/web_idb_metadata.h"
 #include "third_party/blink/public/platform/modules/indexeddb/web_idb_name_and_version.h"
 #include "third_party/blink/public/platform/modules/indexeddb/web_idb_value.h"
 #include "third_party/blink/renderer/modules/indexeddb/idb_key_range.h"
@@ -21,7 +20,6 @@ using blink::WebBlobInfo;
 using blink::WebData;
 using blink::WebIDBCallbacks;
 using blink::WebIDBDatabase;
-using blink::WebIDBMetadata;
 using blink::WebIDBNameAndVersion;
 using blink::WebIDBValue;
 using blink::WebString;
@@ -125,9 +123,9 @@ void IndexedDBCallbacksImpl::UpgradeNeeded(
     int64_t old_version,
     mojom::IDBDataLoss data_loss,
     const String& data_loss_message,
-    const WebIDBMetadata& web_metadata) {
+    const IDBDatabaseMetadata& metadata) {
   WebIDBDatabase* database = new WebIDBDatabaseImpl(std::move(database_info));
-  callbacks_->OnUpgradeNeeded(old_version, database, web_metadata, data_loss,
+  callbacks_->OnUpgradeNeeded(old_version, database, metadata, data_loss,
                               WebString(data_loss_message));
   // Not resetting |callbacks_|.  In this instance we will have to forward at
   // least one other call in the set OnSuccess() / OnError().
@@ -135,12 +133,12 @@ void IndexedDBCallbacksImpl::UpgradeNeeded(
 
 void IndexedDBCallbacksImpl::SuccessDatabase(
     IDBDatabaseAssociatedPtrInfo database_info,
-    const WebIDBMetadata& web_metadata) {
+    const IDBDatabaseMetadata& metadata) {
   WebIDBDatabase* database = nullptr;
   if (database_info.is_valid())
     database = new WebIDBDatabaseImpl(std::move(database_info));
 
-  callbacks_->OnSuccess(database, web_metadata);
+  callbacks_->OnSuccess(database, metadata);
   callbacks_.reset();
 }
 

third_party/blink/renderer/modules/indexeddb/indexed_db_callbacks_impl.h

@@ -49,9 +49,9 @@ class IndexedDBCallbacksImpl : public mojom::blink::IDBCallbacks {
                      int64_t old_version,
                      mojom::IDBDataLoss data_loss,
                      const String& data_loss_message,
-                     const WebIDBMetadata& metadata) override;
+                     const IDBDatabaseMetadata& metadata) override;
   void SuccessDatabase(mojom::blink::IDBDatabaseAssociatedPtrInfo database_info,
-                       const WebIDBMetadata& metadata) override;
+                       const IDBDatabaseMetadata& metadata) override;
   void SuccessCursor(mojom::blink::IDBCursorAssociatedPtrInfo cursor,
                      WebIDBKey key,
                      WebIDBKey primary_key,

third_party/blink/renderer/modules/indexeddb/mock_web_idb_callbacks.h

@@ -9,11 +9,11 @@
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/blink/public/platform/modules/indexeddb/web_idb_callbacks.h"
 #include "third_party/blink/public/platform/modules/indexeddb/web_idb_database_error.h"
-#include "third_party/blink/public/platform/modules/indexeddb/web_idb_metadata.h"
 #include "third_party/blink/public/platform/modules/indexeddb/web_idb_name_and_version.h"
 #include "third_party/blink/public/platform/modules/indexeddb/web_idb_value.h"
 #include "third_party/blink/public/platform/web_blob_info.h"
 #include "third_party/blink/public/web/web_heap.h"
+#include "third_party/blink/renderer/modules/indexeddb/idb_metadata.h"
 
 namespace blink {
 
@@ -46,7 +46,7 @@ class MockWebIDBCallbacks : public blink::WebIDBCallbacks {
                     const blink::WebIDBValue&));
 
   MOCK_METHOD2(OnSuccess,
-               void(blink::WebIDBDatabase*, const blink::WebIDBMetadata&));
+               void(blink::WebIDBDatabase*, const blink::IDBDatabaseMetadata&));
   void OnSuccess(blink::WebIDBKey) override;
   MOCK_METHOD1(DoOnSuccess, void(const blink::WebIDBKey&));
 
@@ -62,7 +62,7 @@ class MockWebIDBCallbacks : public blink::WebIDBCallbacks {
   MOCK_METHOD5(OnUpgradeNeeded,
                void(long long oldVersion,
                     blink::WebIDBDatabase*,
-                    const blink::WebIDBMetadata&,
+                    const blink::IDBDatabaseMetadata&,
                     mojom::IDBDataLoss dataLoss,
                     blink::WebString dataLossMessage));
   MOCK_METHOD0(Detach, void());

third_party/blink/renderer/modules/indexeddb/web_idb_callbacks_impl.cc

@@ -51,7 +51,6 @@ using blink::WebIDBDatabase;
 using blink::WebIDBDatabaseError;
 using blink::WebIDBKey;
 using blink::WebIDBKeyPath;
-using blink::WebIDBMetadata;
 using blink::WebIDBNameAndVersion;
 using blink::WebIDBValue;
 using blink::WebVector;
@@ -125,7 +124,7 @@ void WebIDBCallbacksImpl::OnSuccess(WebIDBCursor* cursor,
 }
 
 void WebIDBCallbacksImpl::OnSuccess(WebIDBDatabase* backend,
-                                    const WebIDBMetadata& metadata) {
+                                    const IDBDatabaseMetadata& metadata) {
   std::unique_ptr<WebIDBDatabase> db = base::WrapUnique(backend);
   if (request_) {
     probe::AsyncTask async_task(request_->GetExecutionContext(), this,
@@ -214,7 +213,7 @@ void WebIDBCallbacksImpl::OnBlocked(long long old_version) {
 
 void WebIDBCallbacksImpl::OnUpgradeNeeded(long long old_version,
                                           WebIDBDatabase* database,
-                                          const WebIDBMetadata& metadata,
+                                          const IDBDatabaseMetadata& metadata,
                                           mojom::IDBDataLoss data_loss,
                                           WebString data_loss_message) {
   std::unique_ptr<WebIDBDatabase> db = base::WrapUnique(database);

third_party/blink/renderer/modules/indexeddb/web_idb_callbacks_impl.h

@@ -42,7 +42,7 @@ class WebIDBCursor;
 class WebIDBDatabase;
 class WebIDBDatabaseError;
 class WebIDBKey;
-struct WebIDBMetadata;
+struct IDBDatabaseMetadata;
 struct WebIDBNameAndVersion;
 class WebIDBValue;
 
@@ -62,7 +62,7 @@ class WebIDBCallbacksImpl final : public WebIDBCallbacks {
                  WebIDBKey,
                  WebIDBKey primary_key,
                  WebIDBValue) override;
-  void OnSuccess(WebIDBDatabase*, const WebIDBMetadata&) override;
+  void OnSuccess(WebIDBDatabase*, const IDBDatabaseMetadata&) override;
   void OnSuccess(WebIDBKey) override;
   void OnSuccess(WebIDBValue) override;
   void OnSuccess(WebVector<WebIDBValue>) override;
@@ -72,7 +72,7 @@ class WebIDBCallbacksImpl final : public WebIDBCallbacks {
   void OnBlocked(long long old_version) override;
   void OnUpgradeNeeded(long long old_version,
                        WebIDBDatabase*,
-                       const WebIDBMetadata&,
+                       const IDBDatabaseMetadata&,
                        mojom::IDBDataLoss data_loss,
                        WebString data_loss_message) override;
   void Detach() override;

third_party/blink/renderer/modules/indexeddb/web_idb_database.h

@@ -30,7 +30,6 @@
 
 #include "third_party/blink/public/common/indexeddb/web_idb_types.h"
 #include "third_party/blink/public/mojom/indexeddb/indexeddb.mojom-blink.h"
-#include "third_party/blink/public/platform/modules/indexeddb/web_idb_metadata.h"
 #include "third_party/blink/public/platform/web_blob_info.h"
 #include "third_party/blink/renderer/modules/indexeddb/web_idb_cursor.h"
 #include "third_party/blink/renderer/modules/modules_export.h"

third_party/blink/renderer/modules/indexeddb/web_idb_database_impl.cc

@@ -18,7 +18,6 @@
 #include "third_party/blink/public/platform/modules/indexeddb/web_idb_database_error.h"
 #include "third_party/blink/public/platform/modules/indexeddb/web_idb_database_exception.h"
 #include "third_party/blink/public/platform/modules/indexeddb/web_idb_key_path.h"
-#include "third_party/blink/public/platform/modules/indexeddb/web_idb_metadata.h"
 #include "third_party/blink/public/platform/web_blob_info.h"
 #include "third_party/blink/public/platform/web_string.h"
 #include "third_party/blink/public/platform/web_vector.h"