web-nfc: Join NDEFReader and NDEFWriter

refers to w3c/web-nfc#601

Bug: 1131141
Change-Id: I8cc2ce053e5bb43c0fa5b299bdaf5cb5317bf859

Author: arskama

third_party/blink/renderer/bindings/generated_in_modules.gni

@@ -1633,8 +1633,6 @@ generated_interface_sources_in_modules = [
   "$root_gen_dir/third_party/blink/renderer/bindings/modules/v8/v8_ndef_reading_event.h",
   "$root_gen_dir/third_party/blink/renderer/bindings/modules/v8/v8_ndef_record.cc",
   "$root_gen_dir/third_party/blink/renderer/bindings/modules/v8/v8_ndef_record.h",
-  "$root_gen_dir/third_party/blink/renderer/bindings/modules/v8/v8_ndef_writer.cc",
-  "$root_gen_dir/third_party/blink/renderer/bindings/modules/v8/v8_ndef_writer.h",
   "$root_gen_dir/third_party/blink/renderer/bindings/modules/v8/v8_network_information.cc",
   "$root_gen_dir/third_party/blink/renderer/bindings/modules/v8/v8_network_information.h",
   "$root_gen_dir/third_party/blink/renderer/bindings/modules/v8/v8_notification.cc",

third_party/blink/renderer/bindings/idl_in_modules.gni

@@ -403,7 +403,6 @@ static_idl_files_in_modules = get_path_info(
           "//third_party/blink/renderer/modules/nfc/ndef_record_init.idl",
           "//third_party/blink/renderer/modules/nfc/ndef_scan_options.idl",
           "//third_party/blink/renderer/modules/nfc/ndef_write_options.idl",
-          "//third_party/blink/renderer/modules/nfc/ndef_writer.idl",
           "//third_party/blink/renderer/modules/notifications/get_notification_options.idl",
           "//third_party/blink/renderer/modules/notifications/notification.idl",
           "//third_party/blink/renderer/modules/notifications/notification_action.idl",

third_party/blink/renderer/modules/nfc/BUILD.gn

@@ -14,8 +14,6 @@ blink_modules_sources("nfc") {
     "ndef_reading_event.h",
     "ndef_record.cc",
     "ndef_record.h",
-    "ndef_writer.cc",
-    "ndef_writer.h",
     "nfc_proxy.cc",
     "nfc_proxy.h",
     "nfc_type_converters.cc",

third_party/blink/renderer/modules/nfc/idls.gni

@@ -7,7 +7,6 @@ modules_idl_files = [
   "ndef_record.idl",
   "ndef_reader.idl",
   "ndef_reading_event.idl",
-  "ndef_writer.idl",
 ]
 
 modules_dictionary_idl_files = [

third_party/blink/renderer/modules/nfc/ndef_reader.cc

@@ -6,10 +6,12 @@
 
 #include <utility>
 
+#include "mojo/public/cpp/bindings/callback_helpers.h"
 #include "services/device/public/mojom/nfc.mojom-blink.h"
-#include "third_party/blink/renderer/bindings/core/v8/script_promise_resolver.h"
 #include "third_party/blink/renderer/bindings/core/v8/source_location.h"
+#include "third_party/blink/renderer/bindings/modules/v8/string_or_array_buffer_or_array_buffer_view_or_ndef_message_init.h"
 #include "third_party/blink/renderer/bindings/modules/v8/v8_ndef_scan_options.h"
+#include "third_party/blink/renderer/bindings/modules/v8/v8_ndef_write_options.h"
 #include "third_party/blink/renderer/core/dom/abort_signal.h"
 #include "third_party/blink/renderer/core/dom/dom_exception.h"
 #include "third_party/blink/renderer/core/events/error_event.h"
@@ -19,6 +21,7 @@
 #include "third_party/blink/renderer/modules/nfc/ndef_message.h"
 #include "third_party/blink/renderer/modules/nfc/ndef_reading_event.h"
 #include "third_party/blink/renderer/modules/nfc/nfc_proxy.h"
+#include "third_party/blink/renderer/modules/nfc/nfc_type_converters.h"
 #include "third_party/blink/renderer/modules/nfc/nfc_utils.h"
 #include "third_party/blink/renderer/modules/permissions/permission_utils.h"
 #include "third_party/blink/renderer/platform/instrumentation/use_counter.h"
@@ -49,7 +52,8 @@ NDEFReader* NDEFReader::Create(ExecutionContext* context) {
 }
 
 NDEFReader::NDEFReader(ExecutionContext* context)
-    : ExecutionContextLifecycleObserver(context), permission_service_(context) {
+    : ExecutionContextLifecycleObserver(context),
+      permission_service_(context) {
   // Call GetNFCProxy to create a proxy. This guarantees no allocation will
   // be needed when calling HasPendingActivity later during gc tracing.
   GetNfcProxy();
@@ -114,29 +118,19 @@ ScriptPromise NDEFReader::scan(ScriptState* script_state,
   // to reader.[[Signal]]:
   if (options->hasSignal()) {
     options->signal()->AddAlgorithm(
-        WTF::Bind(&NDEFReader::Abort, WrapPersistent(this)));
+        WTF::Bind(&NDEFReader::ReadAbort, WrapPersistent(this)));
   }
 
   GetPermissionService()->RequestPermission(
       CreatePermissionDescriptor(PermissionName::NFC),
       LocalFrame::HasTransientUserActivation(frame),
-      WTF::Bind(&NDEFReader::OnRequestPermission, WrapPersistent(this),
+      WTF::Bind(&NDEFReader::ReadOnRequestPermission, WrapPersistent(this),
                 WrapPersistent(options)));
   return resolver_->Promise();
 }
 
-PermissionService* NDEFReader::GetPermissionService() {
-  if (!permission_service_.is_bound()) {
-    ConnectToPermissionService(
-        GetExecutionContext(),
-        permission_service_.BindNewPipeAndPassReceiver(
-            GetExecutionContext()->GetTaskRunner(TaskType::kMiscPlatformAPI)));
-  }
-  return permission_service_.get();
-}
-
-void NDEFReader::OnRequestPermission(const NDEFScanOptions* options,
-                                     PermissionStatus status) {
+void NDEFReader::ReadOnRequestPermission(const NDEFScanOptions* options,
+                                         PermissionStatus status) {
   if (!resolver_) {
     has_pending_scan_request_ = false;
     return;
@@ -163,10 +157,10 @@ void NDEFReader::OnRequestPermission(const NDEFScanOptions* options,
 
   GetNfcProxy()->StartReading(
       this,
-      WTF::Bind(&NDEFReader::OnScanRequestCompleted, WrapPersistent(this)));
+      WTF::Bind(&NDEFReader::ScanOnRequestCompleted, WrapPersistent(this)));
 }
 
-void NDEFReader::OnScanRequestCompleted(
+void NDEFReader::ScanOnRequestCompleted(
     device::mojom::blink::NDEFErrorPtr error) {
   has_pending_scan_request_ = false;
   if (!resolver_)
@@ -182,14 +176,6 @@ void NDEFReader::OnScanRequestCompleted(
   resolver_.Clear();
 }
 
-void NDEFReader::Trace(Visitor* visitor) const {
-  visitor->Trace(permission_service_);
-  visitor->Trace(resolver_);
-  EventTargetWithInlineData::Trace(visitor);
-  ActiveScriptWrappable::Trace(visitor);
-  ExecutionContextLifecycleObserver::Trace(visitor);
-}
-
 void NDEFReader::OnReading(const String& serial_number,
                            const device::mojom::blink::NDEFMessage& message) {
   DCHECK(GetNfcProxy()->IsReading(this));
@@ -204,19 +190,6 @@ void NDEFReader::OnError(const String& message) {
   DispatchEvent(*event);
 }
 
-void NDEFReader::OnMojoConnectionError() {
-  // If |resolver_| has already settled this rejection is silently ignored.
-  if (resolver_) {
-    resolver_->Reject(NDEFErrorTypeToDOMException(
-        device::mojom::blink::NDEFErrorType::NOT_SUPPORTED,
-        kNotSupportedOrPermissionDenied));
-    resolver_.Clear();
-  }
-
-  // Dispatches an error event.
-  OnError(kNotSupportedOrPermissionDenied);
-}
-
 void NDEFReader::ContextDestroyed() {
   // If |resolver_| has already settled this rejection is silently ignored.
   if (resolver_) {
@@ -228,7 +201,7 @@ void NDEFReader::ContextDestroyed() {
   GetNfcProxy()->StopReading(this);
 }
 
-void NDEFReader::Abort() {
+void NDEFReader::ReadAbort() {
   if (resolver_) {
     resolver_->Reject(MakeGarbageCollected<DOMException>(
         DOMExceptionCode::kAbortError, "The NFC operation was cancelled."));
@@ -238,9 +211,180 @@ void NDEFReader::Abort() {
   GetNfcProxy()->StopReading(this);
 }
 
+// https://w3c.github.io/web-nfc/#writing-content
+// https://w3c.github.io/web-nfc/#the-write-method
+ScriptPromise NDEFReader::write(ScriptState* script_state,
+                                const NDEFMessageSource& write_message,
+                                const NDEFWriteOptions* options,
+                                ExceptionState& exception_state) {
+  LocalDOMWindow* window = script_state->ContextIsValid()
+                               ? LocalDOMWindow::From(script_state)
+                               : nullptr;
+  // https://w3c.github.io/web-nfc/#security-policies
+  // WebNFC API must be only accessible from top level browsing context.
+  if (!window || !window->GetFrame()->IsMainFrame()) {
+    exception_state.ThrowDOMException(DOMExceptionCode::kNotAllowedError,
+                                      "NFC interfaces are only avaliable "
+                                      "in a top-level browsing context");
+    return ScriptPromise();
+  }
+
+  if (options->hasSignal() && options->signal()->aborted()) {
+    // If signal’s aborted flag is set, then reject p with an "AbortError"
+    // DOMException and return p.
+    exception_state.ThrowDOMException(DOMExceptionCode::kAbortError,
+                                      "The NFC operation was cancelled.");
+    return ScriptPromise();
+  }
+
+  // Step 11.2: Run "create NDEF message", if this throws an exception,
+  // reject p with that exception and abort these steps.
+  NDEFMessage* ndef_message =
+      NDEFMessage::Create(window, write_message, exception_state);
+  if (exception_state.HadException()) {
+    return ScriptPromise();
+  }
+
+  auto message = device::mojom::blink::NDEFMessage::From(ndef_message);
+  DCHECK(message);
+
+  auto* resolver = MakeGarbageCollected<ScriptPromiseResolver>(script_state);
+  requests_.insert(resolver);
+  InitNfcProxyIfNeeded();
+  GetPermissionService()->RequestPermission(
+      CreatePermissionDescriptor(PermissionName::NFC),
+      LocalFrame::HasTransientUserActivation(window->GetFrame()),
+      WTF::Bind(&NDEFReader::WriteOnRequestPermission, WrapPersistent(this),
+                WrapPersistent(resolver), WrapPersistent(options),
+                std::move(message)));
+
+  return resolver->Promise();
+}
+
+void NDEFReader::WriteOnRequestPermission(
+    ScriptPromiseResolver* resolver,
+    const NDEFWriteOptions* options,
+    device::mojom::blink::NDEFMessagePtr message,
+    PermissionStatus status) {
+  if (status != PermissionStatus::GRANTED) {
+    resolver->Reject(MakeGarbageCollected<DOMException>(
+        DOMExceptionCode::kNotAllowedError, "NFC permission request denied."));
+    return;
+  }
+
+  if (options->hasSignal() && options->signal()->aborted()) {
+    resolver->Reject(MakeGarbageCollected<DOMException>(
+        DOMExceptionCode::kAbortError, "The NFC operation was cancelled."));
+    return;
+  }
+
+  // If signal is not null, then add the abort steps to signal.
+  if (options->hasSignal() && !options->signal()->aborted()) {
+    options->signal()->AddAlgorithm(WTF::Bind(&NDEFReader::WriteAbort,
+                                              WrapPersistent(this),
+                                              WrapPersistent(resolver)));
+  }
+
+  UseCounter::Count(GetExecutionContext(), WebFeature::kWebNfcNdefWriterWrite);
+  // TODO(https://crbug.com/994936) remove when origin trial is complete.
+  UseCounter::Count(GetExecutionContext(), WebFeature::kWebNfcAPI);
+
+  auto callback = WTF::Bind(&NDEFReader::WriteOnRequestCompleted,
+                            WrapPersistent(this), WrapPersistent(resolver));
+  nfc_proxy_->Push(std::move(message),
+                   device::mojom::blink::NDEFWriteOptions::From(options),
+                   std::move(callback));
+}
+
+void NDEFReader::WriteOnRequestCompleted(ScriptPromiseResolver* resolver,
+                                    device::mojom::blink::NDEFErrorPtr error) {
+  DCHECK(requests_.Contains(resolver));
+
+  requests_.erase(resolver);
+
+  if (error.is_null()) {
+    resolver->Resolve();
+  } else {
+    resolver->Reject(
+        NDEFErrorTypeToDOMException(error->error_type, error->error_message));
+  }
+}
+
+void NDEFReader::WriteAbort(ScriptPromiseResolver* resolver) {
+  // |nfc_proxy_| could be null on Mojo connection failure, simply ignore the
+  // abort request in this case.
+  if (!nfc_proxy_)
+    return;
+
+  // OnRequestCompleted() should always be called whether the push operation is
+  // cancelled successfully or not. So do nothing for the cancelled callback.
+  nfc_proxy_->CancelPush(device::mojom::blink::NFC::CancelPushCallback());
+}
+
+void NDEFReader::InitNfcProxyIfNeeded() {
+  // Init NfcProxy if needed.
+  if (nfc_proxy_) {
+    nfc_proxy_->AddWriter(this);
+    return;
+  }
+
+  nfc_proxy_ = NFCProxy::From(*To<LocalDOMWindow>(GetExecutionContext()));
+  DCHECK(nfc_proxy_);
+
+  // Add the writer to proxy's writer list for mojo connection error
+  // notification.
+  nfc_proxy_->AddWriter(this);
+}
+
 NFCProxy* NDEFReader::GetNfcProxy() const {
   DCHECK(GetExecutionContext());
   return NFCProxy::From(*To<LocalDOMWindow>(GetExecutionContext()));
 }
 
+void NDEFReader::Trace(Visitor* visitor) const {
+  visitor->Trace(permission_service_);
+  visitor->Trace(nfc_proxy_);
+  visitor->Trace(resolver_);
+  visitor->Trace(requests_);
+  EventTargetWithInlineData::Trace(visitor);
+  ActiveScriptWrappable::Trace(visitor);
+  ExecutionContextLifecycleObserver::Trace(visitor);
+}
+
+PermissionService* NDEFReader::GetPermissionService() {
+  if (!permission_service_.is_bound()) {
+    ConnectToPermissionService(
+        GetExecutionContext(),
+        permission_service_.BindNewPipeAndPassReceiver(
+            GetExecutionContext()->GetTaskRunner(TaskType::kMiscPlatformAPI)));
+  }
+  return permission_service_.get();
+}
+
+void NDEFReader::ReadOnMojoConnectionError() {
+  // If |resolver_| has already settled this rejection is silently ignored.
+  if (resolver_) {
+    resolver_->Reject(NDEFErrorTypeToDOMException(
+        device::mojom::blink::NDEFErrorType::NOT_SUPPORTED,
+        kNotSupportedOrPermissionDenied));
+    resolver_.Clear();
+  }
+
+  // Dispatches an error event.
+  OnError(kNotSupportedOrPermissionDenied);
+}
+
+void NDEFReader::WriteOnMojoConnectionError() {
+  nfc_proxy_.Clear();
+
+  // If the mojo connection breaks, all push requests will be rejected with a
+  // default error.
+  for (ScriptPromiseResolver* resolver : requests_) {
+    resolver->Reject(NDEFErrorTypeToDOMException(
+        device::mojom::blink::NDEFErrorType::NOT_SUPPORTED,
+        kNotSupportedOrPermissionDenied));
+  }
+  requests_.clear();
+}
+
 }  // namespace blink