Merge remote-tracking branch 'origin/main' into feat/js_debugger_support

Author: andycall

.github/workflows/integration_test_flutter.yml

@@ -111,7 +111,7 @@ jobs:
         path: bridge/build/macos/
     - run: cd integration_tests && npm i
     - name: Run Test
-      run: cd integration_tests && SPEC_SCOPE="${{ matrix.value }}" npm run integration
+      run: cd integration_tests && CI=true SPEC_SCOPE="${{ matrix.value }}" npm run integration
       id: test
       continue-on-error: true
     - uses: actions/upload-artifact@v2
@@ -149,7 +149,7 @@ jobs:
         path: bridge/build/macos/
     - run: cd integration_tests && npm i
     - name: Run Test
-      run: cd integration_tests && SPEC_SCOPE="${{ matrix.value }}" npm run integration
+      run: cd integration_tests && CI=true SPEC_SCOPE="${{ matrix.value }}" npm run integration
       id: test
       continue-on-error: true
     - uses: actions/upload-artifact@v2

README.md

@@ -1,12 +1,12 @@
 # [WebF](https://openwebf.com/) [![pub package](https://img.shields.io/pub/v/webf.svg)](https://pub.dev/packages/webf)
 
-WebF (Web on Flutter) is a W3C standards compliant Web rendering engine based on Flutter, it can run web applications on Flutter natively.
+WebF (Web on Flutter) is a W3C standards-compliant web rendering engine based on Flutter, allowing web applications to run natively on Flutter.
 
