[webnfc] Implement nfc.watch in blink nfc module.

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"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "modules/nfc/NFCError.h"
 #include "modules/nfc/NFCMessage.h"
 #include "modules/nfc/NFCPushOptions.h"
+#include "modules/nfc/NFCWatchOptions.h"
 #include "platform/mojo/MojoHelper.h"
 #include "public/platform/InterfaceProvider.h"
 
 namespace nfc = device::nfc::blink;
 
 namespace {
 const char kJsonMimePrefix[] = "application/";
 const char kJsonMimeType[] = "application/json";
 const char kOpaqueMimeType[] = "application/octet-stream";
 const char kPlainTextMimeType[] = "text/plain";
 const char kPlainTextMimePrefix[] = "text/";
 const char kCharSetUTF8[] = ";charset=UTF-8";
 } // anonymous namespace
 
 // Mojo type converters
 namespace mojo {
 
 using nfc::NFCMessage;
 using nfc::NFCMessagePtr;
 using nfc::NFCRecord;
 using nfc::NFCRecordPtr;
 using nfc::NFCRecordType;
+using nfc::NFCRecordTypeFilter;
+using nfc::NFCRecordTypeFilterPtr;
 using nfc::NFCPushOptions;
 using nfc::NFCPushOptionsPtr;
 using nfc::NFCPushTarget;
+using nfc::NFCWatchMode;
+using nfc::NFCWatchOptions;
+using nfc::NFCWatchOptionsPtr;
 
 NFCPushTarget toNFCPushTarget(const WTF::String& target)
 {
     if (target == "tag")
         return NFCPushTarget::TAG;
 
     if (target == "peer")
         return NFCPushTarget::PEER;
 
     return NFCPushTarget::ANY;
@@ skipping 13 matching lines @@
     if (recordType == "json")
         return NFCRecordType::JSON;
 
     if (recordType == "opaque")
         return NFCRecordType::OPAQUE_RECORD;
 
     NOTREACHED();
     return NFCRecordType::EMPTY;
 }
 
+NFCWatchMode toNFCWatchMode(const WTF::String& watchMode)
+{
+    if (watchMode == "web-nfc-only")
+        return NFCWatchMode::WEBNFC_ONLY;
+
+    if (watchMode == "any")
+        return NFCWatchMode::ANY;
+
+    NOTREACHED();
+    return NFCWatchMode::WEBNFC_ONLY;
+}
+
 // https://w3c.github.io/web-nfc/#creating-web-nfc-message Step 2.1
 // If NFCRecord type is not provided, deduce NFCRecord type from JS data type:
 // String or Number => 'text' record
 // ArrayBuffer => 'opaque' record
 // JSON serializable Object => 'json' record
 NFCRecordType deduceRecordTypeFromDataType(const blink::NFCRecord& record)
 {
     if (record.hasData()) {
         v8::Local<v8::Value> value = record.data().v8Value();
 
@@ skipping 218 matching lines @@
 
         if (pushOptions.hasIgnoreRead())
             pushOptionsPtr->ignore_read = pushOptions.ignoreRead();
         else
             pushOptionsPtr->ignore_read = true;
 
         return pushOptionsPtr;
     }
 };
 
+template <>
+struct TypeConverter<NFCWatchOptionsPtr, blink::NFCWatchOptions> {
+    static NFCWatchOptionsPtr Convert(const blink::NFCWatchOptions& watchOptions)
+    {
+        // https://w3c.github.io/web-nfc/#the-nfcwatchoptions-dictionary
+        // Default values for NFCWatchOptions dictionary are:
+        // url = "", recordType = null, mediaType = "", mode = "web-nfc-only"
+        NFCWatchOptionsPtr watchOptionsPtr = NFCWatchOptions::New();
+        watchOptionsPtr->url = watchOptions.url();
+        watchOptionsPtr->media_type = watchOptions.mediaType();
+
+        if (watchOptions.hasMode())
+            watchOptionsPtr->mode = toNFCWatchMode(watchOptions.mode());
+        else
+            watchOptionsPtr->mode = NFCWatchMode::WEBNFC_ONLY;
+
+        if (watchOptions.hasRecordType()) {
+            watchOptionsPtr->record_filter = NFCRecordTypeFilter::New();
+            watchOptionsPtr->record_filter->record_type = toNFCRecordType(watchOptions.recordType());
+        }
+
+        return watchOptionsPtr;

[dcheng, 2016/09/08 04:42:38]

Please use a typemap instead (see
https://www.chromium.org/developers/design-documents/mojo/type-mapping)

[shalamov, 2016/09/22 13:53:22]

I don't think blink generated bindings <=> mojo types is supported by typemap
system. All other modules use mojo::TypeConverter or just custom functions.

+    }
+};
+
 } // namespace mojo
 
 namespace blink {
 namespace {
 
 bool isValidTextRecord(const NFCRecord& record)
 {
     v8::Local<v8::Value> value = record.data().v8Value();
     if (!value->IsString() && !(value->IsNumber() && !std::isnan(value.As<v8::Number>()->Value())))
         return false;
@@ skipping 104 matching lines @@
     KURL originURL(ParsedURLString, origin);
 
     if (!message->url.isEmpty() && originURL.canSetPathname()) {
         originURL.setPath(message->url);
     }
 
     message->url = originURL;
     return originURL.isValid();
 }
 
+String toNFCRecordType(const nfc::NFCRecordType& type)
+{
+    switch (type) {
+    case nfc::NFCRecordType::TEXT:
+        return "text";
+    case nfc::NFCRecordType::URL:
+        return "url";
+    case nfc::NFCRecordType::JSON:
+        return "json";
+    case nfc::NFCRecordType::OPAQUE_RECORD:
+        return "opaque";
+    case nfc::NFCRecordType::EMPTY:
+        return "empty";
+    }
+
+    NOTREACHED();
+    return String();
+}
+
+v8::Local<v8::Value> toV8(const nfc::NFCRecordPtr& record, ScriptState* scriptState)

[dcheng, 2016/09/08 04:42:38]

Why do we need to do this manually? I would expect the mojo type to be
typemapped to something in Blink, and then whatever magic we use for Blink types
to JS Just Works.

[shalamov, 2016/09/22 13:53:22]

NFCRecord is a kind of container Type,Mime,Data. V8 doesn't know how to do
conversion based on those fields. For magic, I would need to copy toV8 method to
V8BindingForModules.h / cpp and this will introduce dependency to mojo and would
not add any real value.

+{
+    switch (record->record_type) {
+    case nfc::NFCRecordType::TEXT:
+    case nfc::NFCRecordType::URL:
+    case nfc::NFCRecordType::JSON: {
+        String stringData;
+        if (!record->data.empty())
+            stringData = String::fromUTF8WithLatin1Fallback(static_cast<unsigned char*>(&record->data.front()), record->data.size());
+
+        if (record->record_type == nfc::NFCRecordType::JSON)
+            return v8::JSON::Parse(scriptState->isolate(), v8String(scriptState->isolate(), stringData)).ToLocalChecked();
+        return v8String(scriptState->isolate(), stringData);
+    }
+
+    case nfc::NFCRecordType::OPAQUE_RECORD: {
+        if (!record->data.empty()) {
+            DOMArrayBuffer* buffer = DOMArrayBuffer::create(static_cast<void*>(&record->data.front()), record->data.size());
+            return toV8(buffer, scriptState->context()->Global(), scriptState->isolate());
+        }
+
+        return v8::Null(scriptState->isolate());
+    }
+
+    case nfc::NFCRecordType::EMPTY:
+        return v8::Null(scriptState->isolate());
+    }
+
+    NOTREACHED();
+    return v8::Local<v8::Value>();
+}
+
+NFCRecord toNFCRecord(const nfc::NFCRecordPtr& record, ScriptState* scriptState)
+{
+    NFCRecord nfcRecord;
+    nfcRecord.setMediaType(record->media_type);
+    nfcRecord.setRecordType(toNFCRecordType(record->record_type));
+    nfcRecord.setData(ScriptValue(scriptState, toV8(record, scriptState)));
+    return nfcRecord;
+}
+
+NFCMessage toNFCMessage(const nfc::NFCMessagePtr& message, ScriptState* scriptState)
+{
+    NFCMessage nfcMessage;
+    nfcMessage.setURL(message->url);
+    blink::HeapVector<NFCRecord> records;
+    for (size_t i = 0; i < message->data.size(); ++i)
+        records.append(toNFCRecord(message->data[i], scriptState));
+    nfcMessage.setData(records);
+    return nfcMessage;
+}
+
+size_t getNFCMessageSize(const nfc::NFCMessagePtr& message)
+{
+    size_t messageSize = message->url.charactersSizeInBytes();
+    for (size_t i = 0; i < message->data.size(); ++i) {
+        messageSize += message->data[i]->media_type.charactersSizeInBytes();
+        messageSize += message->data[i]->data.size();
+    }
+    return messageSize;
+}
+
 } // anonymous namespace
 
 NFC::NFC(LocalFrame* frame)
     : PageVisibilityObserver(frame->page())
     , ContextLifecycleObserver(frame->document())
     , m_client(this)
 {
     ThreadState::current()->registerPreFinalizer(this);
     frame->interfaceProvider()->getInterface(mojo::GetProxy(&m_nfc));
     m_nfc.set_connection_error_handler(convertToBaseCallback(WTF::bind(&NFC::OnConnectionError, wrapWeakPersistent(this))));
@@ skipping 15 matching lines @@
 
 void NFC::dispose()
 {
     m_client.Close();
 }
 
 void NFC::contextDestroyed()
 {
     m_nfc.reset();
     m_requests.clear();
+    m_callbacks.clear();
 }
 
 // https://w3c.github.io/web-nfc/#writing-or-pushing-content
+// https://w3c.github.io/web-nfc/#dom-nfc-push
 ScriptPromise NFC::push(ScriptState* scriptState, const NFCPushMessage& pushMessage, const NFCPushOptions& options)
 {
-    String errorMessage;
-    if (!scriptState->getExecutionContext()->isSecureContext(errorMessage))
-        return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(SecurityError, errorMessage));
+    ScriptPromise promise = RejectIfNotSupported(scriptState);
+    if (!promise.isEmpty())
+        return promise;
 
     DOMException* exception = isValidNFCPushMessage(pushMessage);
     if (exception)
         return ScriptPromise::rejectWithDOMException(scriptState, exception);
 
-    if (!m_nfc)
-        return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError));
-
     nfc::NFCMessagePtr message = nfc::NFCMessage::From(pushMessage);
     if (!message)
         return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(SyntaxError));
 
     if (!setURL(scriptState->getExecutionContext()->getSecurityOrigin()->toString(), message))
         return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(SyntaxError));
 
