[webnfc] Implement push method for Android nfc mojo service.

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/JSONValuesForV8.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/V8ArrayBuffer.h"
 #include "core/dom/DOMArrayBuffer.h"
@@ skipping 84 matching lines @@
         if (value->IsArrayBuffer()) {
             return NFCRecordType::OPAQUE_RECORD;
         }
     }
 
     return NFCRecordType::EMPTY;
 }
 
 void setMediaType(NFCRecordPtr& recordPtr, const WTF::String& recordMediaType, const WTF::String& defaultMediaType)
 {
-    recordPtr->mediaType = recordMediaType.isEmpty() ? defaultMediaType : recordMediaType;
+    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)
     {
         WTF::CString utf8String = string.utf8();
         WTF::Vector<uint8_t> array;
         array.append(utf8String.data(), utf8String.length());
         return mojo::WTFArray<uint8_t>(std::move(array));
     }
 };
 
 template <>
 struct TypeConverter<mojo::WTFArray<uint8_t>, blink::DOMArrayBuffer*> {
     static mojo::WTFArray<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));
     }
 };
 
 template <>
 struct TypeConverter<NFCRecordPtr, WTF::String> {
     static NFCRecordPtr Convert(const WTF::String& string)
     {
         NFCRecordPtr record = NFCRecord::New();
-        record->recordType = NFCRecordType::TEXT;
-        record->mediaType = kPlainTextMimeType;
-        record->mediaType.append(kCharSetUTF8);
+        record->record_type = NFCRecordType::TEXT;
+        record->media_type = kPlainTextMimeType;
+        record->media_type.append(kCharSetUTF8);
         record->data = mojo::WTFArray<uint8_t>::From(string);
         return record;
     }
 };
 
 template <>
 struct TypeConverter<NFCRecordPtr, blink::DOMArrayBuffer*> {
     static NFCRecordPtr Convert(blink::DOMArrayBuffer* buffer)
     {
         NFCRecordPtr record = NFCRecord::New();
-        record->recordType = NFCRecordType::OPAQUE_RECORD;
-        record->mediaType = kOpaqueMimeType;
+        record->record_type = NFCRecordType::OPAQUE_RECORD;
+        record->media_type = kOpaqueMimeType;
         record->data = mojo::WTFArray<uint8_t>::From(buffer);
         return record;
     }
 };
 
 template <>
 struct TypeConverter<NFCMessagePtr, WTF::String> {
     static NFCMessagePtr Convert(const WTF::String& string)
     {
         NFCMessagePtr message = NFCMessage::New();
@@ skipping 31 matching lines @@
     }
 };
 
 template <>
 struct TypeConverter<NFCRecordPtr, blink::NFCRecord> {
     static NFCRecordPtr Convert(const blink::NFCRecord& record)
     {
         NFCRecordPtr recordPtr = NFCRecord::New();
 
         if (record.hasRecordType())
-            recordPtr->recordType = toNFCRecordType(record.recordType());
+            recordPtr->record_type = toNFCRecordType(record.recordType());
         else
-            recordPtr->recordType = deduceRecordTypeFromDataType(record);
+            recordPtr->record_type = deduceRecordTypeFromDataType(record);
 
         // If record type is "empty", no need to set media type or data.
         // https://w3c.github.io/web-nfc/#creating-web-nfc-message
-        if (recordPtr->recordType == NFCRecordType::EMPTY)
+        if (recordPtr->record_type == NFCRecordType::EMPTY)
             return recordPtr;
 
-        switch (recordPtr->recordType) {
+        switch (recordPtr->record_type) {
         case NFCRecordType::TEXT:
         case NFCRecordType::URL:
             setMediaType(recordPtr, record.mediaType(), kPlainTextMimeType);
-            recordPtr->mediaType.append(kCharSetUTF8);
+            recordPtr->media_type.append(kCharSetUTF8);
             break;
         case NFCRecordType::JSON:
             setMediaType(recordPtr, record.mediaType(), kJsonMimeType);
             break;
         case NFCRecordType::OPAQUE_RECORD:
             setMediaType(recordPtr, record.mediaType(), kOpaqueMimeType);
             break;
         default:
             NOTREACHED();
             break;
@@ skipping 72 matching lines @@
             pushOptionsPtr->target = toNFCPushTarget(pushOptions.target());
         else
             pushOptionsPtr->target = NFCPushTarget::ANY;
 
         if (pushOptions.hasTimeout())
             pushOptionsPtr->timeout = pushOptions.timeout();
         else
             pushOptionsPtr->timeout = std::numeric_limits<double>::infinity();
 
         if (pushOptions.hasIgnoreRead())
-            pushOptionsPtr->ignoreRead = pushOptions.ignoreRead();
+            pushOptionsPtr->ignore_read = pushOptions.ignoreRead();
         else
-            pushOptionsPtr->ignoreRead = true;
+            pushOptionsPtr->ignore_read = true;
 
         return pushOptionsPtr;
     }
 };
 
 } // namespace mojo
 
 namespace blink {
 namespace {
 
@@ skipping 261 matching lines @@
 }
 
 DEFINE_TRACE(NFC)
 {
     PageVisibilityObserver::trace(visitor);
     ContextLifecycleObserver::trace(visitor);
     visitor->trace(m_requests);
 }
 
 } // namespace blink