Remove mojo::WTFArray.

third_party/WebKit/Source/modules/nfc/NFC.cpp

 // Copyright 2015 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 "modules/nfc/NFC.h"
 
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/V8ArrayBuffer.h"
 #include "bindings/core/v8/V8StringResource.h"
 #include "core/dom/DOMArrayBuffer.h"
@@ skipping 102 matching lines @@
 }
 
 void setMediaType(NFCRecordPtr& recordPtr,
                   const WTF::String& recordMediaType,
                   const WTF::String& defaultMediaType) {
   recordPtr->media_type =
       recordMediaType.isEmpty() ? defaultMediaType : recordMediaType;
 }
 
 template <>
-struct TypeConverter<mojo::WTFArray<uint8_t>, WTF::String> {
-  static mojo::WTFArray<uint8_t> Convert(const WTF::String& string) {
+struct TypeConverter<WTF::Vector<uint8_t>, WTF::String> {
+  static WTF::Vector<uint8_t> Convert(const WTF::String& string) {
     WTF::CString utf8String = string.utf8();
     WTF::Vector<uint8_t> array;
     array.append(utf8String.data(), utf8String.length());
-    return mojo::WTFArray<uint8_t>(std::move(array));
+    return WTF::Vector<uint8_t>(std::move(array));

[yzshen1, 2017/01/03 21:33:28]

you could return array directly.

[Sam McNally, 2017/01/04 00:30:16]

Done.

   }
 };
 
 template <>
-struct TypeConverter<mojo::WTFArray<uint8_t>, blink::DOMArrayBuffer*> {
-  static mojo::WTFArray<uint8_t> Convert(blink::DOMArrayBuffer* buffer) {
+struct TypeConverter<WTF::Vector<uint8_t>, blink::DOMArrayBuffer*> {
+  static WTF::Vector<uint8_t> Convert(blink::DOMArrayBuffer* buffer) {
     WTF::Vector<uint8_t> array;
     array.append(static_cast<uint8_t*>(buffer->data()), buffer->byteLength());
-    return mojo::WTFArray<uint8_t>(std::move(array));
+    return WTF::Vector<uint8_t>(std::move(array));

[yzshen1, 2017/01/03 21:33:28]

ditto.

[Sam McNally, 2017/01/04 00:30:16]

Done.

   }
 };
 
 template <>
 struct TypeConverter<NFCRecordPtr, WTF::String> {
   static NFCRecordPtr Convert(const WTF::String& string) {
     NFCRecordPtr record = NFCRecord::New();
     record->record_type = NFCRecordType::TEXT;
     record->media_type = kPlainTextMimeType;
     record->media_type.append(kCharSetUTF8);
-    record->data = mojo::WTFArray<uint8_t>::From(string).PassStorage();
+    record->data = mojo::ConvertTo<WTF::Vector<uint8_t>>(string);
     return record;
   }
 };
 
 template <>
 struct TypeConverter<NFCRecordPtr, blink::DOMArrayBuffer*> {
   static NFCRecordPtr Convert(blink::DOMArrayBuffer* buffer) {
     NFCRecordPtr record = NFCRecord::New();
     record->record_type = NFCRecordType::OPAQUE_RECORD;
     record->media_type = kOpaqueMimeType;
-    record->data = mojo::WTFArray<uint8_t>::From(buffer).PassStorage();
+    record->data = mojo::ConvertTo<WTF::Vector<uint8_t>>(buffer);
     return record;
   }
 };
 
 template <>
 struct TypeConverter<NFCMessagePtr, WTF::String> {
   static NFCMessagePtr Convert(const WTF::String& string) {
     NFCMessagePtr message = NFCMessage::New();
     message->data.append(NFCRecord::From(string));
     return message;
   }
 };
 
 template <>
-struct TypeConverter<mojo::WTFArray<uint8_t>, blink::ScriptValue> {
-  static mojo::WTFArray<uint8_t> Convert(
+struct TypeConverter<WTF::Optional<WTF::Vector<uint8_t>>, blink::ScriptValue> {
+  static WTF::Optional<WTF::Vector<uint8_t>> Convert(
       const blink::ScriptValue& scriptValue) {
     v8::Local<v8::Value> value = scriptValue.v8Value();
 
     if (value->IsNumber())
-      return mojo::WTFArray<uint8_t>::From(
+      return mojo::ConvertTo<WTF::Vector<uint8_t>>(
           WTF::String::number(value.As<v8::Number>()->Value()));
 
     if (value->IsString()) {
       blink::V8StringResource<> stringResource = value;
-      if (stringResource.prepare())
-        return mojo::WTFArray<uint8_t>::From<WTF::String>(stringResource);
+      if (stringResource.prepare()) {
+        return mojo::ConvertTo<WTF::Vector<uint8_t>>(
+            WTF::String(stringResource));
+      }
     }
 
     if (value->IsObject() && !value->IsArray() && !value->IsArrayBuffer()) {
       v8::Local<v8::String> jsonString;
       if (v8::JSON::Stringify(scriptValue.context(), value.As<v8::Object>())
               .ToLocal(&jsonString)) {
         WTF::String wtfString = blink::v8StringToWebCoreString<WTF::String>(
             jsonString, blink::DoNotExternalize);
-        return mojo::WTFArray<uint8_t>::From(wtfString);
+        return mojo::ConvertTo<WTF::Vector<uint8_t>>(wtfString);
       }
     }
 
     if (value->IsArrayBuffer())
-      return mojo::WTFArray<uint8_t>::From(
+      return mojo::ConvertTo<WTF::Vector<uint8_t>>(
           blink::V8ArrayBuffer::toImpl(value.As<v8::Object>()));
 
-    return nullptr;
+    return WTF::nullopt;
   }
 };
 
 template <>
 struct TypeConverter<NFCRecordPtr, blink::NFCRecord> {
   static NFCRecordPtr Convert(const blink::NFCRecord& record) {
     NFCRecordPtr recordPtr = NFCRecord::New();
 
     if (record.hasRecordType())
       recordPtr->record_type = toNFCRecordType(record.recordType());
@@ skipping 15 matching lines @@
         setMediaType(recordPtr, record.mediaType(), kJsonMimeType);
         break;
       case NFCRecordType::OPAQUE_RECORD:
         setMediaType(recordPtr, record.mediaType(), kOpaqueMimeType);
         break;
       default:
         NOTREACHED();
         break;
     }
 
-    auto recordData = mojo::WTFArray<uint8_t>::From(record.data());
+    auto recordData =
+        mojo::ConvertTo<WTF::Optional<WTF::Vector<uint8_t>>>(record.data());

[haraken, 2016/12/29 11:42:35]

Why do we need Optional? Maybe can we simply check if the Vector is empty?

[Sam McNally, 2016/12/30 00:21:14]

We need to be able to distinguish am invalid value from an empty string value.

     // If JS object cannot be converted to uint8_t array, return null,
     // interrupt NFCMessage conversion algorithm and reject promise with
     // SyntaxError exception.
-    if (recordData.is_null())
+    if (!recordData)
       return nullptr;
 
-    recordPtr->data = recordData.PassStorage();
+    recordPtr->data = recordData.value();
     return recordPtr;
   }
 };
 
 template <>
 struct TypeConverter<NFCMessagePtr, blink::NFCMessage> {
   static NFCMessagePtr Convert(const blink::NFCMessage& message) {
     NFCMessagePtr messagePtr = NFCMessage::New();
     messagePtr->url = message.url();
     messagePtr->data.resize(message.data().size());
@@ skipping 558 matching lines @@
 }
 
 DEFINE_TRACE(NFC) {
   PageVisibilityObserver::trace(visitor);
   ContextLifecycleObserver::trace(visitor);
   visitor->trace(m_requests);
   visitor->trace(m_callbacks);
 }
 
 }  // namespace blink