+    if (getNFCMessageSize(message) > nfc::NFCMessage::kMaxNFCMessageSize)

[dcheng, 2016/09/08 04:42:38]

Do we have an equivalent check on the handling side in the browser? I'd rather
just handle this uniformly in one place.

[shalamov, 2016/09/22 13:53:22]

We need two checks, one for push (write), one for watch (read), when device is
waiting for tag in proximity and finds NFC message that is too big, then it is
discarded.

+        return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError));
+
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     m_requests.add(resolver);
     auto callback = convertToBaseCallback(WTF::bind(&NFC::OnRequestCompleted, wrapPersistent(this), wrapPersistent(resolver)));
     m_nfc->Push(std::move(message), nfc::NFCPushOptions::From(options), callback);
 
     return resolver->promise();
 }
 
+// https://w3c.github.io/web-nfc/#dom-nfc-cancelpush
 ScriptPromise NFC::cancelPush(ScriptState* scriptState, const String& target)
 {
-    String errorMessage;
-    if (!scriptState->getExecutionContext()->isSecureContext(errorMessage))
-        return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(SecurityError, errorMessage));
-
-    if (!m_nfc)
-        return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError));
+    ScriptPromise promise = RejectIfNotSupported(scriptState);
+    if (!promise.isEmpty())
+        return promise;
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     m_requests.add(resolver);
     auto callback = convertToBaseCallback(WTF::bind(&NFC::OnRequestCompleted, wrapPersistent(this), wrapPersistent(resolver)));
     m_nfc->CancelPush(mojo::toNFCPushTarget(target), callback);
 
     return resolver->promise();
 }
 
