Have SerializedScriptValue::GetWireData return a base::span.

StringView wasn't an ideal type, since this is binary data, not character data.

Bug: 770862
Change-Id: I24108f10f8171815d52704d028a93fd01e2f44cf
Reviewed-on: https://chromium-review.googlesource.com/710674
Commit-Queue: Jeremy Roman <jbroman@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Marijn Kruisselbrink <mek@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#526826}

third_party/WebKit/Source/DEPS

 include_rules = [
     "+base/callback.h",
     "+base/callback_forward.h",
+    "+base/containers/span.h",
     "+base/debug",
     "+base/gtest_prod_util.h",
     "+base/location.h",

third_party/WebKit/Source/bindings/core/v8/serialization/SerializedScriptValue.h

@@ -33,6 +33,7 @@
 
 #include <memory>
 
+#include "base/containers/span.h"
 #include "bindings/core/v8/NativeValueTraits.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/serialization/Transferables.h"
@@ -147,8 +148,8 @@ class CORE_EXPORT SerializedScriptValue
 
   String ToWireString() const;
 
-  StringView GetWireData() const {
-    return StringView(data_buffer_.get(), data_buffer_size_);
+  base::span<const uint8_t> GetWireData() const {
+    return {data_buffer_.get(), data_buffer_size_};
   }
 
   // Deserializes the value (in the current context). Returns a null value in

third_party/WebKit/Source/bindings/core/v8/serialization/SerializedScriptValueTest.cpp

@@ -26,13 +26,12 @@ TEST(SerializedScriptValueTest, WireFormatRoundTrip) {
           scope.GetIsolate(), v8OriginalTrue,
           SerializedScriptValue::SerializeOptions(), ASSERT_NO_EXCEPTION);
 
-  StringView wire_data = sourceSerializedScriptValue->GetWireData();
-  DCHECK(wire_data.Is8Bit());
+  base::span<const uint8_t> wire_data =
+      sourceSerializedScriptValue->GetWireData();
 
   scoped_refptr<SerializedScriptValue> serializedScriptValue =
       SerializedScriptValue::Create(
-          reinterpret_cast<const char*>(wire_data.Characters8()),
-          wire_data.length());
+          reinterpret_cast<const char*>(wire_data.data()), wire_data.length());
   v8::Local<v8::Value> deserialized =
       serializedScriptValue->Deserialize(scope.GetIsolate());
   EXPECT_TRUE(deserialized->IsTrue());

third_party/WebKit/Source/bindings/modules/v8/V8BindingForModulesTest.cpp

@@ -148,10 +148,9 @@ void SerializeV8Value(v8::Local<v8::Value> value,
   scoped_refptr<SerializedScriptValue> serialized_value =
       SerializedScriptValue::Serialize(isolate, value, options,
                                        non_throwable_exception_state);
-  StringView ssv_wire_data = serialized_value->GetWireData();
-  DCHECK(ssv_wire_data.Is8Bit());
+  base::span<const uint8_t> ssv_wire_data = serialized_value->GetWireData();
   DCHECK(wire_bytes->IsEmpty());
-  wire_bytes->Append(ssv_wire_data.Characters8(), ssv_wire_data.length());
+  wire_bytes->Append(ssv_wire_data.data(), ssv_wire_data.length());
 
   // Sanity check that the serialization header has not changed, as the tests
   // that use this method rely on the header format.

third_party/WebKit/Source/core/messaging/BlinkCloneableMessageStructTraits.h

@@ -18,10 +18,7 @@ struct StructTraits<blink::mojom::blink::CloneableMessage::DataView,
                     blink::BlinkCloneableMessage> {
   static base::span<const uint8_t> encoded_message(
       blink::BlinkCloneableMessage& input) {
-    StringView wire_data = input.message->GetWireData();
-    return base::make_span(
-        reinterpret_cast<const uint8_t*>(wire_data.Characters8()),
-        wire_data.length());
+    return input.message->GetWireData();
   }
 
   static Vector<blink::mojom::blink::SerializedBlobPtr> blobs(

third_party/WebKit/Source/core/testing/Internals.cpp

@@ -2860,12 +2860,11 @@ bool Internals::fakeMouseMovePending() const {
 
 DOMArrayBuffer* Internals::serializeObject(
     scoped_refptr<SerializedScriptValue> value) const {
-  StringView view = value->GetWireData();
-  DCHECK(view.Is8Bit());
+  base::span<const uint8_t> span = value->GetWireData();
   DOMArrayBuffer* buffer =
-      DOMArrayBuffer::CreateUninitializedOrNull(view.length(), sizeof(LChar));
+      DOMArrayBuffer::CreateUninitializedOrNull(span.length(), sizeof(uint8_t));
   if (buffer)
-    memcpy(buffer->Data(), view.Characters8(), view.length());
+    memcpy(buffer->Data(), span.data(), span.length());
   return buffer;
 }
 

third_party/WebKit/Source/modules/indexeddb/IDBTestHelper.cpp

@@ -21,13 +21,11 @@ std::unique_ptr<IDBValue> CreateNullIDBValueForTesting() {
   scoped_refptr<SerializedScriptValue> null_ssv =
       SerializedScriptValue::NullValue();
 
-  StringView ssv_wire_bytes = null_ssv->GetWireData();
-  DCHECK(ssv_wire_bytes.Is8Bit());
+  base::span<const uint8_t> ssv_wire_bytes = null_ssv->GetWireData();
 
   scoped_refptr<SharedBuffer> idb_value_buffer = SharedBuffer::Create();
-  idb_value_buffer->Append(
-      reinterpret_cast<const char*>(ssv_wire_bytes.Characters8()),
-      ssv_wire_bytes.length());
+  idb_value_buffer->Append(reinterpret_cast<const char*>(ssv_wire_bytes.data()),
+                           ssv_wire_bytes.length());
   return IDBValue::Create(std::move(idb_value_buffer),
                           Vector<scoped_refptr<BlobDataHandle>>(),
                           Vector<WebBlobInfo>(), IDBKey::CreateNumber(42.0),

third_party/WebKit/Source/modules/indexeddb/IDBValueWrapping.cpp

@@ -123,7 +123,6 @@ void IDBValueWrapper::DoneCloning() {
 #endif  // DCHECK_IS_ON()
 
   wire_data_ = serialized_value_->GetWireData();
-  DCHECK(wire_data_.Is8Bit());
   for (const auto& kvp : serialized_value_->BlobDataHandles())
     blob_handles_.push_back(std::move(kvp.value));
 }
@@ -147,7 +146,7 @@ bool IDBValueWrapper::WrapIfBiggerThan(unsigned max_bytes) {
   //                         Blob::Create to avoid a buffer copy.
   std::unique_ptr<BlobData> wrapper_blob_data = BlobData::Create();
   wrapper_blob_data->SetContentType(String(kWrapMimeType));
-  wrapper_blob_data->AppendBytes(wire_data_.Characters8(), wire_data_size);
+  wrapper_blob_data->AppendBytes(wire_data_.data(), wire_data_size);
   scoped_refptr<BlobDataHandle> wrapper_handle =
       BlobDataHandle::Create(std::move(wrapper_blob_data), wire_data_size);
   blob_info_.emplace_back(wrapper_handle->Uuid(), wrapper_handle->GetType(),
@@ -162,9 +161,10 @@ bool IDBValueWrapper::WrapIfBiggerThan(unsigned max_bytes) {
   IDBValueWrapper::WriteVarInt(serialized_value_->BlobDataHandles().size(),
                                wire_data_buffer_);
 
-  wire_data_ = StringView(wire_data_buffer_.data(), wire_data_buffer_.size());
+  wire_data_ = base::make_span(
+      reinterpret_cast<const uint8_t*>(wire_data_buffer_.data()),
+      wire_data_buffer_.size());
   DCHECK(!wire_data_buffer_.IsEmpty());
-  DCHECK(wire_data_.Is8Bit());
   return true;
 }
 
@@ -177,16 +177,15 @@ scoped_refptr<SharedBuffer> IDBValueWrapper::TakeWireBytes() {
 
   if (wire_data_buffer_.IsEmpty()) {
     // The wire bytes are coming directly from the SSV's GetWireData() call.
-    DCHECK_EQ(wire_data_.Characters8(),
-              serialized_value_->GetWireData().Characters8());
+    DCHECK_EQ(wire_data_.data(), serialized_value_->GetWireData().data());
     DCHECK_EQ(wire_data_.length(), serialized_value_->GetWireData().length());
-    return SharedBuffer::Create(wire_data_.Characters8(),
+    return SharedBuffer::Create(wire_data_.data(),
                                 static_cast<size_t>(wire_data_.length()));
   }
 
   // The wire bytes are coming from wire_data_buffer_, so we can avoid a copy.
   DCHECK_EQ(wire_data_buffer_.data(),
-            reinterpret_cast<const char*>(wire_data_.Characters8()));
+            reinterpret_cast<const char*>(wire_data_.data()));
   DCHECK_EQ(wire_data_buffer_.size(), wire_data_.length());
   return SharedBuffer::AdoptVector(wire_data_buffer_);
 }

third_party/WebKit/Source/modules/indexeddb/IDBValueWrapping.h

@@ -185,7 +185,7 @@ class MODULES_EXPORT IDBValueWrapper {
   Vector<char> wire_data_buffer_;
 
   // Points into SerializedScriptValue's data buffer, or into wire_data_buffer_.
-  StringView wire_data_;
+  base::span<const uint8_t> wire_data_;
 
   size_t original_data_length_ = 0;
 

third_party/WebKit/Source/modules/notifications/NotificationData.cpp

@@ -95,13 +95,7 @@ WebNotificationData CreateWebNotificationData(
     if (exception_state.HadException())
       return WebNotificationData();
 
-    StringView ssv_wire_data = serialized_script_value->GetWireData();
-    DCHECK(ssv_wire_data.Is8Bit());
-    Vector<char> serialized_data;
-    serialized_data.ReserveInitialCapacity(ssv_wire_data.length());
-    serialized_data.Append(ssv_wire_data.Characters8(), ssv_wire_data.length());
-
-    web_data.data = serialized_data;
+    web_data.data = WebVector<char>(serialized_script_value->GetWireData());
   }
 
   Vector<WebNotificationAction> actions;