[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/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/ServiceRegistry.h"
 
 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 device::wtf::NFCMessage;
 using device::wtf::NFCMessagePtr;
 using device::wtf::NFCRecord;
 using device::wtf::NFCRecordPtr;
 using device::wtf::NFCRecordType;
+using device::wtf::NFCRecordTypeFilter;
+using device::wtf::NFCRecordTypeFilterPtr;
 using device::wtf::NFCPushOptions;
 using device::wtf::NFCPushOptionsPtr;
 using device::wtf::NFCPushTarget;
+using device::wtf::NFCWatchMode;
+using device::wtf::NFCWatchOptions;
+using device::wtf::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;
 
     ASSERT_NOT_REACHED();
     return NFCRecordType::EMPTY;
 }
 
+NFCWatchMode toNFCWatchMode(const WTF::String& watchMode)
+{
+    if (watchMode == "web-nfc-only")
+        return NFCWatchMode::WEBNFC_ONLY;
+
+    if (watchMode == "any")
+        return NFCWatchMode::ANY;
+
+    ASSERT_NOT_REACHED();
+    return NFCWatchMode::WEBNFC_ONLY;
+}
+
 // https://w3c.github.io/web-nfc/#creating-web-nfc-message Step 2.1
 // If NFCRecord type is not provided, deduct NFCRecord type from JS data type:
 // String or Number => 'text' record
 // ArrayBuffer => 'opaque' record
 // JSON serializable Object => 'json' record
 NFCRecordType deductRecordTypeFromDataType(const blink::NFCRecord& record)
 {
     if (record.hasData()) {
         v8::Local<v8::Value> value = record.data().v8Value();
 
@@ skipping 218 matching lines @@
 
         if (pushOptions.hasIgnoreRead())
             pushOptionsPtr->ignoreRead = pushOptions.ignoreRead();
         else
             pushOptionsPtr->ignoreRead = 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->mediaType = watchOptions.mediaType();
+
+        if (watchOptions.hasMode())
+            watchOptionsPtr->mode = toNFCWatchMode(watchOptions.mode());
+        else
+            watchOptionsPtr->mode = NFCWatchMode::WEBNFC_ONLY;
+
+        if (watchOptions.hasRecordType()) {
+            watchOptionsPtr->recordFilter = NFCRecordTypeFilter::New();
+            watchOptionsPtr->recordFilter->recordType = toNFCRecordType(watchOptions.recordType());
+        }
+
+        return watchOptionsPtr;
+    }
+};
+
 } // namespace mojo
 
 namespace blink {
 
 
 namespace {
 
 bool isValidTextRecord(const NFCRecord& record)
 {
     v8::Local<v8::Value> value = record.data().v8Value();
@@ skipping 102 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 device::wtf::NFCRecordType& type)
+{
+    switch (type) {
+    case device::wtf::NFCRecordType::TEXT:
+        return "text";
+    case device::wtf::NFCRecordType::URL:
+        return "url";
+    case device::wtf::NFCRecordType::JSON:
+        return "json";
+    case device::wtf::NFCRecordType::OPAQUE_RECORD:
+        return "opaque";
+    case device::wtf::NFCRecordType::EMPTY:
+        return "empty";
+    }
+
+    ASSERT_NOT_REACHED();
+    return String();
+}
+
+v8::Local<v8::Value> toV8(const device::wtf::NFCRecordPtr& record, ScriptState* scriptState)
+{
+    switch (record->recordType) {
+    case device::wtf::NFCRecordType::TEXT:
+    case device::wtf::NFCRecordType::URL:
+    case device::wtf::NFCRecordType::JSON: {
+        String stringData;
+        if (!record->data.empty())
+            stringData = String::fromUTF8WithLatin1Fallback(static_cast<unsigned char*>(&record->data.front()), record->data.size());
+
+        if (record->recordType == device::wtf::NFCRecordType::JSON)
+            return v8::JSON::Parse(scriptState->isolate(), v8String(scriptState->isolate(), stringData)).ToLocalChecked();
+        return v8String(scriptState->isolate(), stringData);
+    }
+
+    case device::wtf::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 device::wtf::NFCRecordType::EMPTY:
+        return v8::Null(scriptState->isolate());
+    }
+
+    ASSERT_NOT_REACHED();
+    return v8::Local<v8::Value>();
+}
+
+NFCRecord toNFCRecord(const device::wtf::NFCRecordPtr& record, ScriptState* scriptState)
+{
+    NFCRecord nfcRecord;
+    nfcRecord.setMediaType(record->mediaType);
+    nfcRecord.setRecordType(toNFCRecordType(record->recordType));
+    nfcRecord.setData(ScriptValue(scriptState, toV8(record, scriptState)));
+    return nfcRecord;
+}
+
+NFCMessage toNFCMessage(const device::wtf::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;
+}
+
 } // anonymous namespace
 
+template <typename T>
+class NFCCallbackBase {
+public:
+    explicit NFCCallbackBase(ScriptPromiseResolver* resolver)
+        : m_promiseAdapter(adoptPtr(new T(resolver))) { }
+
+    // If NFCService is not available or disappears when NFC HW is disabled,
+    // mojo service will invalidate proxy and destroy all pending callbacks.
+    // Promise will be rejected with NotSupportedError exception.
+    virtual ~NFCCallbackBase()
+    {
+        m_promiseAdapter->onError(device::wtf::NFCErrorType::NOT_SUPPORTED);
+    }
+
+protected:
+    OwnPtr<T> m_promiseAdapter;
+};
+
 using NFCMojoCallback = mojo::Callback<void(device::wtf::NFCErrorPtr)>;
-class NFCCallback final : public NFCMojoCallback::Runnable {
+using NFCCallbackPromiseAdapter = CallbackPromiseAdapter<void, NFCError>;
+
+class NFCCallback final : public NFCMojoCallback::Runnable,
+    public NFCCallbackBase<NFCCallbackPromiseAdapter> {
     WTF_MAKE_NONCOPYABLE(NFCCallback);
 public:
-    using NFCCallbackPromiseAdapter = CallbackPromiseAdapter<void, NFCError>;
     explicit NFCCallback(ScriptPromiseResolver* resolver)
-    : m_promiseAdapter(adoptPtr(new NFCCallbackPromiseAdapter(resolver))) { }
-
-    ~NFCCallback() override
-    {
-        // If NFCService is not available or disappears when NFC HW is disabled,
-        // reject promise with NotSupportedError exception.
-        m_promiseAdapter->onError(device::wtf::NFCErrorType::NOT_SUPPORTED);
-    }
+    : NFCCallbackBase<NFCCallbackPromiseAdapter>(resolver) { }
 
     void Run(device::wtf::NFCErrorPtr error) override
     {
         if (error.is_null())
             m_promiseAdapter->onSuccess();
         else
             m_promiseAdapter->onError(error->error_type);
     }
+};
+
+using NFCWatchMojoCallback = mojo::Callback<void(uint32_t, device::wtf::NFCErrorPtr)>;
+using NFCWatchCallbackPromiseAdapter = CallbackPromiseAdapter<uint32_t, NFCError>;
+
+class NFCWatchCallback final : public NFCWatchMojoCallback::Runnable,
+    public NFCCallbackBase<NFCWatchCallbackPromiseAdapter> {
+    WTF_MAKE_NONCOPYABLE(NFCWatchCallback);
+public:
+    NFCWatchCallback(ScriptPromiseResolver* resolver, NFC* nfc, MessageCallback* callback)
+    : NFCCallbackBase<NFCWatchCallbackPromiseAdapter>(resolver)
+    , m_nfc(nfc)
+    , m_callback(callback) { }
+
+    void Run(uint32_t watchId, device::wtf::NFCErrorPtr error) override
+    {
+        if (error.is_null()) {
+            m_nfc->OnWatchRegistered(watchId, m_callback);
+            m_promiseAdapter->onSuccess(watchId);
+        } else {
+            m_promiseAdapter->onError(error->error_type);
+        }
+    }
 
 private:
-    OwnPtr<NFCCallbackPromiseAdapter> m_promiseAdapter;
+    Persistent<NFC> m_nfc;
+    Persistent<MessageCallback> m_callback;
 };
 
 NFC::NFC(LocalFrame* frame)
     : PageLifecycleObserver(frame ? frame->page() : 0),
     m_client(this)
 {
 }
 
 NFC* NFC::create(LocalFrame* frame)
 {
     NFC* nfc = new NFC(frame);
     return nfc;
 }
 
 NFC::~NFC() = default;
 
 // 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 (!Initialize(scriptState->domWindow()->frame()->serviceRegistry()))
-        return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError));
-
     device::wtf::NFCMessagePtr message = device::wtf::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));
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     m_nfc->Push(std::move(message), device::wtf::NFCPushOptions::From(options), device::wtf::NFC::PushCallback(new NFCCallback(resolver)));
 
     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 (!Initialize(scriptState->domWindow()->frame()->serviceRegistry()))
