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

Source/modules/presentation/PresentationSession.cpp

 // Copyright 2014 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 "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"
 #include "modules/presentation/Presentation.h"
 #include "modules/presentation/PresentationController.h"
 #include "public/platform/modules/presentation/WebPresentationSessionClient.h"
 #include "wtf/Assertions.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/text/AtomicString.h"
 
@@ skipping 10 matching lines @@
     case WebPresentationSessionState::Connected:
         return connectedValue;
     case WebPresentationSessionState::Disconnected:
         return disconnectedValue;
     }
 
     ASSERT_NOT_REACHED();
     return disconnectedValue;
 }
 
+void throwPresentationDisconnectedError(ExceptionState& exceptionState)
+{
+    exceptionState.throwDOMException(InvalidStateError, "Presentation session is disconnected.");
+}
+
 } // namespace
 
 PresentationSession::PresentationSession(LocalFrame* frame, const String& id, const String& url)
     : DOMWindowProperty(frame)
     , m_id(id)
     , m_url(url)
     , m_state(WebPresentationSessionState::Disconnected)
 {
 }
 
@@ skipping 34 matching lines @@
 {
     RefCountedGarbageCollectedEventTargetWithInlineData<PresentationSession>::trace(visitor);
     DOMWindowProperty::trace(visitor);
 }
 
 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()
 {
     if (m_state != WebPresentationSessionState::Connected)
         return;
     PresentationController* controller = presentationController();
     if (controller)
         controller->closeSession(m_url, m_id);
 }
@@ skipping 13 matching lines @@
 }
 
 PresentationController* PresentationSession::presentationController()
 {
     if (!frame())
         return nullptr;
     return PresentationController::from(*frame());
 }
 
 } // namespace blink