-- **W3C Standards Compliant:** WebF use HTML/CSS and JavaScript to render contents on flutter. It can achieve 100% consistency with browser rendering.
-- **Front-End Framework Supports:** WebF is W3C standards compliant, so it can be used by many Front-End frameworks, such as [React](https://reactjs.org/), [Vue](https://vuejs.org/).
-- **Expand your Web app with Flutter:** WebF is fully customizable. You can define a customized HTML element with Flutter Widget and use it in your application. Or add a JavaScript API for any Dart library from <pub.dev> registry.
-- **Web Development Experience:** WebF supports inspecting DOM structure, CSS styles and debugging JavaScript with Chrome DevTools, just like the web development experience of your browser.
-- **Write Once, Run Anywhere:** With the power of WebF, You can write your web application and run it on any device flutter supports, and you can still run your apps in Node.js and Web browsers with the same codebase.
+- **W3C Standards Compliant:** WebF uses HTML/CSS and JavaScript to render content on Flutter, achieving 100% consistency with browser rendering.
+- **Front-End Framework Supports:** As WebF is W3C standards compliant, it can be used with many front-end frameworks, such as [React](https://reactjs.org/), [Vue](https://vuejs.org/).
+- **Expand your Web App with Flutter:** WebF is fully customizable. You can define a customized HTML element with Flutter Widgets and use it in your application or add a JavaScript API for any Dart library from <pub.dev> registry.
+- **Web Development Experience:** WebF supports inspecting DOM structure, CSS styles and debugging JavaScript with Chrome DevTools, providing a browser-like web development experience.
+- **Write Once, Run Anywhere:** With the power of WebF, You can write your web application and run it on any device that Flutter supports. Additionally, you can still run your apps in Node.js and web browsers with the same codebase.
 
 ## Check if a Web API or CSS is available in WebF
 

bridge/bindings/qjs/atomic_string.cc

@@ -295,6 +295,11 @@ inline AtomicString RemoveCharactersInternal(JSContext* ctx,
   }
 
   AtomicString str;
+
+  if (outc == 0) {
+    return AtomicString::Empty();
+  }
+
   auto data = (CharType*)js_malloc(ctx, outc);
   memcpy(data, to, outc);
   js_free(ctx, to);

bridge/core/binding_object.cc

@@ -96,7 +96,7 @@ NativeValue BindingObject::GetBindingProperty(const AtomicString& prop, Exceptio
   if (UNLIKELY(binding_object_->disposed_)) {
     exception_state.ThrowException(
         ctx(), ErrorType::InternalError,
-        "Can not get binding property on BindingObject , dart binding object had been disposed");
+        "Can not get binding property on BindingObject, dart binding object had been disposed");
     return Native_NewNull();
   }
   GetExecutingContext()->FlushUICommand();

bridge/core/dom/document.h

@@ -95,6 +95,7 @@ class Document : public ContainerNode, public TreeScope {
 
   uint32_t RequestAnimationFrame(const std::shared_ptr<FrameCallback>& callback, ExceptionState& exception_state);
   void CancelAnimationFrame(uint32_t request_id, ExceptionState& exception_state);
+  ScriptAnimationController* script_animations() { return &script_animation_controller_; };
 
   // Helper functions for forwarding LocalDOMWindow event related tasks to the
   // LocalDOMWindow if it exists.

bridge/core/dom/element.cc

@@ -364,7 +364,10 @@ void ElementSnapshotReader::HandleFailed(const char* error) {
 }
 
 ScriptPromise Element::toBlob(ExceptionState& exception_state) {
-  return toBlob(1.0, exception_state);
+  Window* window = GetExecutingContext()->window();
+  double device_pixel_ratio = NativeValueConverter<NativeTypeDouble>::FromNativeValue(
+      window->GetBindingProperty(binding_call_methods::kdevicePixelRatio, exception_state));
+  return toBlob(device_pixel_ratio, exception_state);
 }
 
 ScriptPromise Element::toBlob(double device_pixel_ratio, ExceptionState& exception_state) {

bridge/core/dom/frame_request_callback_collection.cc

@@ -39,17 +39,24 @@ void FrameCallback::Trace(GCVisitor* visitor) const {
 
 void FrameRequestCallbackCollection::RegisterFrameCallback(uint32_t callback_id,
                                                            const std::shared_ptr<FrameCallback>& frame_callback) {
-  frameCallbacks_[callback_id] = frame_callback;
+  assert(frame_callbacks_.count(callback_id) == 0);
+  frame_callbacks_[callback_id] = frame_callback;
 }
 
-void FrameRequestCallbackCollection::CancelFrameCallback(uint32_t callbackId) {
-  if (frameCallbacks_.count(callbackId) == 0)
+void FrameRequestCallbackCollection::RemoveFrameCallback(uint32_t callback_id) {
+  if (frame_callbacks_.count(callback_id) == 0)
     return;
-  frameCallbacks_.erase(callbackId);
+  frame_callbacks_.erase(callback_id);
+}
+
+std::shared_ptr<FrameCallback> FrameRequestCallbackCollection::GetFrameCallback(uint32_t callback_id) {
+  if (frame_callbacks_.count(callback_id) == 0)
+    return nullptr;
+  return frame_callbacks_[callback_id];
 }
 
 void FrameRequestCallbackCollection::Trace(GCVisitor* visitor) const {
-  for (auto& entry : frameCallbacks_) {
+  for (auto& entry : frame_callbacks_) {
     entry.second->Trace(visitor);
   }
 }

bridge/core/dom/frame_request_callback_collection.h

@@ -9,10 +9,13 @@
 
 namespace webf {
 
+class FrameRequestCallbackCollection;
+
 // |FrameCallback| is an interface type which generalizes callbacks which are
 // invoked when a script-based animation needs to be resampled.
 class FrameCallback {
  public:
+  enum FrameStatus { kPending, kExecuting, kFinished, kCanceled };
   static std::shared_ptr<FrameCallback> Create(ExecutingContext* context, const std::shared_ptr<QJSFunction>& callback);
 
   FrameCallback(ExecutingContext* context, std::shared_ptr<QJSFunction> callback);
@@ -21,22 +24,31 @@ class FrameCallback {
 
   ExecutingContext* context() { return context_; };
 
+  FrameStatus status() { return status_; }
+  void SetStatus(FrameStatus status) { status_ = status; }
+
+  uint32_t frameId() { return frame_id_; }
+  void SetFrameId(uint32_t id) { frame_id_ = id; }
+
   void Trace(GCVisitor* visitor) const;
 
  private:
   std::shared_ptr<QJSFunction> callback_;
+  FrameStatus status_;
+  uint32_t frame_id_;
   ExecutingContext* context_{nullptr};
 };
 
 class FrameRequestCallbackCollection final {
  public:
   void RegisterFrameCallback(uint32_t callback_id, const std::shared_ptr<FrameCallback>& frame_callback);
-  void CancelFrameCallback(uint32_t callback_id);
+  void RemoveFrameCallback(uint32_t callback_id);
+  std::shared_ptr<FrameCallback> GetFrameCallback(uint32_t callback_id);
 
   void Trace(GCVisitor* visitor) const;
 
  private:
-  std::unordered_map<uint32_t, std::shared_ptr<FrameCallback>> frameCallbacks_;
+  std::unordered_map<uint32_t, std::shared_ptr<FrameCallback>> frame_callbacks_;
 };
 
 }  // namespace webf

bridge/core/dom/scripted_animation_controller.cc

@@ -4,6 +4,7 @@
  */
 
 #include "scripted_animation_controller.h"
+#include "document.h"
 #include "frame_request_callback_collection.h"
 
 namespace webf {
@@ -21,8 +22,16 @@ static void handleRAFTransientCallback(void* ptr, int32_t contextId, double high
     return;
   }
 
+  assert(frame_callback->status() == FrameCallback::FrameStatus::kPending);
+
+  frame_callback->SetStatus(FrameCallback::FrameStatus::kExecuting);
+
   // Trigger callbacks.
   frame_callback->Fire(highResTimeStamp);
+
+  frame_callback->SetStatus(FrameCallback::FrameStatus::kFinished);
+
+  context->document()->script_animations()->callbackCollection()->RemoveFrameCallback(frame_callback->frameId());
 }
 
 uint32_t ScriptAnimationController::RegisterFrameCallback(const std::shared_ptr<FrameCallback>& frame_callback,
@@ -36,17 +45,19 @@ uint32_t ScriptAnimationController::RegisterFrameCallback(const std::shared_ptr<
     return -1;
   }
 
+  frame_callback->SetStatus(FrameCallback::FrameStatus::kPending);
+
   uint32_t requestId = context->dartMethodPtr()->requestAnimationFrame(frame_callback.get(), context->contextId(),
                                                                        handleRAFTransientCallback);
-
+  frame_callback->SetFrameId(requestId);
   // Register frame callback to collection.
   frame_request_callback_collection_.RegisterFrameCallback(requestId, frame_callback);
 
   return requestId;
 }
 
 void ScriptAnimationController::CancelFrameCallback(ExecutingContext* context,
-                                                    uint32_t callbackId,
+                                                    uint32_t callback_id,
                                                     ExceptionState& exception_state) {
   if (context->dartMethodPtr()->cancelAnimationFrame == nullptr) {
     exception_state.ThrowException(
@@ -55,8 +66,15 @@ void ScriptAnimationController::CancelFrameCallback(ExecutingContext* context,
     return;
   }
 
-  context->dartMethodPtr()->cancelAnimationFrame(context->contextId(), callbackId);
-  frame_request_callback_collection_.CancelFrameCallback(callbackId);
+  context->dartMethodPtr()->cancelAnimationFrame(context->contextId(), callback_id);
+
+  auto frame_callback = frame_request_callback_collection_.GetFrameCallback(callback_id);
+  if (frame_callback != nullptr) {
+    if (frame_callback->status() != FrameCallback::FrameStatus::kExecuting) {
+      frame_request_callback_collection_.RemoveFrameCallback(callback_id);
+    }
+    frame_callback->SetStatus(FrameCallback::kCanceled);
+  }
 }
 
 void ScriptAnimationController::Trace(GCVisitor* visitor) const {

bridge/core/dom/scripted_animation_controller.h

@@ -15,7 +15,9 @@ class ScriptAnimationController {
  public:
   // Animation frame callbacks are used for requestAnimationFrame().
   uint32_t RegisterFrameCallback(const std::shared_ptr<FrameCallback>& callback, ExceptionState& exception_state);
-  void CancelFrameCallback(ExecutingContext* context, uint32_t callbackId, ExceptionState& exception_state);
+  void CancelFrameCallback(ExecutingContext* context, uint32_t callback_id, ExceptionState& exception_state);
+
+  FrameRequestCallbackCollection* callbackCollection() { return &frame_request_callback_collection_; };
 
   void Trace(GCVisitor* visitor) const;