[Android] WebCL support for Crosswalk.

WebCL 1.0 defines a JavaScript binding to the Khronos OpenCL standard
for heterogeneous parallel computing. Its spec is available at:
http://www.khronos.org/registry/webcl/specs/latest/1.0/

This patch includes WebCL basic APIs support, dynamic loading mechanism
etc. WebCL support is controlled by "ENABLE_WEBCL" flag, and it's enabled
by default on Android. If you want to disable with WebCL,
please add "-Denable_webcl=0" when running the "xwalk/gyp_xwalk" before building.
And run conformance test(src/third_party/webcl/src/) in the XWalkCoreShell.

Currently, Intel CPU/GPU, Qualcomm CPU/GPU and Power VR GPU are supported.
But OpenCL library isn't always shipped with device by default, even it supports OpenCL.
For example: Google Nexus series. It requires to install OpenCL library manually.

TEST=WebCL conformances test on Asus MemoPad and Xiaomi3.

Known issue:
1. miss oilpan support.
2. miss cl_khr_gl_sharing extension support.
3. load library in render process.

[email protected], [email protected], [email protected]

BUG=XWALK-2550

Author: junmin-zhu

Source/bindings/core/v8/ExceptionState.cpp

@@ -65,6 +65,17 @@ void ExceptionState::throwDOMException(const ExceptionCode& ec, const String& me
     setException(V8ThrowException::createDOMException(m_isolate, ec, processedMessage, m_creationContext));
 }
 
+void ExceptionState::throwWebCLException(const ExceptionCode& ec, const String& message)
+{
+    ASSERT(ec);
+    ASSERT(m_isolate);
+
+    m_code = ec;
+    m_message = message;
+    String finalMessage = addExceptionContext("WEBCL_IMPL_" + message);
+    setException(V8ThrowException::createWebCLException(ec, message, finalMessage, m_creationContext, m_isolate));
+}
+
 void ExceptionState::throwSecurityError(const String& sanitizedMessage, const String& unsanitizedMessage)
 {
     ASSERT(m_isolate);

Source/bindings/core/v8/ExceptionState.h

@@ -78,6 +78,7 @@ class ExceptionState {
         , m_isolate(isolate) { ASSERT(m_context == ConstructionContext || m_context == EnumerationContext || m_context == IndexedSetterContext || m_context == IndexedGetterContext || m_context == IndexedDeletionContext); }
 
     virtual void throwDOMException(const ExceptionCode&, const String& message);
+    virtual void throwWebCLException(const ExceptionCode&, const String& message);
     virtual void throwTypeError(const String& message);
     virtual void throwSecurityError(const String& sanitizedMessage, const String& unsanitizedMessage = String());
     virtual void throwRangeError(const String& message);

Source/bindings/core/v8/V8ThrowException.cpp

@@ -27,8 +27,10 @@
 
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8DOMException.h"
+#include "bindings/modules/v8/V8WebCLException.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/ExceptionCode.h"
+#include "modules/webcl/WebCLException.h"
 
 namespace blink {
 
@@ -150,4 +152,20 @@ v8::Handle<v8::Value> V8ThrowException::throwException(v8::Handle<v8::Value> exc
     return v8::Undefined(isolate);
 }
 
+v8::Handle<v8::Value> V8ThrowException::createWebCLException(int ec, const String& name, const String& message, const v8::Handle<v8::Object>& creationContext, v8::Isolate* isolate)
+{
+    if (ec <= 0 || v8::V8::IsExecutionTerminating())
+        return v8Undefined();
+
+    if (ec == V8TypeError)
+        return V8ThrowException::createTypeError(isolate, message);
+
+    RefPtr<WebCLException> webclException = WebCLException::create(ec, name, message);
+    v8::Handle<v8::Value> exception = toV8(webclException, creationContext, isolate);
+
+    if (exception.IsEmpty())
+        return v8Undefined();
+
+    return exception;
+}
 } // namespace blink

Source/bindings/core/v8/V8ThrowException.h

@@ -57,6 +57,7 @@ class V8ThrowException {
     static v8::Handle<v8::Value> throwSyntaxError(v8::Isolate*, const String&);
     static v8::Handle<v8::Value> createReferenceError(v8::Isolate*, const String&);
     static v8::Handle<v8::Value> throwReferenceError(v8::Isolate*, const String&);
+    static v8::Handle<v8::Value> createWebCLException(int, const String&, const String&, const v8::Handle<v8::Object>&, v8::Isolate*);
 };
 
 } // namespace blink

Source/bindings/modules/v8/custom/V8WebCLCommandQueueCustom.cpp

@@ -0,0 +1,48 @@
+// Copyright (C) 2015 Intel Corporation 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"
+
+#if ENABLE(WEBCL)
+
+#include "bindings/modules/v8/V8WebCLCallback.h"
+#include "bindings/modules/v8/V8WebCLDevice.h"
+#include "bindings/modules/v8/V8WebCLProgram.h"
+
+namespace blink {
+
+void V8WebCLProgram::buildMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    ExceptionState es(ExceptionState::ExecutionContext, "build", "WebCLProgram", info.Holder(), info.GetIsolate());
+    WebCLProgram* impl = V8WebCLProgram::toImpl(info.Holder());
+    Vector<RefPtr<WebCLDevice>> devices;
+    V8StringResource<TreatNullAndUndefinedAsNullString> options;
+    WebCLCallback* whenFinished = nullptr;
+    {
+        if (info.Length() > 0 && !isUndefinedOrNull(info[0]))
+            TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(devices, (toRefPtrNativeArray<WebCLDevice, V8WebCLDevice>(info[0], 1, info.GetIsolate(), es)), es);
+
+        TOSTRING_VOID_INTERNAL(options, info[1]);
+        if (!isUndefinedOrNull(info[2])) {
+            if (!info[2]->IsFunction()) {
+                es.throwTypeError("The callback provided as parameter 3 is not a function.");
+                es.throwIfNeeded();
+                return;
+            }
+
+            whenFinished = V8WebCLCallback::create(v8::Handle<v8::Function>::Cast(info[2]), ScriptState::current(info.GetIsolate()));
+        }
+    }
+
+    if (!devices.isEmpty())
+        impl->build(devices, options, whenFinished, es);
+    else
+        impl->build(options, whenFinished, es);
+
+    if (es.hadException())
+        es.throwIfNeeded();
+}
+
+}
+#endif // ENABLE(WEBCL)

