[Dart GPU] Export symbols from engine, stub for testing on CI.

Author: bdero

common/exported_symbols.sym

@@ -5,4 +5,6 @@
   kDartVmSnapshotInstructions;
   kDartIsolateSnapshotData;
   kDartIsolateSnapshotInstructions;
+  FlutterGpu*;
+  kFlutterGpu*;
 };

common/exported_symbols_mac.sym

@@ -4,3 +4,5 @@ _kDartVmSnapshotData
 _kDartVmSnapshotInstructions
 _kDartIsolateSnapshotData
 _kDartIsolateSnapshotInstructions
+_FlutterGpu*
+_kFlutterGpu*

lib/gpu/BUILD.gn

@@ -0,0 +1,51 @@
+# Copyright 2013 The Flutter Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import("//flutter/common/config.gni")
+import("//flutter/impeller/tools/impeller.gni")
+import("//flutter/testing/testing.gni")
+
+source_set("gpu") {
+  cflags = [
+    # Dart gives us doubles. Skia and Impeller work in floats.
+    # If Dart gives us a double > FLT_MAX or < -FLT_MAX, implicit conversion
+    # will convert it to either inf/-inf or FLT_MAX/-FLT_MAX (undefined
+    # behavior). This can result in surprising and difficult to debug behavior
+    # for Flutter application developers, so it should be explicitly handled
+    # via SafeNarrow.
+    "-Wimplicit-float-conversion",
+  ]
+
+  if (is_win) {
+    # This causes build failures in third_party dependencies on Windows.
+    cflags += [ "-Wno-implicit-int-float-conversion" ]
+  }
+
+  public_configs = [ "//flutter:config" ]
+
+  public_deps = []
+
+  if (!defined(defines)) {
+    defines = []
+  }
+
+  sources = [
+    "gpu.cc",
+    "gpu.h",
+  ]
+  deps = [
+    "//flutter/impeller",
+    "//flutter/impeller/display_list:skia_conversions",
+    "//flutter/lib/ui",
+    "//flutter/third_party/tonic",
+  ]
+
+  if (is_win) {
+    # Required for M_PI and others.
+    defines += [ "_USE_MATH_DEFINES" ]
+  }
+}
+
+if (enable_unittests) {
+}

lib/gpu/gpu.cc

@@ -0,0 +1,46 @@
+// Copyright 2013 The Flutter 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 "flutter/lib/gpu/gpu.h"
+#include "flutter/fml/memory/ref_ptr.h"
+#include "flutter/lib/ui/dart_wrapper.h"
+#include "flutter/lib/ui/ui_dart_state.h"
+#include "third_party/dart/runtime/include/dart_api.h"
+#include "third_party/tonic/converter/dart_converter.h"
+#include "third_party/tonic/dart_state.h"
+#include "third_party/tonic/dart_wrappable.h"
+#include "third_party/tonic/dart_wrapper_info.h"
+#include "third_party/tonic/logging/dart_invoke.h"
+
+namespace flutter {
+
+IMPLEMENT_WRAPPERTYPEINFO(gpu, FlutterGpuTestClass);
+
+}  // namespace flutter
+
+uint32_t FlutterGpuTestProc() {
+  return 1;
+}
+
+Dart_Handle FlutterGpuTestProcWithCallback(Dart_Handle callback) {
+  flutter::UIDartState::ThrowIfUIOperationsProhibited();
+  if (!Dart_IsClosure(callback)) {
+    return tonic::ToDart("Callback must be a function");
+  }
+
+  tonic::DartInvoke(callback, {tonic::ToDart(1234)});
+
+  return Dart_Null();
+}
+
+void FlutterGpuTestClass_Create(Dart_Handle wrapper) {
+  auto res = fml::MakeRefCounted<flutter::FlutterGpuTestClass>();
+  res->AssociateWithDartWrapper(wrapper);
+  FML_LOG(ERROR) << "FlutterGpuTestClass Wrapped.";
+}
+
+void FlutterGpuTestClass_Method(flutter::FlutterGpuTestClass* self,
+                                int something) {
+  FML_LOG(ERROR) << "Something: " << something;
+}

lib/gpu/gpu.dart

