[Feature][DevTool] Add global memory usage CDP plumbing

Add the first part of the global memory query pipeline for DevTool. The commit registers Memory.getAllMemoryUsage in the Memory domain and routes both global and instance dispatch through LynxGlobalDevToolMediator.

The mediator validates the optional timeoutMs parameter, treats missing or zero timeoutMs values as the default wait policy, rejects negative values, rejects values outside the int64 and five-minute bounds, forwards accepted requests to GlobalDevToolPlatformFacade, and keeps CDP envelope construction in one place.

Introduce a move-only MemoryUsageCallback for the facade and embedder hook because the platform completion is request-scoped and consumed once. GlobalDevToolPlatformFacade now provides a default unsupported response for source compatibility with out-of-tree facade implementations, while Android, Darwin, and generic embedder fallbacks return an empty JSON result object together with an explicit unsupported-bridge error.

Add focused InspectorMemoryAgent coverage for successful platform results, invalid params, invalid timeoutMs values, default timeout normalization, negative timeout rejection, oversized timeout rejection, uint64 overflow rejection, platform error forwarding, malformed platform JSON, and unknown Memory methods. Move the test facade GetInstance implementation into the mock .cc file so the non-inline singleton override is defined once across DevTool test translation units. The Memory-agent tests use a test-local condition-variable backed MessageSender and explicitly initialize the UIThread runner before constructing the global mediator, so task-runner message delivery cannot race with assertions, time out on delivered messages with empty payloads, or block waiting for UIThread initialization without changing shared DevTool test mocks.

AutoSubmit: true

Author: DragonDragonDDD

devtool/embedder/core/global_devtool_platform_embedder.cc

@@ -4,6 +4,8 @@
 
 #include "devtool/embedder/core/global_devtool_platform_embedder.h"
 
+#include <utility>
+
 #if ENABLE_TRACE_PERFETTO || ENABLE_TRACE_SYSTRACE
 #include "base/trace/native/trace_controller.h"
 #endif
@@ -23,6 +25,13 @@ class GlobalDevtoolPlatformCommon
     GlobalDevtoolPlatformEmbedder::StopMemoryTracing();
   }
 