Source/bindings/modules/v8/custom/V8WebCLProgramCustom.cpp

@@ -15,6 +15,8 @@
             'V8SQLResultSetRowListCustom.cpp',
             'V8SQLTransactionCustom.cpp',
             'V8ServiceWorkerCustom.cpp',
+            'V8WebCLCommandQueueCustom.cpp',
+            'V8WebCLProgramCustom.cpp',
         ],
     },
 }

Source/bindings/modules/v8/custom/custom.gypi

@@ -214,6 +214,22 @@
       'webmidi/MIDISuccessCallback.idl',
       'websockets/CloseEvent.idl',
       'websockets/WebSocket.idl',
+      'webcl/WebCL.idl',
+      'webcl/WebCLBuffer.idl',
+      'webcl/WebCLCallback.idl',
+      'webcl/WebCLCommandQueue.idl',
+      'webcl/WebCLContext.idl',
+      'webcl/WebCLDevice.idl',
+      'webcl/WebCLException.idl',
+      'webcl/WebCLEvent.idl',
+      'webcl/WebCLImage.idl',
+      'webcl/WebCLKernel.idl',
+      'webcl/WebCLKernelArgInfo.idl',
+      'webcl/WebCLMemoryObject.idl',
+      'webcl/WebCLPlatform.idl',
+      'webcl/WebCLProgram.idl',
+      'webcl/WebCLSampler.idl',
+      'webcl/WebCLUserEvent.idl'
     ],
     # 'partial interface' or target (right side of) 'implements'
     'modules_dependency_idl_files': [
@@ -269,6 +285,7 @@
       'speech/WindowSpeechSynthesis.idl',
       'vibration/NavigatorVibration.idl',
       'webaudio/WindowWebAudio.idl',
+      'webcl/WindowWebCL.idl',
       'webdatabase/WindowWebDatabase.idl',
       'webmidi/NavigatorWebMIDI.idl',
     ],
