feat: Blink integration

bridge/.gitignore

@@ -6,4 +6,10 @@ out
 code_gen
 .cache
 
-bin
+bin
+
+# ignore blink soft link
+blink_source
+
+# ignore preview tools
+.preview-bundles

bridge/AGENTS.md

@@ -0,0 +1,43 @@
+# Repository Guidelines
+
+## Project Structure & Module Organization
+- `bridge/`: C++17 native bridge (JS runtime, DOM/CSS, bindings). Core code in `bridge/core/`; generated code in `bridge/code_gen/`; unit tests in `bridge/test/`; third-party deps in `bridge/third_party/`.
+- `webf/`: Dart/Flutter engine (DOM/layout/painting). Tests in `webf/test/` and `webf/integration_test/`.
+- `cli/`: TypeScript CLI/codegen helpers. Tests in `cli/test/`.
+- `integration_tests/`: E2E + snapshot runner and tooling.
+- `scripts/`: Repo-wide build/codegen utilities invoked by `npm run ...`.
+
+## Build, Test, and Development Commands
+Run from repo root (`../`) unless noted:
+- Install dependencies: `npm install`
+- Build bridge (macOS): `npm run build:bridge:macos` (other targets: `build:bridge:{android,ios,linux,windows}`)
+- Clean build artifacts: `npm run build:clean`
+- Regenerate bindings/types: `npm run bindgen` (don’t hand-edit files under `bridge/code_gen/`)
+- Bridge unit tests: `node scripts/run_bridge_unit_test.js`
+- Flutter analyze/format: `npm run lint` / `npm run format`
+- Flutter tests: `cd webf && flutter test`
+- Integration tests: `cd integration_tests && npm run integration`
+- CLI tests: `cd cli && npm test`
+
+## Coding Style & Naming Conventions
+- C++ (bridge): 2-space indent, 120 cols, Chromium style via `.clang-format`; files use `.cc`/`.h`.
+- Dart (webf): follow `webf/analysis_options.yaml`; files `snake_case.dart`, types `PascalCase`, members `camelCase`.
+- TypeScript (cli): strict TS; keep generators deterministic; Jest tests use `*.test.ts`.
+
+## Testing Guidelines
+- Bridge uses GoogleTest; keep tests small and behavior-focused, and mirror source paths under `bridge/test/`.
+- Do not create or run tests unless explicitly requested.
+- Do not modify existing tests unless explicitly instructed.
+
+## Commit & Pull Request Guidelines
+- Use Conventional Commits: `type(scope): subject` (e.g., `fix(bridge): handle null QualifiedName`).
+- PRs should include rationale, linked issues, and exact verification steps; add screenshots for UI changes in `webf_apps/`.
+- Do not commit anything unless explicitly requested.
+
+## Agent-Specific Instructions
+- Always explain why changes are needed before making them.
+- Do not build anything unless explicitly requested.
+
+## Security & Configuration Tips
+- Initialize submodules: `git submodule update --init --recursive`.
+- Common build env: `WEBF_BUILD=Release`, `ENABLE_PROFILE=true`. Platform deps include Flutter SDK + CMake/Clang (macOS) and Xcode/NDK where applicable.

bridge/CMakeLists.txt

@@ -55,6 +55,8 @@ if(CMAKE_SYSTEM_NAME MATCHES "MSYS" OR MINGW)
 
   # Define math constants that are not in standard C++
   add_compile_definitions(_USE_MATH_DEFINES)
+  # Exclude GDI from Windows.h
+  add_compile_definitions(NOGDI)
 
   if (DEFINED ENV{LIBRARY_OUTPUT_DIR})
     set(CMAKE_INSTALL_PREFIX $ENV{LIBRARY_OUTPUT_DIR})
@@ -206,6 +208,10 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR}/code_gen)
 set(BRIDGE_SOURCE_LOADED FALSE)
 set(_BRIDGE_SOURCES_JSON5 "${CMAKE_CURRENT_SOURCE_DIR}/bridge_sources.json5")
 if(EXISTS "${_BRIDGE_SOURCES_JSON5}")
+  # Ensure changes to bridge_sources.json5 trigger a CMake reconfigure so newly
+  # added source files are picked up (otherwise builds can fail at link time
+  # with unresolved symbols).
+  set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${_BRIDGE_SOURCES_JSON5}")
   execute_process(
     COMMAND node ${CMAKE_CURRENT_SOURCE_DIR}/scripts/read_bridge_sources.js ${_BRIDGE_SOURCES_JSON5}
     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
@@ -445,3 +451,70 @@ if (${CMAKE_SYSTEM_NAME} MATCHES "iOS")
     )
   endif()
 endif ()
