IndexedDB: Remove WebData usage from frontend

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

third_party/blink/renderer/modules/BUILD.gn

@@ -2,8 +2,8 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-import("//build/split_static_library.gni")
 import("//build/config/chromecast_build.gni")
+import("//build/split_static_library.gni")
 import("//third_party/blink/renderer/bindings/bindings.gni")
 import("//third_party/blink/renderer/bindings/modules/v8/generated.gni")
 import("//third_party/blink/renderer/bindings/modules/v8/v8.gni")
@@ -277,6 +277,7 @@ jumbo_source_set("unit_tests") {
     "indexeddb/idb_test_helper.cc",
     "indexeddb/idb_transaction_test.cc",
     "indexeddb/idb_value_wrapping_test.cc",
+    "indexeddb/indexed_db_blink_mojom_traits_test.cc",
     "indexeddb/mock_web_idb_callbacks.cc",
     "indexeddb/mock_web_idb_callbacks.h",
     "indexeddb/mock_web_idb_database.cc",

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

@@ -31,7 +31,6 @@
 #include "base/memory/scoped_refptr.h"
 #include "base/numerics/safe_conversions.h"
 #include "third_party/blink/public/platform/web_blob_info.h"
-#include "third_party/blink/public/platform/web_data.h"
 #include "third_party/blink/public/platform/web_vector.h"
 #include "third_party/blink/renderer/bindings/core/v8/serialization/serialized_script_value_factory.h"
 #include "third_party/blink/renderer/bindings/core/v8/to_v8_for_core.h"
@@ -580,10 +579,10 @@ IDBRequest* IDBObjectStore::DoPut(ScriptState* script_state,
     value_wrapper.WrapIfBiggerThan(IDBValueWrapper::kWrapThreshold);
 
   request->transit_blob_handles() = value_wrapper.TakeBlobDataHandles();
-  BackendDB()->Put(
-      transaction_->Id(), Id(), WebData(value_wrapper.TakeWireBytes()),
-      value_wrapper.TakeBlobInfo(), IDBKey::Clone(key), put_mode,
-      request->CreateWebCallbacks().release(), std::move(index_keys));
+  BackendDB()->Put(transaction_->Id(), Id(), value_wrapper.TakeWireBytes(),
+                   value_wrapper.TakeBlobInfo(), IDBKey::Clone(key), put_mode,
+                   request->CreateWebCallbacks().release(),
+                   std::move(index_keys));
 
   return request;
 }

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

@@ -10,7 +10,6 @@
 #include "base/memory/ptr_util.h"
 #include "base/memory/scoped_refptr.h"
 #include "third_party/blink/public/platform/web_blob_info.h"
-#include "third_party/blink/public/platform/web_data.h"
 #include "third_party/blink/renderer/bindings/core/v8/serialization/serialized_script_value.h"
 #include "third_party/blink/renderer/platform/blob/blob_data.h"
 #include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
@@ -18,7 +17,7 @@
 
 namespace blink {
 
-IDBValue::IDBValue(const WebData& data,
+IDBValue::IDBValue(const scoped_refptr<SharedBuffer>& data,
                    const WebVector<WebBlobInfo>& web_blob_info)
     : data_(data) {
   blob_info_.ReserveInitialCapacity(SafeCast<wtf_size_t>(web_blob_info.size()));
@@ -40,7 +39,7 @@ IDBValue::~IDBValue() {
 }
 
 std::unique_ptr<IDBValue> IDBValue::Create(
-    const WebData& data,
+    const scoped_refptr<SharedBuffer>& data,
     const WebVector<WebBlobInfo>& web_blob_info) {
   return base::WrapUnique(new IDBValue(data, web_blob_info));
 }

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

@@ -9,6 +9,7 @@
 
 #include "base/macros.h"
 #include "base/memory/scoped_refptr.h"
+#include "third_party/blink/public/platform/web_blob_info.h"
 #include "third_party/blink/public/platform/web_vector.h"
 #include "third_party/blink/renderer/modules/indexeddb/idb_key.h"
 #include "third_party/blink/renderer/modules/indexeddb/idb_key_path.h"
@@ -19,7 +20,6 @@ namespace blink {
 
 class BlobDataHandle;
 class SerializedScriptValue;
-class WebData;
 class WebBlobInfo;
 
 // Represents an IndexedDB Object Store value retrieved from the backing store.
@@ -39,7 +39,7 @@ class WebBlobInfo;
 class MODULES_EXPORT IDBValue final {
  public:
   // Creates an IDBValue from backing store information.
-  static std::unique_ptr<IDBValue> Create(const WebData&,
+  static std::unique_ptr<IDBValue> Create(const scoped_refptr<SharedBuffer>&,
                                           const WebVector<WebBlobInfo>&);
 
   // Used by IDBValueUnwrapper tests.
@@ -54,6 +54,7 @@ class MODULES_EXPORT IDBValue final {
   bool IsNull() const;
   scoped_refptr<SerializedScriptValue> CreateSerializedValue() const;
   const Vector<WebBlobInfo>& BlobInfo() const { return blob_info_; }
+  const scoped_refptr<SharedBuffer>& Data() const { return data_; }
   const IDBKey* PrimaryKey() const { return primary_key_.get(); }
   const IDBKeyPath& KeyPath() const { return key_path_; }
 
@@ -92,7 +93,7 @@ class MODULES_EXPORT IDBValue final {
 
   friend class IDBValueUnwrapper;
 
-  IDBValue(const WebData&, const WebVector<WebBlobInfo>&);
+  IDBValue(const scoped_refptr<SharedBuffer>&, const WebVector<WebBlobInfo>&);
   IDBValue(scoped_refptr<SharedBuffer> unwrapped_data,
            Vector<WebBlobInfo>);
 

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

@@ -124,7 +124,7 @@ bool UnionTraits<
     case blink::mojom::IDBKeyDataDataView::Tag::BINARY: {
       ArrayDataView<uint8_t> bytes;
       data.GetBinaryDataView(&bytes);
-      *out = blink::IDBKey::CreateBinary(blink::WebData(
+      *out = blink::IDBKey::CreateBinary(blink::SharedBuffer::Create(
           reinterpret_cast<const char*>(bytes.data()), bytes.size()));
       return true;
     }
@@ -163,16 +163,7 @@ UnionTraits<blink::mojom::IDBKeyDataDataView, std::unique_ptr<blink::IDBKey>>::
 Vector<uint8_t>
 UnionTraits<blink::mojom::IDBKeyDataDataView, std::unique_ptr<blink::IDBKey>>::
     binary(const std::unique_ptr<blink::IDBKey>& key) {
-  const blink::WebData& data = key->Binary();
-  Vector<uint8_t> result;
-  result.ReserveInitialCapacity(SafeCast<wtf_size_t>(data.size()));
-  data.ForEachSegment([&result](const char* segment, size_t segment_size,
-                                size_t segment_offset) {
-    const auto& segment_span = base::make_span(segment, segment + segment_size);
-    result.AppendRange(segment_span.begin(), segment_span.end());
-    return true;
-  });
-  return result;
+  return key->Binary()->CopyAs<Vector<uint8_t>>();
 }
 
 // static

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

+// Copyright 2018 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.
+
+#include "third_party/blink/renderer/modules/indexeddb/indexed_db_blink_mojom_traits.h"
+
+#include <random>
+
+#include "base/macros.h"
+#include "base/memory/scoped_refptr.h"
+#include "mojo/public/cpp/bindings/array_traits_wtf_vector.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/blink/renderer/modules/indexeddb/idb_key.h"
+#include "third_party/blink/renderer/platform/mojo/string16_mojom_traits.h"
+
+namespace blink {
+
+TEST(IDBMojomTraitsTest, IDBKeyBinary) {
+  // Generate test data.
+  std::mt19937 rng(5);
+  size_t test_data_size = 10000;
+  Vector<char> test_data(test_data_size);
+  std::generate(test_data.begin(), test_data.end(), rng);
+
+  // Create IDBKey binary key type mojom message.
+  scoped_refptr<SharedBuffer> input_data =
+      SharedBuffer::Create(test_data.data(), test_data.size());
+  std::unique_ptr<IDBKey> input = IDBKey::CreateBinary(input_data);
+  Vector<uint8_t> input_vector = input_data->CopyAs<Vector<uint8_t>>();
+  mojo::Message mojo_message = mojom::blink::IDBKey::SerializeAsMessage(&input);
+
+  // Deserialize the mojo message.
+  std::unique_ptr<IDBKey> output;
+  ASSERT_TRUE(mojom::blink::IDBKey::DeserializeFromMessage(
+      std::move(mojo_message), &output));
+  scoped_refptr<SharedBuffer> output_data = output->Binary();
+  Vector<uint8_t> output_vector = output_data->CopyAs<Vector<uint8_t>>();
+
+  // Verify expectations.
+  ASSERT_EQ(input_data->size(), test_data_size);
+  ASSERT_EQ(input_vector.size(), test_data_size);
+  ASSERT_EQ(output_data->size(), test_data_size);
+  ASSERT_EQ(output_vector.size(), test_data_size);
+  ASSERT_EQ(input_vector, output_vector);
+}
+
+}  // namespace blink

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

@@ -5,7 +5,6 @@
 #include "third_party/blink/renderer/modules/indexeddb/indexed_db_callbacks_impl.h"
 
 #include "third_party/blink/public/platform/file_path_conversion.h"
-#include "third_party/blink/public/platform/web_data.h"
 #include "third_party/blink/renderer/modules/indexeddb/idb_key_range.h"
 #include "third_party/blink/renderer/modules/indexeddb/indexed_db_dispatcher.h"
 #include "third_party/blink/renderer/modules/indexeddb/web_idb_callbacks.h"
@@ -29,8 +28,10 @@ namespace {
 
 std::unique_ptr<IDBValue> ConvertReturnValue(
     const mojom::blink::IDBReturnValuePtr& input) {
-  if (!input)
-    return IDBValue::Create(WebData(), WebVector<WebBlobInfo>());
+  if (!input) {
+    return IDBValue::Create(scoped_refptr<SharedBuffer>(),
+                            WebVector<WebBlobInfo>());
+  }
 
   std::unique_ptr<IDBValue> output =
       IndexedDBCallbacksImpl::ConvertValue(input->value);
@@ -49,8 +50,10 @@ WebIDBNameAndVersion ConvertNameVersion(
 // static
 std::unique_ptr<IDBValue> IndexedDBCallbacksImpl::ConvertValue(
     const mojom::blink::IDBValuePtr& input) {
-  if (!input || input->bits.IsEmpty())
-    return IDBValue::Create(WebData(), WebVector<WebBlobInfo>());
+  if (!input || input->bits.IsEmpty()) {
+    return IDBValue::Create(scoped_refptr<SharedBuffer>(),
+                            WebVector<WebBlobInfo>());
+  }
 
   WebVector<WebBlobInfo> local_blob_info;
   local_blob_info.reserve(input->blob_or_file_info.size());
@@ -69,11 +72,11 @@ std::unique_ptr<IDBValue> IndexedDBCallbacksImpl::ConvertValue(
   }
 
   // TODO(crbug.com/902498): Use mojom traits to map directly to WebData.
-  WebData web_data(reinterpret_cast<const char*>(input->bits.data()),
-                   input->bits.size());
+  scoped_refptr<blink::SharedBuffer> value_buffer = blink::SharedBuffer::Create(
+      reinterpret_cast<const char*>(input->bits.data()), input->bits.size());
   // Release input->bits std::vector.
   input->bits.clear();
-  return IDBValue::Create(std::move(web_data), std::move(local_blob_info));
+  return IDBValue::Create(std::move(value_buffer), std::move(local_blob_info));
 }
 
 IndexedDBCallbacksImpl::IndexedDBCallbacksImpl(

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

@@ -7,7 +7,6 @@
 #include <memory>
 
 #include "base/memory/ptr_util.h"
-#include "third_party/blink/public/platform/web_data.h"
 
 namespace blink {
 

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

@@ -86,7 +86,7 @@ class MockWebIDBDatabase : public testing::StrictMock<WebIDBDatabase> {
   MOCK_METHOD8(Put,
                void(long long transaction_id,
                     long long object_store_id,
-                    const WebData& value,
+                    const scoped_refptr<SharedBuffer>& value,
                     const Vector<WebBlobInfo>&,
                     std::unique_ptr<IDBKey> primary_key,
                     mojom::IDBPutMode,

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

@@ -15,7 +15,6 @@
 #include "third_party/blink/renderer/modules/indexeddb/indexed_db_dispatcher.h"
 
 using blink::WebBlobInfo;
-using blink::WebData;
 using blink::WebIDBCallbacks;
 using blink::mojom::blink::IDBCallbacksAssociatedPtrInfo;
 using blink::mojom::blink::IDBCursorAssociatedPtrInfo;

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

@@ -13,7 +13,6 @@
 #include "mojo/public/cpp/bindings/associated_binding.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/platform/scheduler/test/renderer_scheduler_test_support.h"
-#include "third_party/blink/public/platform/web_data.h"
 #include "third_party/blink/renderer/modules/indexeddb/idb_key_range.h"
 #include "third_party/blink/renderer/modules/indexeddb/mock_web_idb_callbacks.h"
 #include "third_party/blink/renderer/platform/testing/testing_platform_support.h"
@@ -168,7 +167,8 @@ TEST_F(WebIDBCursorImplTest, PrefetchTest) {
         blob_info.emplace_back(WebBlobInfo::BlobForTesting(
             WebString("blobuuid"), "text/plain", 123));
       }
-      values.emplace_back(IDBValue::Create(WebData(), std::move(blob_info)));
+      values.emplace_back(IDBValue::Create(scoped_refptr<SharedBuffer>(),
+                                           std::move(blob_info)));
     }
     cursor_->SetPrefetchData(std::move(keys), std::move(primary_keys),
                              std::move(values));
@@ -239,7 +239,8 @@ TEST_F(WebIDBCursorImplTest, AdvancePrefetchTest) {
       blob_info.emplace_back(WebBlobInfo::BlobForTesting(WebString("blobuuid"),
                                                          "text/plain", 123));
     }
-    values.emplace_back(IDBValue::Create(WebData(), std::move(blob_info)));
+    values.emplace_back(
+        IDBValue::Create(scoped_refptr<SharedBuffer>(), std::move(blob_info)));
   }
   cursor_->SetPrefetchData(std::move(keys), std::move(primary_keys),
                            std::move(values));
@@ -322,8 +323,10 @@ TEST_F(WebIDBCursorImplTest, PrefetchReset) {
   Vector<std::unique_ptr<IDBKey>> keys(prefetch_count);
   Vector<std::unique_ptr<IDBKey>> primary_keys(prefetch_count);
   Vector<std::unique_ptr<IDBValue>> values;
-  for (int i = 0; i < prefetch_count; ++i)
-    values.emplace_back(IDBValue::Create(WebData(), WebVector<WebBlobInfo>()));
+  for (int i = 0; i < prefetch_count; ++i) {
+    values.emplace_back(IDBValue::Create(scoped_refptr<SharedBuffer>(),
+                                         WebVector<WebBlobInfo>()));
+  }
   cursor_->SetPrefetchData(std::move(keys), std::move(primary_keys),
                            std::move(values));
 

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/web_blob_info.h"
 #include "third_party/blink/renderer/modules/indexeddb/web_idb_cursor.h"
 #include "third_party/blink/renderer/modules/modules_export.h"
 #include "third_party/blink/renderer/platform/wtf/vector.h"
@@ -38,7 +37,7 @@
 namespace blink {
 
 class IDBKeyRange;
-class WebData;
+class WebBlobInfo;
 class WebIDBCallbacks;
 class WebIDBKeyPath;
 
@@ -106,7 +105,7 @@ class MODULES_EXPORT WebIDBDatabase {
                       WebIDBCallbacks*) = 0;
   virtual void Put(long long transaction_id,
                    long long object_store_id,
-                   const WebData& value,
+                   const scoped_refptr<SharedBuffer>& value,
                    const Vector<WebBlobInfo>&,
                    std::unique_ptr<IDBKey> primary_key,
                    mojom::IDBPutMode,

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

@@ -15,8 +15,6 @@
 #include "third_party/blink/public/common/indexeddb/indexeddb_key.h"
 #include "third_party/blink/public/platform/file_path_conversion.h"
 #include "third_party/blink/public/platform/modules/indexeddb/web_idb_database_exception.h"
-#include "third_party/blink/public/platform/web_blob_info.h"
-#include "third_party/blink/public/platform/web_data.h"
 #include "third_party/blink/public/platform/web_string.h"
 #include "third_party/blink/public/platform/web_vector.h"
 #include "third_party/blink/renderer/modules/indexeddb/idb_key_range.h"
@@ -125,7 +123,7 @@ void WebIDBDatabaseImpl::GetAll(long long transaction_id,
 
 void WebIDBDatabaseImpl::Put(long long transaction_id,
                              long long object_store_id,
-                             const WebData& value,
+                             const scoped_refptr<SharedBuffer>& value,
                              const Vector<WebBlobInfo>& web_blob_info,
                              std::unique_ptr<IDBKey> primary_key,
                              mojom::IDBPutMode put_mode,
@@ -136,12 +134,7 @@ void WebIDBDatabaseImpl::Put(long long transaction_id,
   auto mojo_value = mojom::blink::IDBValue::New();
 
   // mojo_value->bits initialization.
-  value.ForEachSegment([&mojo_value](const char* segment, size_t segment_size,
-                                     size_t segment_offset) {
-    const auto& segment_span = base::make_span(segment, segment + segment_size);
-    mojo_value->bits.AppendRange(segment_span.begin(), segment_span.end());
-    return true;
-  });
+  mojo_value->bits = value->CopyAs<Vector<uint8_t>>();
 
   // mojo_value->blob_or_file_info initialization.
   mojo_value->blob_or_file_info.ReserveInitialCapacity(web_blob_info.size());

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

@@ -68,7 +68,7 @@ class MODULES_EXPORT WebIDBDatabaseImpl : public WebIDBDatabase {
               WebIDBCallbacks*) override;
   void Put(long long transaction_id,
            long long object_store_id,
-           const WebData& value,
+           const scoped_refptr<SharedBuffer>& value,
            const Vector<WebBlobInfo>&,
            std::unique_ptr<IDBKey> primary_key,
            mojom::IDBPutMode,

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

@@ -12,7 +12,6 @@
 #include "third_party/blink/public/common/indexeddb/indexeddb_key.h"
 #include "third_party/blink/public/platform/scheduler/test/renderer_scheduler_test_support.h"
 #include "third_party/blink/public/platform/web_blob_info.h"
-#include "third_party/blink/public/platform/web_data.h"
 #include "third_party/blink/public/web/web_heap.h"
 #include "third_party/blink/renderer/modules/indexeddb/idb_key_range.h"
 #include "third_party/blink/renderer/modules/indexeddb/mock_web_idb_callbacks.h"
@@ -33,14 +32,15 @@ TEST_F(WebIDBDatabaseImplTest, ValueSizeTest) {
   const size_t kMaxValueSizeForTesting = 10 * 1024 * 1024;  // 10 MB
 
   const std::vector<char> data(kMaxValueSizeForTesting + 1);
-  const WebData value(&data.front(), data.size());
+  const scoped_refptr<SharedBuffer> value =
+      SharedBuffer::Create(&data.front(), data.size());
   const Vector<WebBlobInfo> blob_info;
   std::unique_ptr<IDBKey> key = IDBKey::CreateNumber(0);
   const int64_t transaction_id = 1;
   const int64_t object_store_id = 2;
   StrictMock<MockWebIDBCallbacks> callbacks;
 
-  ASSERT_GT(value.size() + key->SizeEstimate(), kMaxValueSizeForTesting);
+  ASSERT_GT(value->size() + key->SizeEstimate(), kMaxValueSizeForTesting);
   ThreadState::Current()->CollectAllGarbage();
   EXPECT_CALL(callbacks, OnError(_)).Times(1);
 
@@ -58,7 +58,8 @@ TEST_F(WebIDBDatabaseImplTest, KeyAndValueSizeTest) {
   const size_t kKeySize = 1024 * 1024;
 
   const std::vector<char> data(kMaxValueSizeForTesting - kKeySize);
-  const WebData value(&data.front(), data.size());
+  const scoped_refptr<SharedBuffer> value =
+      SharedBuffer::Create(&data.front(), data.size());
   const Vector<WebBlobInfo> blob_info;
   const int64_t transaction_id = 1;
   const int64_t object_store_id = 2;
@@ -76,9 +77,9 @@ TEST_F(WebIDBDatabaseImplTest, KeyAndValueSizeTest) {
   DCHECK_EQ(key_string.length(), number_of_chars);
 
   std::unique_ptr<IDBKey> key = IDBKey::CreateString(key_string);
-  DCHECK_EQ(value.size(), kMaxValueSizeForTesting - kKeySize);
+  DCHECK_EQ(value->size(), kMaxValueSizeForTesting - kKeySize);
   DCHECK_GT(key->SizeEstimate() - kKeySize, static_cast<unsigned long>(0));
-  DCHECK_GT(value.size() + key->SizeEstimate(), kMaxValueSizeForTesting);
+  DCHECK_GT(value->size() + key->SizeEstimate(), kMaxValueSizeForTesting);
 
   ThreadState::Current()->CollectAllGarbage();
   EXPECT_CALL(callbacks, OnError(_)).Times(1);

third_party/blink/renderer/platform/shared_buffer.h

@@ -239,6 +239,20 @@ inline Vector<char> SharedBuffer::CopyAs() const {
   return buffer;
 }
 
+template <>
+inline Vector<uint8_t> SharedBuffer::CopyAs() const {
+  Vector<uint8_t> buffer;
+  buffer.ReserveInitialCapacity(SafeCast<wtf_size_t>(size_));
+
+  for (const auto& span : *this) {
+    buffer.Append(reinterpret_cast<const uint8_t*>(span.data()),
+                  static_cast<wtf_size_t>(span.size()));
+  }
+
+  DCHECK_EQ(buffer.size(), size_);
+  return buffer;
+}
+
 template <>
 inline std::vector<char> SharedBuffer::CopyAs() const {
   std::vector<char> buffer;