@@ -331,6 +348,7 @@
       'serviceworkers/RegistrationOptions.idl',
       'speech/SpeechRecognitionErrorInit.idl',
       'speech/SpeechRecognitionEventInit.idl',
+      'webcl/WebCLImageDescriptor.idl',
       'webmidi/MIDIConnectionEventInit.idl',
       'webmidi/MIDIMessageEventInit.idl',
       'webmidi/MIDIOptions.idl',
@@ -410,6 +428,8 @@
       '<(blink_modules_output_dir)/webmidi/MIDIMessageEventInit.cpp',
       '<(blink_modules_output_dir)/webmidi/MIDIOptions.cpp',
       '<(blink_modules_output_dir)/webmidi/MIDIOptions.h',
+      '<(blink_modules_output_dir)/webcl/WebCLImageDescriptor.cpp',
+      '<(blink_modules_output_dir)/webcl/WebCLImageDescriptor.h',
       '<(blink_modules_output_dir)/websockets/CloseEventInit.cpp',
       '<(blink_modules_output_dir)/websockets/CloseEventInit.h',
     ],
@@ -1081,6 +1101,53 @@
       'webaudio/WaveShaperNode.h',
       'webaudio/WaveShaperProcessor.cpp',
       'webaudio/WaveShaperProcessor.h',
+      'webcl/DOMWindowWebCL.cpp',
+      'webcl/DOMWindowWebCL.h',
+      'webcl/WebCL.cpp',
+      'webcl/WebCL.h',
+      'webcl/WebCLBuffer.cpp',
+      'webcl/WebCLBuffer.h',
+      'webcl/WebCLCallback.h',
+      'webcl/WebCLCommandQueue.cpp',
+      'webcl/WebCLCommandQueue.h',
+      'webcl/WebCLConfig.h',
+      'webcl/WebCLContext.cpp',
+      'webcl/WebCLContext.h',
+      'webcl/WebCLDevice.cpp',
+      'webcl/WebCLDevice.h',
+      'webcl/WebCLException.cpp',
+      'webcl/WebCLException.h',
+      'webcl/WebCLExtension.cpp',
+      'webcl/WebCLExtension.h',
+      'webcl/WebCLEvent.cpp',
+      'webcl/WebCLEvent.h',
+      'webcl/WebCLHTMLUtil.cpp',
+      'webcl/WebCLHTMLUtil.h',
+      'webcl/WebCLImage.cpp',
+      'webcl/WebCLImage.h',
+      'webcl/WebCLInputChecker.cpp',
+      'webcl/WebCLInputChecker.h',
+      'webcl/WebCLKernel.cpp',
+      'webcl/WebCLKernel.h',
+      'webcl/WebCLKernelArgInfo.h',
+      'webcl/WebCLKernelArgInfoProvider.cpp',
+      'webcl/WebCLKernelArgInfoProvider.h',
+      'webcl/WebCLMemoryUtil.cpp',
+      'webcl/WebCLMemoryUtil.h',
+      'webcl/WebCLMemoryObject.cpp',
+      'webcl/WebCLMemoryObject.h',
+      'webcl/WebCLObject.cpp',
+      'webcl/WebCLObject.h',
+      'webcl/WebCLOpenCL.cpp',
+      'webcl/WebCLOpenCL.h',
+      'webcl/WebCLPlatform.cpp',
+      'webcl/WebCLPlatform.h',
+      'webcl/WebCLProgram.cpp',
+      'webcl/WebCLProgram.h',
+      'webcl/WebCLSampler.cpp',
+      'webcl/WebCLSampler.h',
+      'webcl/WebCLUserEvent.cpp',
+      'webcl/WebCLUserEvent.h',
       'webdatabase/ChangeVersionData.h',
       'webdatabase/ChangeVersionWrapper.cpp',
       'webdatabase/ChangeVersionWrapper.h',