@@ -0,0 +1,38 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// ignore_for_file: public_member_api_docs
+
+import 'dart:ffi';
+import 'dart:nativewrappers';
+
+/// This is a simple test fuction.
+@Native<Int32 Function()>(symbol: 'FlutterGpuTestProc')
+external int testProc();
+
+/// This is a test callback that follows the same pattern as much of dart:ui --
+/// immediately returning an error string and supplying an asynchronous result
+/// via callback later.
+typedef Callback<T> = void Function(T result);
+@Native<Handle Function(Handle)>(symbol: 'FlutterGpuTestProcWithCallback')
+external String? testProcWithCallback(Callback<int> callback);
+
+/// This is a test of NativeFieldWrapperClass1, which is commonly used in
+/// dart:ui to enable Dart to dictate the lifetime of a C counterpart.
+base class FlutterGpuTestClass extends NativeFieldWrapperClass1 {
+  FlutterGpuTestClass() {
+    _constructor();
+  }
+
+  /// This "constructor" is used to instantiate and wrap the C counterpart.
+  /// This is a common pattern in dart:ui.
+  @Native<Void Function(Handle)>(symbol: 'FlutterGpuTestClass_Create')
+  external void _constructor();
+
+  /// This is a method that will supply a pointer to the C data counterpart when
+  /// calling the function
+  @Native<Void Function(Pointer<Void>, Int)>(
+      symbol: 'FlutterGpuTestClass_Method')
+  external void coolMethod(int something);
+}

lib/gpu/gpu.h

@@ -0,0 +1,49 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef FLUTTER_LIB_GPU_GPU_H_
+#define FLUTTER_LIB_GPU_GPU_H_
+
+#include <cstdint>
+
+#include "flutter/lib/ui/dart_wrapper.h"
+#include "third_party/dart/runtime/include/dart_api.h"
+#include "third_party/tonic/dart_state.h"
+#include "third_party/tonic/dart_wrapper_info.h"
+
+#if FML_OS_WIN
+#define FLUTTER_EXPORT __declspec(dllexport)
+#else  // FML_OS_WIN
+#define FLUTTER_EXPORT __attribute__((visibility("default")))
+#endif  // FML_OS_WIN
+
+namespace flutter {
+
+class FlutterGpuTestClass
+    : public RefCountedDartWrappable<FlutterGpuTestClass> {
+  DEFINE_WRAPPERTYPEINFO();
+
+ public:
+};
+
+}  // namespace flutter
+
+extern "C" {
+
+FLUTTER_EXPORT
+extern uint32_t FlutterGpuTestProc();
+
+FLUTTER_EXPORT
+extern Dart_Handle FlutterGpuTestProcWithCallback(Dart_Handle callback);
+
+FLUTTER_EXPORT
+extern void FlutterGpuTestClass_Create(Dart_Handle wrapper);
+
+FLUTTER_EXPORT
+extern void FlutterGpuTestClass_Method(flutter::FlutterGpuTestClass* self,
+                                       int something);
+
+}  // extern "C"
+
+#endif  // FLUTTER_LIB_GPU_GPU_H_

runtime/BUILD.gn

@@ -90,6 +90,7 @@ source_set("runtime") {
   }
 
   public_deps = [
+    "//flutter/lib/gpu",
     "//flutter/lib/ui",
     "//third_party/rapidjson",
   ]

shell/testing/BUILD.gn

@@ -27,6 +27,7 @@ executable("testing") {
     "//flutter/common",
     "//flutter/flow",
     "//flutter/fml",
+    "//flutter/lib/gpu",
     "//flutter/lib/snapshot",
     "//flutter/shell/common",
     "//flutter/shell/gpu:gpu_surface_software",

testing/dart/BUILD.gn

@@ -17,6 +17,7 @@ tests = [
   "fragment_shader_test.dart",
   "geometry_test.dart",
   "gesture_settings_test.dart",
+  "gpu_test.dart",
   "gradient_test.dart",
   "http_allow_http_connections_test.dart",
   "http_disallow_http_connections_test.dart",

testing/dart/gpu_test.dart

@@ -0,0 +1,25 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// ignore_for_file: avoid_relative_lib_imports
+
+import 'dart:ui';
+
+import 'package:litetest/litetest.dart';
+import '../../lib/gpu/gpu.dart' as gpu;
+
+void main() {
+  test('no crash', () async {
+    final int result = gpu.testProc();
+    expect(result, 1234);
+
+    final String? message = gpu.testProcWithCallback((int result) {
+      print('Callback called with: $result');
+    });
+    expect(message, '');
+
+    final gpu.FlutterGpuTestClass a = gpu.FlutterGpuTestClass();
+    a.coolMethod(9847);
+  });
+}