Mojo Java bindings: org.chromium.mojom -> org.chromium

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 "platform/mojo/MojoHelper.h"
 #include "public/platform/InterfaceProvider.h"
 
-namespace nfc = device::nfc::blink;
+namespace mojom = device::nfc::mojom::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::NFCPushOptions;
-using nfc::NFCPushOptionsPtr;
-using nfc::NFCPushTarget;
+using mojom::NFCMessage;
+using mojom::NFCMessagePtr;
+using mojom::NFCRecord;
+using mojom::NFCRecordPtr;
+using mojom::NFCRecordType;
+using mojom::NFCPushOptions;
+using mojom::NFCPushOptionsPtr;
+using mojom::NFCPushTarget;
 
 NFCPushTarget toNFCPushTarget(const WTF::String& target)
 {
     if (target == "tag")
         return NFCPushTarget::TAG;
 
     if (target == "peer")
         return NFCPushTarget::PEER;
 
     return NFCPushTarget::ANY;
@@ skipping 299 matching lines @@
     return true;
 }
 
 bool isValidOpaqueRecord(const NFCRecord& record)
 {
     return record.data().v8Value()->IsArrayBuffer();
 }
 
 bool isValidNFCRecord(const NFCRecord& record)
 {
-    nfc::NFCRecordType type;
+    mojom::NFCRecordType type;
     if (record.hasRecordType()) {
         type = mojo::toNFCRecordType(record.recordType());
     } else {
         type = mojo::deduceRecordTypeFromDataType(record);
 
         // https://w3c.github.io/web-nfc/#creating-web-nfc-message
         // If NFCRecord.recordType is not set and record type cannot be deduced
         // from NFCRecord.data, reject promise with SyntaxError.
-        if (type == nfc::NFCRecordType::EMPTY)
+        if (type == mojom::NFCRecordType::EMPTY)
             return false;
     }
 
     // Non-empty records must have data.
-    if (!record.hasData() && (type != nfc::NFCRecordType::EMPTY))
+    if (!record.hasData() && (type != mojom::NFCRecordType::EMPTY))
         return false;
 
     switch (type) {
-    case nfc::NFCRecordType::TEXT:
+    case mojom::NFCRecordType::TEXT:
         return isValidTextRecord(record);
-    case nfc::NFCRecordType::URL:
+    case mojom::NFCRecordType::URL:
         return isValidURLRecord(record);
-    case nfc::NFCRecordType::JSON:
+    case mojom::NFCRecordType::JSON:
         return isValidJSONRecord(record);
-    case nfc::NFCRecordType::OPAQUE_RECORD:
+    case mojom::NFCRecordType::OPAQUE_RECORD:
         return isValidOpaqueRecord(record);
-    case nfc::NFCRecordType::EMPTY:
+    case mojom::NFCRecordType::EMPTY:
         return !record.hasData() && record.mediaType().isEmpty();
     }
 
     NOTREACHED();
     return false;
 }
 
 DOMException* isValidNFCRecordArray(const HeapVector<NFCRecord>& records)
 {
     // https://w3c.github.io/web-nfc/#the-push-method
@@ skipping 17 matching lines @@
     if (message.isNFCMessage()) {
         if (!message.getAsNFCMessage().hasData())
             return DOMException::create(TypeMismatchError);
 
         return isValidNFCRecordArray(message.getAsNFCMessage().data());
     }
 
     return nullptr;
 }
 
-bool setURL(const String& origin, nfc::NFCMessagePtr& message)
+bool setURL(const String& origin, mojom::NFCMessagePtr& message)
 {
     KURL originURL(ParsedURLString, origin);
 
     if (!message->url.isEmpty() && originURL.canSetPathname()) {
         originURL.setPath(message->url);
     }
 
     message->url = originURL;
     return originURL.isValid();
 }
@@ skipping 42 matching lines @@
     if (!scriptState->getExecutionContext()->isSecureContext(errorMessage))
         return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(SecurityError, errorMessage));
 
     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);
+    mojom::NFCMessagePtr message = mojom::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_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);
+    m_nfc->Push(std::move(message), mojom::NFCPushOptions::From(options), callback);
 
     return resolver->promise();
 }
 
 ScriptPromise NFC::cancelPush(ScriptState* scriptState, const String& target)
 {
     String errorMessage;
     if (!scriptState->getExecutionContext()->isSecureContext(errorMessage))
         return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(SecurityError, errorMessage));
 
@@ skipping 33 matching lines @@
         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::OnRequestCompleted(ScriptPromiseResolver* resolver, nfc::NFCErrorPtr error)
+void NFC::OnRequestCompleted(ScriptPromiseResolver* resolver, mojom::NFCErrorPtr error)
 {
     if (!m_requests.contains(resolver))
         return;
 
     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();
 
     // 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));
+        resolver->reject(NFCError::take(resolver, mojom::NFCErrorType::NOT_SUPPORTED));
 
     m_requests.clear();
 }
 
-void NFC::OnWatch(mojo::WTFArray<uint32_t> ids, nfc::NFCMessagePtr)
+void NFC::OnWatch(mojo::WTFArray<uint32_t> ids, mojom::NFCMessagePtr)
 {
     // TODO(shalamov): Not implemented.
 }
 
 DEFINE_TRACE(NFC)
 {
     PageVisibilityObserver::trace(visitor);
     ContextLifecycleObserver::trace(visitor);
     visitor->trace(m_requests);
 }
 
 } // namespace blink