Mojo C++ bindings: switch device/nfc mojom target to use STL/WTF types.

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 113 matching lines @@
   }
 };
 
 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);
+    record->data = mojo::WTFArray<uint8_t>::From(string).PassStorage();
     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);
+    record->data = mojo::WTFArray<uint8_t>::From(buffer).PassStorage();

[haraken, 2016/11/12 01:35:41]

Would you help me understand what PassStorage is doing? i.e., when do we need to
use PassStorage?

[yzshen1, 2016/11/14 17:10:42]

Because with this CL, record->data's type becomes WTF::Vector<uint8_t>. In order
to convert a mojo::WTFArray<uint8_t> to that, we need to use PassStorage().

You might ask: why are we still using mojo::WTFArray<> at all? That is because
we have a TypeConverter defined to convert from blink::DOMArrayBuffer to
WTFArray. I am a little reluctant to change that to a conversion function from
blink::DOMArrayBuffer to WTF::Vector in this CL (which is supposed to be a
mechanical change).

[haraken, 2016/11/14 18:38:30]

Thanks, makes sense.

     return record;
   }
 };
 
 template <>
 struct TypeConverter<NFCMessagePtr, WTF::String> {
   static NFCMessagePtr Convert(const WTF::String& string) {
     NFCMessagePtr message = NFCMessage::New();
-    message->data = mojo::WTFArray<NFCRecordPtr>::New(1);
-    message->data[0] = NFCRecord::From(string);
+    message->data.append(NFCRecord::From(string));
     return message;
   }
 };
 
 template <>
 struct TypeConverter<mojo::WTFArray<uint8_t>, blink::ScriptValue> {
   static mojo::WTFArray<uint8_t> Convert(
       const blink::ScriptValue& scriptValue) {
     v8::Local<v8::Value> value = scriptValue.v8Value();
 
@@ skipping 50 matching lines @@
         setMediaType(recordPtr, record.mediaType(), kJsonMimeType);
         break;
       case NFCRecordType::OPAQUE_RECORD:
         setMediaType(recordPtr, record.mediaType(), kOpaqueMimeType);
         break;
       default:
         NOTREACHED();
         break;
     }
 
-    recordPtr->data = mojo::WTFArray<uint8_t>::From(record.data());
-
+    auto recordData = mojo::WTFArray<uint8_t>::From(record.data());
     // If JS object cannot be converted to uint8_t array, return null,
     // interrupt NFCMessage conversion algorithm and reject promise with
     // SyntaxError exception.
-    if (recordPtr->data.is_null())
+    if (recordData.is_null())
       return nullptr;
 
+    recordPtr->data = recordData.PassStorage();
     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());
     for (size_t i = 0; i < message.data().size(); ++i) {
       NFCRecordPtr record = NFCRecord::From(message.data()[i]);
       if (record.is_null())
         return nullptr;
 
       messagePtr->data[i] = std::move(record);
     }
-    messagePtr->data = mojo::WTFArray<NFCRecordPtr>::From(message.data());

[haraken, 2016/11/12 01:35:41]

Why can we remove this?

[yzshen1, 2016/11/14 17:10:42]

Because line 243-250 does the same thing as line 251 (except that line 243-250
doesn't allow null element). Therefore, I kept the former.

     return messagePtr;
   }
 };
 
 template <>
 struct TypeConverter<NFCMessagePtr, blink::DOMArrayBuffer*> {
   static NFCMessagePtr Convert(blink::DOMArrayBuffer* buffer) {
     NFCMessagePtr message = NFCMessage::New();
-    message->data = mojo::WTFArray<NFCRecordPtr>::New(1);
-    message->data[0] = NFCRecord::From(buffer);
+    message->data.append(NFCRecord::From(buffer));
     return message;
   }
 };
 
 template <>
 struct TypeConverter<NFCMessagePtr, blink::NFCPushMessage> {
   static NFCMessagePtr Convert(const blink::NFCPushMessage& message) {
     if (message.isString())
       return NFCMessage::From(message.getAsString());
 
@@ skipping 302 matching lines @@
 
   // If NFCService is not available or disappears when NFC hardware is
   // disabled, reject promise with NotSupportedError exception.
   for (ScriptPromiseResolver* resolver : m_requests)
     resolver->reject(
         NFCError::take(resolver, mojom::NFCErrorType::NOT_SUPPORTED));
 
   m_requests.clear();
 }
 
-void NFC::OnWatch(mojo::WTFArray<uint32_t> ids, mojom::NFCMessagePtr) {
+void NFC::OnWatch(const WTF::Vector<uint32_t>& ids, mojom::NFCMessagePtr) {
   // TODO(shalamov): Not implemented.
 }
 
 DEFINE_TRACE(NFC) {
   PageVisibilityObserver::trace(visitor);
   ContextLifecycleObserver::trace(visitor);
   visitor->trace(m_requests);
 }
 
 }  // namespace blink