-        return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError));
+    ScriptPromise promise = RejectIfNotSupported(scriptState);
+    if (!promise.isEmpty())
+        return promise;
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     m_nfc->CancelPush(mojo::toNFCPushTarget(target), device::wtf::NFC::CancelPushCallback(new NFCCallback(resolver)));
 
     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);
+    device::wtf::NFC::WatchCallback watchCallback(new NFCWatchCallback(resolver, this, callback));
+    m_nfc->Watch(device::wtf::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_nfc->CancelWatch(id, device::wtf::NFC::CancelWatchCallback(new NFCCallback(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_nfc->CancelAllWatches(device::wtf::NFC::CancelAllWatchesCallback(new NFCCallback(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
     if (page()->visibilityState() == PageVisibilityStateVisible)
         m_nfc->ResumeNFCOperations();
     else
         m_nfc->SuspendNFCOperations();
 }
 
 void NFC::OnWatch(uint32_t id, device::wtf::NFCMessagePtr message)
 {
+    WatchCallbacksMap::iterator it = m_callbacks.find(id);
+    if (it != m_callbacks.end()) {
+        ScriptState* scriptState = ScriptState::forMainWorld(toLocalFrame(page()->mainFrame()));
+        ScriptState::Scope scope(scriptState);
+        it->value->handleMessage(toNFCMessage(message, scriptState));
+    }
 }
 
 bool NFC::Initialize(ServiceRegistry* registry)
 {
     DCHECK(registry);
 
     if (m_nfc)
         return true;
 
     registry->connectToRemoteService(mojo::GetProxy(&m_nfc));
 
     if (m_nfc) {
         m_nfc.set_connection_error_handler(sameThreadBindForMojo(&NFC::OnError, this));
         m_nfc->SetClient(m_client.CreateInterfacePtrAndBind());
     }
 
     return m_nfc;
 }
 
+ScriptPromise NFC::RejectIfNotSupported(ScriptState* scriptState)
+{
+    String errorMessage;
+    if (!scriptState->getExecutionContext()->isSecureContext(errorMessage)) {
+        return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(SecurityError, errorMessage));
+    }
+
+    if (!Initialize(scriptState->domWindow()->frame()->serviceRegistry()))
+        return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError));
+
+    return ScriptPromise();
+}
+
 void NFC::OnError()
 {
-    // todo(shalamov): clear map that contains nfc watch callbacks
+    m_callbacks.clear();
     if (m_client.is_bound())
         m_client.Close();
     m_nfc.reset();
 }
 
+void NFC::OnWatchRegistered(uint32_t id, MessageCallback* callback)
+{
+    if (id)
+        m_callbacks.add(id, callback);
+}
+
 DEFINE_TRACE(NFC)
 {
     PageLifecycleObserver::trace(visitor);
+    visitor->trace(m_callbacks);
 }
 
 } // namespace blink