Source/modules/modules.gypi

@@ -0,0 +1,77 @@
+// Copyright (C) 2015 Intel Corporation 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"
+#if ENABLE(WEBCL)
+
+#include "core/dom/Document.h"
+#include "core/frame/LocalDOMWindow.h"
+#include "core/page/Page.h"
+#include "DOMWindowWebCL.h"
+#include "modules/webcl/WebCL.h"
+
+namespace blink {
+
+DOMWindowWebCL::DOMWindowWebCL(LocalDOMWindow& window)
+    : DOMWindowProperty(window.frame())
+    , m_window(window)
+{
+}
+
+DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(DOMWindowWebCL);
+
+void DOMWindowWebCL::trace(Visitor* visitor)
+{
+    visitor->trace(m_webcl);
+    WillBeHeapSupplement<LocalDOMWindow>::trace(visitor);
+    DOMWindowProperty::trace(visitor);
+}
+
+DOMWindowWebCL& DOMWindowWebCL::from(LocalDOMWindow& window)
+{
+    DOMWindowWebCL* supplement = static_cast<DOMWindowWebCL*>(WillBeHeapSupplement<LocalDOMWindow>::from(window, supplementName()));
+    if (!supplement) {
+        supplement = new DOMWindowWebCL(window);
+        provideTo(window, supplementName(), adoptPtrWillBeNoop(supplement));
+    }
+
+    return *supplement;
+}
+
+void DOMWindowWebCL::willDestroyGlobalObjectInFrame()
+{
+    m_webcl = nullptr;
+    DOMWindowProperty::willDestroyGlobalObjectInFrame();
+}
+
+void DOMWindowWebCL::willDetachGlobalObjectFromFrame()
+{
+    m_webcl = nullptr;
+    DOMWindowProperty::willDetachGlobalObjectFromFrame();
+}
+
+WebCL* DOMWindowWebCL::webcl(DOMWindow& window)
+{
+    return from(toLocalDOMWindow(window)).webcl();
+}
+
+WebCL* DOMWindowWebCL::webcl()
+{
+    if (!m_window.document() || !m_window.document()->page())
+        return nullptr;
+
+    if (!m_webcl)
+        m_webcl = WebCL::create();
+
+    return m_webcl.get();
+}
+
+const char* DOMWindowWebCL::supplementName()
+{
+    return "DOMWindowWebCL";
+}
+
+} // namespace blink
+
+#endif // ENABLE(WEBCL)

Source/modules/webcl/DOMWindowWebCL.cpp

@@ -0,0 +1,42 @@
+// Copyright (C) 2015 Intel Corporation All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef DOMWindowWebCL_h
+#define DOMWindowWebCL_h
+
+#if ENABLE(WEBCL)
+#include "core/frame/DOMWindowProperty.h"
+#include "platform/Supplementable.h"
+
+namespace blink {
+
+class LocalDOMWindow;
+class WebCL;
+
+class DOMWindowWebCL : public NoBaseWillBeGarbageCollected<DOMWindowWebCL>, public WillBeHeapSupplement<LocalDOMWindow>, public DOMWindowProperty {
+    WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(DOMWindowWebCL);
+    DECLARE_EMPTY_VIRTUAL_DESTRUCTOR_WILL_BE_REMOVED(DOMWindowWebCL);
+public:
+    static DOMWindowWebCL& from(LocalDOMWindow&);
+    static WebCL* webcl(DOMWindow&);
+
+    void willDestroyGlobalObjectInFrame() override;
+    void willDetachGlobalObjectFromFrame() override;
+
+    void trace(Visitor*);
+
+private:
+    explicit DOMWindowWebCL(LocalDOMWindow&);
+
+    WebCL* webcl();
+    static const char* supplementName();
+
+    LocalDOMWindow& m_window;
+    RefPtr<WebCL> m_webcl;
+};
+
+} // namespace blink
+
+#endif // ENABLE(WEBCL)
+#endif // DOMWindowWebCL_h