+  void GetAllMemoryUsage(
+      int64_t timeout_ms,
+      GlobalDevToolPlatformFacade::MemoryUsageCallback callback) override {
+    GlobalDevtoolPlatformEmbedder::GetAllMemoryUsage(timeout_ms,
+                                                     std::move(callback));
+  }
+
   lynx::trace::TraceController* GetTraceController() override {
 #if ENABLE_TRACE_PERFETTO || ENABLE_TRACE_SYSTRACE
     return lynx::trace::GetTraceControllerInstance();
@@ -50,6 +59,23 @@ void GlobalDevtoolPlatformEmbedder::StartMemoryTracing() {}
 
 void GlobalDevtoolPlatformEmbedder::StopMemoryTracing() {}
 
+void GlobalDevtoolPlatformEmbedder::GetAllMemoryUsage(
+    int64_t timeout_ms,
+    base::MoveOnlyClosure<void, const std::string&, const std::string&>
+        callback) {
+  (void)timeout_ms;
+  // The generic embedder has no host-specific memory bridge. Keep the CDP
+  // plumbing honest by returning an explicit error until embedders provide
+  // their own memory counters through this static hook.
+  constexpr char kBridgeUnavailable[] =
+      "Memory.getAllMemoryUsage is not available in this Lynx runtime. "
+      "Upgrade the Lynx runtime and DevTool platform integration to a version "
+      "with the global memory bridge.";
+  if (callback) {
+    std::move(callback)("{}", kBridgeUnavailable);
+  }
+}
+
 GlobalDevToolPlatformFacade& GlobalDevToolPlatformFacade::GetInstance() {
   static GlobalDevtoolPlatformCommon instance;
   return instance;

devtool/embedder/core/global_devtool_platform_embedder.h

@@ -5,9 +5,12 @@
 #ifndef DEVTOOL_EMBEDDER_CORE_GLOBAL_DEVTOOL_PLATFORM_EMBEDDER_H_
 #define DEVTOOL_EMBEDDER_CORE_GLOBAL_DEVTOOL_PLATFORM_EMBEDDER_H_
 
+#include <cstdint>
 #include <memory>
 #include <string>
 
+#include "base/include/closure.h"
+
 namespace lynx {
 namespace devtool {
 
@@ -19,6 +22,10 @@ class GlobalDevtoolPlatformEmbedder
 
   static void StartMemoryTracing();
   static void StopMemoryTracing();
+  static void GetAllMemoryUsage(
+      int64_t timeout_ms,
+      base::MoveOnlyClosure<void, const std::string&, const std::string&>
+          callback);
 };
 
 }  // namespace devtool

devtool/lynx_devtool/agent/android/global_devtool_platform_android.cc

@@ -6,6 +6,8 @@
 
 #include <sys/system_properties.h>
 
+#include <utility>
+
 #include "core/base/android/jni_helper.h"
 #include "devtool/lynx_devtool/agent/lynx_global_devtool_mediator.h"
 #include "platform/android/lynx_devtool/src/main/jni/gen/GlobalDevToolPlatformAndroidDelegate_jni.h"
@@ -26,6 +28,11 @@ bool RegisterJNIForGlobalDevToolPlatformAndroidDelegate(JNIEnv* env) {
 namespace lynx {
 namespace devtool {
 
+constexpr char kAndroidMemoryUsageBridgeUnavailable[] =
+    "Memory.getAllMemoryUsage is not available in this Android Lynx runtime. "
+    "Upgrade the Lynx runtime and DevTool platform integration to a version "
+    "with the global memory bridge.";
+
 GlobalDevToolPlatformFacade& GlobalDevToolPlatformFacade::GetInstance() {
   static base::NoDestructor<GlobalDevToolPlatformAndroid> instance;
   return *(instance.get());
@@ -41,6 +48,18 @@ void GlobalDevToolPlatformAndroid::StopMemoryTracing() {
   Java_GlobalDevToolPlatformAndroidDelegate_stopMemoryTracing(env);
 }
 
+void GlobalDevToolPlatformAndroid::GetAllMemoryUsage(
+    int64_t timeout_ms, MemoryUsageCallback callback) {
+  (void)timeout_ms;
+  // This CDP method needs the Android-side memory bridge that lands in the
+  // platform integration. Reaching this fallback means the current runtime only
+  // contains the global CDP plumbing, so clients should upgrade the Lynx
+  // runtime and DevTool platform integration to a version with that bridge.
+  if (callback) {
+    std::move(callback)("{}", kAndroidMemoryUsageBridgeUnavailable);
+  }
+}
+
 #if ENABLE_TRACE_PERFETTO || ENABLE_TRACE_SYSTRACE
 lynx::trace::TraceController*
 GlobalDevToolPlatformAndroid::GetTraceController() {

devtool/lynx_devtool/agent/android/global_devtool_platform_android.h

@@ -7,6 +7,8 @@
 
 #include <jni.h>
 
+#include <cstdint>
+
 #include "base/include/no_destructor.h"
 #include "base/include/platform/android/scoped_java_ref.h"
 #include "devtool/lynx_devtool/agent/global_devtool_platform_facade.h"
@@ -17,6 +19,8 @@ class GlobalDevToolPlatformAndroid : public GlobalDevToolPlatformFacade {
  public:
   void StartMemoryTracing() override;
   void StopMemoryTracing() override;
+  void GetAllMemoryUsage(int64_t timeout_ms,
+                         MemoryUsageCallback callback) override;
 
 #if ENABLE_TRACE_PERFETTO || ENABLE_TRACE_SYSTRACE
   // The following functions are used for tracing agent.

devtool/lynx_devtool/agent/domain_agent/inspector_memory_agent.cc

@@ -12,6 +12,8 @@ namespace devtool {
 InspectorMemoryAgent::InspectorMemoryAgent() {
   functions_map_["Memory.startTracing"] = &InspectorMemoryAgent::StartTracing;
   functions_map_["Memory.stopTracing"] = &InspectorMemoryAgent::StopTracing;
+  functions_map_["Memory.getAllMemoryUsage"] =
+      &InspectorMemoryAgent::GetAllMemoryUsage;
 }
 
 InspectorMemoryAgent::~InspectorMemoryAgent() = default;
@@ -26,6 +28,12 @@ void InspectorMemoryAgent::StopTracing(
   LynxGlobalDevToolMediator::GetInstance().MemoryStopTracing(sender, message);
 }
 
+void InspectorMemoryAgent::GetAllMemoryUsage(
+    const std::shared_ptr<MessageSender>& sender, const Json::Value& message) {
+  LynxGlobalDevToolMediator::GetInstance().MemoryGetAllMemoryUsage(sender,
+                                                                   message);
+}
+
 void InspectorMemoryAgent::CallMethod(
     const std::shared_ptr<MessageSender>& sender, const Json::Value& content) {
   std::string method = content["method"].asString();

devtool/lynx_devtool/agent/domain_agent/inspector_memory_agent.h

@@ -25,6 +25,8 @@ class InspectorMemoryAgent : public CDPDomainAgentBase {
                     const Json::Value& message);
   void StopTracing(const std::shared_ptr<MessageSender>& sender,
                    const Json::Value& message);
+  void GetAllMemoryUsage(const std::shared_ptr<MessageSender>& sender,
+                         const Json::Value& message);
 
   std::map<std::string, MemoryAgentMethod> functions_map_;
 };