+
+
+#############################
+# Logging options
+#############################
+
+# Helper to allow env var defaults while preserving -D cache overrides
+function(_webf_option_with_env VAR DESC DEFAULT)
+  set(_default ${DEFAULT})
+  if(DEFINED ENV{${VAR}})
+    string(TOUPPER "$ENV{${VAR}}" _env_val)
+    if(_env_val STREQUAL "1" OR _env_val STREQUAL "ON" OR _env_val STREQUAL "TRUE" OR _env_val STREQUAL "YES")
+      set(_default ON)
+    elseif(_env_val STREQUAL "0" OR _env_val STREQUAL "OFF" OR _env_val STREQUAL "FALSE" OR _env_val STREQUAL "NO")
+      set(_default OFF)
+    else()
+      message(WARNING "Ignoring invalid value for ${VAR} environment variable: '$ENV{${VAR}}'. Expected ON/OFF/1/0/TRUE/FALSE/YES/NO.")
+    endif()
+  endif()
+  option(${VAR} "${DESC}" ${_default})
+endfunction()
+
+# Master switch to quickly enable all log categories
+_webf_option_with_env(WEBF_LOG_ALL "Enable all WebF category logs" OFF)
+
+# Per-category logging switches
+_webf_option_with_env(WEBF_LOG_PARSER "Enable Parser logs" OFF)
+_webf_option_with_env(WEBF_LOG_STYLEENGINE "Enable StyleEngine logs" OFF)
+_webf_option_with_env(WEBF_LOG_CASCADE "Enable Cascade logs" OFF)
+_webf_option_with_env(WEBF_LOG_COLLECTOR "Enable Collector logs" OFF)
+_webf_option_with_env(WEBF_LOG_STYLESHEET "Enable Stylesheet logs" OFF)
+_webf_option_with_env(WEBF_LOG_SELECTOR "Enable Selector logs" OFF)
+_webf_option_with_env(WEBF_LOG_ATTR "Enable Attr logs" OFF)
+_webf_option_with_env(WEBF_LOG_COMMAND "Enable Command logs" OFF)
+
+macro(_webf_define_log VAR)
+  if (WEBF_LOG_ALL OR ${VAR})
+    add_compile_definitions(${VAR}=1)
+    list(APPEND _WEBF_ENABLED_LOGS ${VAR})
+  endif()
+endmacro()
+
+set(_WEBF_ENABLED_LOGS)
+_webf_define_log(WEBF_LOG_PARSER)
+_webf_define_log(WEBF_LOG_STYLEENGINE)
+_webf_define_log(WEBF_LOG_CASCADE)
+_webf_define_log(WEBF_LOG_COLLECTOR)
+_webf_define_log(WEBF_LOG_STYLESHEET)
+_webf_define_log(WEBF_LOG_SELECTOR)
+_webf_define_log(WEBF_LOG_ATTR)
+_webf_define_log(WEBF_LOG_COMMAND)
+
+if (_WEBF_ENABLED_LOGS)
+  list(JOIN _WEBF_ENABLED_LOGS ", " _WEBF_ENABLED_LOGS_STR)
+  message(STATUS "WebF logging enabled for: ${_WEBF_ENABLED_LOGS_STR}")
+  # Ensure targets built in this directory also receive the definitions
+  foreach(_log ${_WEBF_ENABLED_LOGS})
+    if (TARGET webf_core)
+      target_compile_definitions(webf_core PUBLIC ${_log}=1)
+    endif()
+    if (TARGET webf)
+      target_compile_definitions(webf PUBLIC ${_log}=1)
+    endif()
+  endforeach()
+else()
+  message(STATUS "WebF logging: no categories enabled (define WEBF_LOG_* or set WEBF_LOG_ALL)")
+endif()

bridge/bindings/qjs/atomic_string_test.cc

@@ -9,6 +9,7 @@
 
 #include <quickjs/quickjs.h>
 #include <codecvt>
+#include <iterator>
 #include "event_type_names.h"
 #include "gtest/gtest.h"
 #include "native_string_utils.h"
@@ -197,6 +198,27 @@ TEST(AtomicString, MixedUTF8AndUTF16) {
   EXPECT_EQ(str2, "Hello 世界");
 }
 