+// https://w3c.github.io/web-nfc/#watching-for-content
+// https://w3c.github.io/web-nfc/#dom-nfc-watch
 ScriptPromise NFC::watch(ScriptState* scriptState, MessageCallback* callback, const NFCWatchOptions& options)
 {
-    // TODO(shalamov): To be implemented.
-    return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError));
+    ScriptPromise promise = RejectIfNotSupported(scriptState);
+    if (!promise.isEmpty())
+        return promise;
+
+    ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
+    m_requests.add(resolver);
+    auto watchCallback = convertToBaseCallback(WTF::bind(&NFC::OnWatchRegistered, wrapPersistent(this), wrapPersistent(callback), wrapPersistent(resolver)));
+    m_nfc->Watch(nfc::NFCWatchOptions::From(options), watchCallback);
+    return resolver->promise();
 }
 
+// https://w3c.github.io/web-nfc/#dom-nfc-cancelwatch
 ScriptPromise NFC::cancelWatch(ScriptState* scriptState, long id)
 {
-    // TODO(shalamov): To be implemented.
-    return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError));
+    ScriptPromise promise = RejectIfNotSupported(scriptState);
+    if (!promise.isEmpty())
+        return promise;
+
+    if (id)
+        m_callbacks.remove(id);
+    else
+        return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotFoundError));
+
+    ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
+    m_requests.add(resolver);
+    m_nfc->CancelWatch(id, convertToBaseCallback(WTF::bind(&NFC::OnRequestCompleted, wrapPersistent(this), wrapPersistent(resolver))));
+    return resolver->promise();
 }
 
