Add a shared memory variant of CefProcessMessage (fixes issue #3126)

CefSharedProcessMessageBuilder supports creation of a CefProcessMessage backed by a CefSharedMemoryRegion. Performance tests comparing the existing ArgumentList approach and the new SharedMemoryRegion approach have been added to cefclient at http://tests/ipc_performance. CefMessageRouter has been updated to use SharedMemoryRegion as transport for larger message payloads. The threshold is configurable via |CefMessageRouterConfig.message_size_threshold|. To test: run `ceftests --gtest_filter=SendSharedProcessMessageTest.*:SharedProcessMessageTest.*:MessageRouterTest.Threshold*`
2025-06-05 21:39:12 +02:00 · 2022-07-04 09:49:15 +00:00
parent a931d49f3e
commit 81e892d19e
55 changed files with 4025 additions and 1132 deletions
--- a/tests/ceftests/message_router_threshold_unittest.cc
+++ b/tests/ceftests/message_router_threshold_unittest.cc
@@ -0,0 +1,222 @@
+// Copyright (c) 2022 The Chromium Embedded Framework 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 "tests/ceftests/message_router_unittest_utils.h"
+
+namespace {
+
+constexpr int kSingleQueryErrorCode = 5;
+constexpr size_t kMessageSizeThreshold = 16000;
+
+enum class TestType { SUCCESS, FAILURE };
+
+CefString GenerateResponse(size_t size, char ch) {
+  return CefString(std::string(size, ch));
+}
+
+CefString GenerateResponse(size_t size, wchar_t ch) {
+  return CefString(std::wstring(size, ch));
+}
+
+template <class CharType>
+class ThresholdTestHandler final : public SingleLoadTestHandler {
+ public:
+  ThresholdTestHandler(TestType type, size_t message_size, CharType symbol)
+      : test_type_(type),
+        message_size_(message_size),
+        message_size_str_(std::to_string(message_size)),
+        symbol_(symbol) {}
+
+  std::string GetMainHTML() override {
+    const std::string& errorCodeStr = std::to_string(kSingleQueryErrorCode);
+
+    std::string html =
+        "<html><body><script>\n"
+        // Send the query.
+        "var request_id = window." +
+        std::string(kJSQueryFunc) + "({\n request: '" + message_size_str_ +
+        "',\n persistent: false,\n"
+        "  onSuccess: function(response) {\n"
+        "      window.mrtNotify(response);\n"
+        "  },\n"
+        "  onFailure: function(error_code, error_message) {\n"
+        "    if (error_code == " +
+        errorCodeStr +
+        ")\n"
+        "      window.mrtNotify(error_message);\n"
+        "    else\n"
+        "      window.mrtNotify('error-onFailure');\n"
+        "  }\n"
+        "});\n</script></body></html>";
+
+    return html;
+  }
+
+  void OnNotify(CefRefPtr<CefBrowser> browser,
+                CefRefPtr<CefFrame> frame,
+                const std::string& message) override {
+    AssertMainBrowser(browser);
+    AssertMainFrame(frame);
+
+    // OnNotify only be called once.
+    EXPECT_FALSE(got_notify_);
+    got_notify_.yes();
+
+    auto expected = GenerateResponse(message_size_, symbol_);
+
+    switch (test_type_) {
+      case TestType::SUCCESS:
+        EXPECT_EQ(expected, message);
+        break;
+      case TestType::FAILURE:
+        EXPECT_EQ(expected, message);
+        break;
+      default:
+        ADD_FAILURE();
+        break;
+    }
+
+    DestroyTest();
+  }
+
+  void ExecuteCallback(size_t response_size) {
+    auto response = GenerateResponse(response_size, symbol_);
+
+    EXPECT_TRUE(callback_.get());
+    switch (test_type_) {
+      case TestType::SUCCESS:
+        callback_->Success(response);
+        break;
+      case TestType::FAILURE:
+        callback_->Failure(kSingleQueryErrorCode, response);
+        break;
+      default:
+        ADD_FAILURE();
+        break;
+    }
+    callback_ = nullptr;
+  }
+
+  bool OnQuery(CefRefPtr<CefBrowser> browser,
+               CefRefPtr<CefFrame> frame,
+               int64 query_id,
+               const CefString& request,
+               bool persistent,
+               CefRefPtr<Callback> callback) override {
+    AssertMainBrowser(browser);
+    AssertMainFrame(frame);
+    EXPECT_NE(0, query_id);
+    EXPECT_FALSE(persistent);
+    EXPECT_EQ(message_size_str_, request.ToString());
+
+    const size_t message_size =
+        static_cast<size_t>(std::stoi(request.ToString()));
+    got_on_query_.yes();
+
+    callback_ = callback;
+    ExecuteCallback(message_size);
+
+    return true;
+  }
+
+  void DestroyTest() override {
+    EXPECT_TRUE(got_notify_);
+    EXPECT_TRUE(got_on_query_);
+    EXPECT_FALSE(callback_.get());
+
+    TestHandler::DestroyTest();
+  }
+
+ private:
+  const TestType test_type_;
+  const size_t message_size_;
+  const std::string message_size_str_;
+  const CharType symbol_;
+
+  CefRefPtr<Callback> callback_;
+
+  TrackCallback got_on_query_;
+  TrackCallback got_notify_;
+};
+
+using CharTestHandler = CefRefPtr<ThresholdTestHandler<char>>;
+using WCharTestHandler = CefRefPtr<ThresholdTestHandler<wchar_t>>;
+
+}  // namespace
+
+TEST(MessageRouterTest, ThresholdMessageUnderSuccessCallback) {
+  const auto UnderThreshold = kMessageSizeThreshold - 1;
+  CharTestHandler handler =
+      new ThresholdTestHandler(TestType::SUCCESS, UnderThreshold, 'A');
+  handler->SetMessageSizeThreshold(kMessageSizeThreshold);
+
+  handler->ExecuteTest();
+
+  ReleaseAndWaitForDestructor(handler);
+}
+
+TEST(MessageRouterTest, ThresholMessageExactdSuccessCallback) {
+  CharTestHandler handler =
+      new ThresholdTestHandler(TestType::SUCCESS, kMessageSizeThreshold, 'A');
+  handler->SetMessageSizeThreshold(kMessageSizeThreshold);
+
+  handler->ExecuteTest();
+
+  ReleaseAndWaitForDestructor(handler);
+}
+
+TEST(MessageRouterTest, ThresholdMessageOverSuccessCallback) {
+  const auto OverThreshold = kMessageSizeThreshold + 1;
+  CharTestHandler handler =
+      new ThresholdTestHandler(TestType::SUCCESS, OverThreshold, 'A');
+  handler->SetMessageSizeThreshold(kMessageSizeThreshold);
+
+  handler->ExecuteTest();
+
+  ReleaseAndWaitForDestructor(handler);
+}
+
+TEST(MessageRouterTest, ThresholdMessageUnderFailureCallback) {
+  const auto UnderThreshold = kMessageSizeThreshold - 1;
+  CharTestHandler handler =
+      new ThresholdTestHandler(TestType::FAILURE, UnderThreshold, 'A');
+  handler->SetMessageSizeThreshold(kMessageSizeThreshold);
+
+  handler->ExecuteTest();
+
+  ReleaseAndWaitForDestructor(handler);
+}
+
+TEST(MessageRouterTest, ThresholMessageOverdFailureCallback) {
+  const auto OverThreshold = kMessageSizeThreshold + 1;
+  CharTestHandler handler =
+      new ThresholdTestHandler(TestType::FAILURE, OverThreshold, 'A');
+  handler->SetMessageSizeThreshold(kMessageSizeThreshold);
+
+  handler->ExecuteTest();
+
+  ReleaseAndWaitForDestructor(handler);
+}
+
+TEST(MessageRouterTest, ThresholdUtf8MessageUnderSuccessCallback) {
+  const auto UnderThreshold = kMessageSizeThreshold - 1;
+  WCharTestHandler handler =
+      new ThresholdTestHandler(TestType::SUCCESS, UnderThreshold, L'\u304B');
+  handler->SetMessageSizeThreshold(kMessageSizeThreshold);
+
+  handler->ExecuteTest();
+
+  ReleaseAndWaitForDestructor(handler);
+}
+
+TEST(MessageRouterTest, ThresholdUtf8MessageOverSuccessCallback) {
+  const auto OverThreshold = kMessageSizeThreshold + 1;
+  WCharTestHandler handler =
+      new ThresholdTestHandler(TestType::SUCCESS, OverThreshold, L'\u304B');
+  handler->SetMessageSizeThreshold(kMessageSizeThreshold);
+
+  handler->ExecuteTest();
+
+  ReleaseAndWaitForDestructor(handler);
+}