+TEST(AtomicString, ConstructFromStringView) {
+  TEST_init();
+
+  String ascii = String::FromUTF8("string-view");
+  StringView ascii_view(ascii);
+  AtomicString from_ascii(ascii_view);
+  EXPECT_TRUE(from_ascii.Is8Bit());
+  EXPECT_EQ(from_ascii.ToUTF8String(), "string-view");
+
+  const char16_t wide_chars[] = u"Bảo hiểm";
+  String wide(wide_chars, std::size(wide_chars) - 1);
+  StringView wide_view(wide);
+  AtomicString from_wide(wide_view);
+  EXPECT_FALSE(from_wide.Is8Bit());
+  EXPECT_EQ(from_wide.ToUTF8String(), "Bảo hiểm");
+
+  StringView null_view;
+  AtomicString from_null(null_view);
+  EXPECT_TRUE(from_null.IsNull());
+}
+
 TEST(AtomicString, UTF16WithSurrogatePairs) {
   TEST_init();
 
@@ -328,3 +350,25 @@ TEST(StringImpl, CreateFromUTF8Empty) {
   EXPECT_TRUE(str2->length() == 0);
   EXPECT_EQ(str1, str2); // Should return the same empty string singleton
 }
+
+// Adding for hash collision reference
+// TEST(StringImpl, HashCollision1) {
+//   TEST_init();
+//
+//   // Test hash collision
+//   auto str1 = StringImpl::CreateFromUTF8(R"#(
+//       * {
+//         padding: 0;
+//         margin: 0;
+//       }
+//       .q {
+//         margin: 10px;
+//         padding: 10px;
+//         flex: 1 1 auto;
+//         background: gold;
+//       }
+//     )#");
+//   auto str2 = StringImpl::CreateFromUTF8("screen_async");
+//
+//   EXPECT_EQ(str1->GetHash(), str2->GetHash());
+// }

bridge/bindings/qjs/converter_impl.h

@@ -302,7 +302,14 @@ struct Converter<IDLSequence<T>> : public ConverterBase<IDLSequence<T>> {
     }
 
     ImplType v;
-    uint32_t length = Converter<IDLUint32>::FromValue(ctx, JS_GetPropertyStr(ctx, value, "length"), exception_state);
+    JSValue length_value = JS_GetPropertyStr(ctx, value, "length");
+    if (JS_IsException(length_value)) {
+      exception_state.ThrowException(ctx, length_value);
+      JS_FreeValue(ctx, length_value);
+      return {};
+    }
+    uint32_t length = Converter<IDLUint32>::FromValue(ctx, length_value, exception_state);
+    JS_FreeValue(ctx, length_value);
 
     v.reserve(length);
 
@@ -430,12 +437,19 @@ struct Converter<JSEventListener> : public ConverterBase<JSEventListener> {
     if (JS_IsObject(value) && !JS_IsFunction(ctx, value)) {
       JSValue handleEventMethod = JS_GetPropertyStr(ctx, value, "handleEvent");
 
+      if (JS_IsException(handleEventMethod)) {
+        exception_state.ThrowException(ctx, handleEventMethod);
+        JS_FreeValue(ctx, handleEventMethod);
+        return JSEventListener::CreateOrNull(nullptr);
+      }
+
       if (JS_IsFunction(ctx, handleEventMethod)) {
         auto result = JSEventListener::CreateOrNull(QJSFunction::Create(ctx, handleEventMethod, value));
         JS_FreeValue(ctx, handleEventMethod);
         return result;
       }
 
+      JS_FreeValue(ctx, handleEventMethod);
       return JSEventListener::CreateOrNull(nullptr);
     }
     return JSEventListener::CreateOrNull(QJSFunction::Create(ctx, value));

bridge/bindings/qjs/heap_vector.h

@@ -9,6 +9,14 @@
 #ifndef BRIDGE_BINDINGS_QJS_HEAP_VECTOR_H_
 #define BRIDGE_BINDINGS_QJS_HEAP_VECTOR_H_
 
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <iostream>
+#include <vector>
+
+#include "bindings/qjs/cppgc/gc_visitor.h"
+
 namespace webf {
 
 template <typename V>

bridge/bindings/qjs/native_string_utils.cc

@@ -9,6 +9,11 @@
 
 #include "native_string_utils.h"
 
+#include <cstring>
+
+#include "foundation/dart_readable.h"
+#include "foundation/string/wtf_string.h"
+
 namespace webf {
 
 std::unique_ptr<SharedNativeString> jsValueToNativeString(JSContext* ctx, JSValue value) {
@@ -44,6 +49,26 @@ std::unique_ptr<SharedNativeString> stringToNativeString(const std::string& stri
   return SharedNativeString::FromTemporaryString(tmp.string(), tmp.length());
 }
 
+std::unique_ptr<SharedNativeString> stringToNativeString(const String& string) {
+  uint32_t length = string.length();
+  if (length == 0) {
+    return std::make_unique<SharedNativeString>(nullptr, 0);
+  }
+
+  auto* buffer = static_cast<uint16_t*>(dart_malloc(sizeof(uint16_t) * length));
+  if (string.Is8Bit()) {
+    const LChar* p = string.Characters8();
+    for (uint32_t i = 0; i < length; ++i) {
+      buffer[i] = static_cast<uint16_t>(p[i]);
+    }
+  } else {
+    const UChar* p = string.Characters16();
+    std::memcpy(buffer, p, sizeof(uint16_t) * length);
+  }
+
+  return std::make_unique<SharedNativeString>(buffer, length);
+}
+
 std::string nativeStringToStdString(const SharedNativeString* native_string) {
   std::u16string u16EventType =
       std::u16string(reinterpret_cast<const char16_t*>(native_string->string()), native_string->length());

bridge/bindings/qjs/native_string_utils.h

@@ -19,12 +19,19 @@
 
 namespace webf {
 
+class String;
+
 // Convert to string and return a full copy of NativeString from JSValue.
 std::unique_ptr<SharedNativeString> jsValueToNativeString(JSContext* ctx, JSValue value);
 
 // Encode utf-8 to utf-16, and return a full copy of NativeString.
 std::unique_ptr<SharedNativeString> stringToNativeString(const std::string& string);
 
+// Copies a WebF String to a NativeString (UTF-16) without interning.
+// Prefer this over AtomicString(value).ToNativeString() for transient values
+// (e.g. style values) to avoid growing the AtomicString table.
+std::unique_ptr<SharedNativeString> stringToNativeString(const String& string);
+
 std::string nativeStringToStdString(const SharedNativeString* native_string);
 
 template <typename T>

bridge/bindings/qjs/script_value.cc

@@ -182,9 +182,9 @@ ScriptValue::ScriptValue(const ScriptValue& value) {
 ScriptValue& ScriptValue::operator=(const ScriptValue& value) {
   if (&value != this) {
     JS_FreeValueRT(runtime_, value_);
+    runtime_ = value.runtime_;
     value_ = JS_DupValueRT(runtime_, value.value_);
   }
-  runtime_ = value.runtime_;
   return *this;
 }
 

bridge/bridge_sources.json5

@@ -1,5 +1,6 @@
 {
   BRIDGE_SOURCE: [
+    "foundation/metrics_registry.cc",
     "foundation/logging.cc",
     "foundation/ios_logger.mm",
     "foundation/native_string.cc",
@@ -119,10 +120,23 @@
     "core/base/strings/utf_string_conversion_utils.cc",
     "core/core_initializer.cc",
 
-    // Style
-    "core/css/style_element.cc",
-    "core/css/style_color.cc",
-    "core/css/style_engine.cc",
+	    // Style
+	    "core/css/style_element.cc",
+	    "core/css/style_color.cc",
+	    "core/css/active_style_sheets.cc",
+	    "core/css/style_engine.cc",
+	    "core/css/style_traversal_root.cc",
+	    "core/css/style_invalidation_root.cc",
+	    "core/css/style_recalc_root.cc",
+    "core/css/style_recalc_context.cc",
+    "core/css/css_global_rule_set.cc",
+    "core/css/rule_feature_set.cc",
+    "core/css/invalidation/invalidation_flags.cc",
+    "core/css/invalidation/invalidation_set.cc",
+    "core/css/invalidation/pending_invalidations.cc",
+    "core/css/invalidation/rule_invalidation_data.cc",
+    "core/css/invalidation/style_invalidator.cc",
+    "core/inspector/invalidation_set_to_selector_map.cc",
 
     // Animation
     "core/animation/animation_time_delta.cc",
@@ -188,6 +202,7 @@
     "core/css/css_selector_list.cc",
     "core/css/css_value.cc",
     "core/css/media_list.cc",
+    "core/css/media_values_dynamic.cc",
     "core/css/media_values.cc",
     "core/css/style_scope.cc",
     "core/css/cascade_layer.cc",
@@ -294,6 +309,7 @@
     "core/css/css_value_pool.cc",
     "core/css/cssom_utils.cc",
     "core/css/css_string_value.cc",
+    "core/css/css_raw_value.cc",
     "core/css/css_initial_value.cc",
     "core/css/css_numeric_literal_value",
     "core/css/css_color.cc",

bridge/core/base/strings/string_number_conversions.cc

@@ -18,6 +18,7 @@
 #include "foundation/macros.h"
 
 #include "core/base/strings/string_number_conversions_internal.h"
+#include "string/string_types.h"
 
 namespace base {
 
@@ -117,7 +118,7 @@ bool StringToDouble(std::string_view input, double* output) {
   return internal::StringToDoubleImpl(input, input.data(), *output);
 }
 
-bool StringToDouble(std::u16string_view input, double* output) {
+bool StringToDouble(webf::UTF16StringView input, double* output) {
   return internal::StringToDoubleImpl(input, reinterpret_cast<const uint16_t*>(input.data()), *output);
 }