+// https://w3c.github.io/web-nfc/#dom-nfc-cancelwatch
+// If watchId is not provided to nfc.cancelWatch, cancel all watch operations.
 ScriptPromise NFC::cancelWatch(ScriptState* scriptState)
 {
-    // TODO(shalamov): To be implemented.
-    return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError));
+    ScriptPromise promise = RejectIfNotSupported(scriptState);
+    if (!promise.isEmpty())
+        return promise;
+
+    m_callbacks.clear();
+    ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
+    m_requests.add(resolver);
+    m_nfc->CancelAllWatches(convertToBaseCallback(WTF::bind(&NFC::OnRequestCompleted, wrapPersistent(this), wrapPersistent(resolver))));
+    return resolver->promise();
 }
 
 void NFC::pageVisibilityChanged()
 {
     // If service is not initialized, there cannot be any pending NFC activities
     if (!m_nfc)
         return;
 
     // NFC operations should be suspended.
     // https://w3c.github.io/web-nfc/#nfc-suspended
@@ skipping 11 matching lines @@
     m_requests.remove(resolver);
     if (error.is_null())
         resolver->resolve();
     else
         resolver->reject(NFCError::take(resolver, error->error_type));
 }
 
 void NFC::OnConnectionError()
 {
     m_nfc.reset();
+    m_callbacks.clear();
 
     // 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, nfc::NFCErrorType::NOT_SUPPORTED));
 
     m_requests.clear();
 }
 
-void NFC::OnWatch(mojo::WTFArray<uint32_t> ids, nfc::NFCMessagePtr)
+void NFC::OnWatch(mojo::WTFArray<uint32_t> ids, nfc::NFCMessagePtr message)
 {
-    // TODO(shalamov): Not implemented.
+    ScriptState* scriptState = ScriptState::forMainWorld(toLocalFrame(page()->mainFrame()));

[dcheng, 2016/09/08 04:42:38]

Why does this always use the main frame? Can this API be used in subframes? Why
isn't this just using the frame associated with the execution context it's
observing?

[shalamov, 2016/09/22 13:53:22]

I added comment, according to the specification, api only accessible for secure
context (https) and only for top browsing context (main frame)

+    ScriptState::Scope scope(scriptState);
+    NFCMessage nfcMessage = toNFCMessage(message, scriptState);
+
+    for (size_t i = 0; i < ids.size(); ++i) {
+        WatchCallbacksMap::iterator it = m_callbacks.find(ids[i]);
+        if (it != m_callbacks.end()) {
+            it->value->handleMessage(nfcMessage);
+        }
+    }
+}
+
+ScriptPromise NFC::RejectIfNotSupported(ScriptState* scriptState)
+{
+    String errorMessage;
+    if (!scriptState->getExecutionContext()->isSecureContext(errorMessage)) {
+        return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(SecurityError, errorMessage));
+    }
+
+    if (!m_nfc)
+        return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError));
+
+    return ScriptPromise();
+}
+
+void NFC::OnWatchRegistered(MessageCallback* callback, ScriptPromiseResolver* resolver, uint32_t id, nfc::NFCErrorPtr error)
+{
+    m_requests.remove(resolver);
+
+    // Invalid id was returned.
+    // https://w3c.github.io/web-nfc/#dom-nfc-watch
+    // 8. If the request fails, reject promise with "NotSupportedError"
+    // and abort these steps.
+    if (!id) {
+        resolver->reject(NFCError::take(resolver, nfc::NFCErrorType::NOT_SUPPORTED));
+        return;
+    }
+
+    if (error.is_null()) {
+        m_callbacks.add(id, callback);
+        resolver->resolve(id);
+    } else {
+        resolver->reject(NFCError::take(resolver, error->error_type));
+    }
 }
 
 DEFINE_TRACE(NFC)
 {
     PageVisibilityObserver::trace(visitor);
     ContextLifecycleObserver::trace(visitor);
     visitor->trace(m_requests);
+    visitor->trace(m_callbacks);
 }
 
 } // namespace blink