[PresentationAPI] Plumbing send() from PresentationSession IDL to platform/.

Source/modules/presentation/PresentationSession.cpp

Index: Source/modules/presentation/PresentationSession.cpp
diff --git a/Source/modules/presentation/PresentationSession.cpp b/Source/modules/presentation/PresentationSession.cpp
index 47ba6253b3d33c471419808f6e6918b48f272bdd..866fb2039c8fdb5f6c1d078916fba5c6cd7f69a1 100644
--- a/Source/modules/presentation/PresentationSession.cpp
+++ b/Source/modules/presentation/PresentationSession.cpp
@@ -5,7 +5,10 @@
 #include "config.h"
 #include "modules/presentation/PresentationSession.h"
 
+#include "core/dom/DOMArrayBuffer.h"
+#include "core/dom/DOMArrayBufferView.h"
 #include "core/dom/Document.h"
+#include "core/dom/ExceptionCode.h"
 #include "core/events/Event.h"
 #include "core/frame/LocalFrame.h"
 #include "modules/EventTargetModules.h"
@@ -36,6 +39,11 @@ const AtomicString& SessionStateToString(WebPresentationSessionState state)
     return disconnectedValue;
 }
 
+void throwPresentationDisconnectedError(ExceptionState& exceptionState)
+{
+    exceptionState.throwDOMException(InvalidStateError, "Presentation session is disconnected.");
+}
+
 } // namespace
 
 PresentationSession::PresentationSession(LocalFrame* frame, const String& id, const String& url)
@@ -90,8 +98,54 @@ const AtomicString& PresentationSession::state() const
     return SessionStateToString(m_state);
 }
 
-void PresentationSession::postMessage(const String& message)
+void PresentationSession::send(const String& message, ExceptionState& exceptionState)
+{
+    if (m_state != WebPresentationSessionState::Connected) {
+        throwPresentationDisconnectedError(exceptionState);
+        return;
+    }
+    if (message.isNull() || message.isEmpty())

[whywhat, 2015/04/13 12:58:45]

I wonder if sending empty messages should be okay (e.g. to ping the
presentation)?
It seems that WebRTC standard is not clear about this and Chromium
implementation doesn't pass empty messages through.
I think the way it is implemented now is fine but wanted to raise the issue.

[USE s.singapati at gmail.com, 2015/04/13 16:45:36]

Acknowledged.

+        return;
+
+    PresentationController* controller = presentationController();
+    if (controller)
+        controller->send(m_url, m_id, message);
+}
+
+void PresentationSession::send(Blob* data, ExceptionState& exceptionState)
+{
+    exceptionState.throwDOMException(NotSupportedError, "Blob support not implemented yet.");
+    // TODO(s.singapati): To be implemented.
+}
+
+void PresentationSession::send(PassRefPtr<DOMArrayBuffer> data, ExceptionState& exceptionState)
 {
+    if (m_state != WebPresentationSessionState::Connected) {
+        throwPresentationDisconnectedError(exceptionState);
+        return;
+    }
+    ASSERT(data && data->buffer());
+    if (!data->byteLength())
+        return;
+
+    PresentationController* controller = presentationController();
+    if (controller)
+        controller->send(m_url, m_id, static_cast<const char*>(data->data()), data->byteLength());
+}
+
+void PresentationSession::send(PassRefPtr<DOMArrayBufferView> data, ExceptionState& exceptionState)

[whywhat, 2015/04/13 12:58:45]

looks like both send() methods for ArrayBufferView and ArrayBuffer could be
implemented via a common private sendInternal() method:

void PS::send(PRP<DAB> data, ES& eS) {
  ASSERT(data && data->buffer());
  sendInternal(static_cast<const char*>(data->data()), data->byteLength(), eS);
}

void PS::send(PRP<DABV> data, ES& eS) {
  ASSERT(data);
  sendInternal(static_cast<const char*>(data->baseAddress()),
data->byteLength(), eS);
}

void PS::sendInternal(const char* data, size_t size, ES& eS) {
  ASSERT(data);
  if (m_state != WPSS::Connected) { throwPDE(eS); return }

  if (!size) return;

  PC* controller = pC();
  if (controller)
    controller->send(m_url, m_id, data, size);
}

I wonder if we could also implement sending a string the same way? Do we need to
distinguish between an array of bytes and a string?

[USE s.singapati at gmail.com, 2015/04/13 16:45:36]

Done. Re factored this. sending a string the same way is other option for eg.
sending String.characters8() which is <const unsigned char*>. But sending all
types in same way may need extra argument to indicate what message/binary type
is sent (for the purpose of onmessage implementation)

Also, array buffer data can be sent as <const unsigned char*>. And mojo does not
have 'char' as basic types but, have int8, uint8. so probably char* needs
conversion in presentation_dispatcher. I will check more on this and align with
mojo capabilities.

+{
+    if (m_state != WebPresentationSessionState::Connected) {
+        throwPresentationDisconnectedError(exceptionState);
+        return;
+    }
+    ASSERT(data);

[whywhat, 2015/04/13 12:58:45]

Do you need to ASSERT for data->baseAddress()?

[USE s.singapati at gmail.com, 2015/04/13 16:45:36]

Done. Now it is done in sendInternal().

+    if (!data->byteLength())
+        return;
+
+    PresentationController* controller = presentationController();
+    if (controller)
+        controller->send(m_url, m_id, static_cast<const char*>(data->baseAddress()), data->byteLength());
 }
 
 void PresentationSession::close()