Add support for user on exit strategy.

b/385357645

cobalt/build/testing/targets/linux-x64x11/test_targets.json

@@ -4,6 +4,7 @@
     "base:base_unittests",
     "cc:cc_perftests",
     "cc:cc_unittests",
+    "cobalt/renderer:renderer_browsertests",
     "components/viz:viz_perftests",
     "components/viz:viz_unittests",
     "crypto:crypto_unittests",
@@ -60,6 +61,7 @@
     "out/linux-x64x11_devel/ozone_unittests",
     "out/linux-x64x11_devel/ppapi_perftests",
     "out/linux-x64x11_devel/ppapi_unittests",
+    "out/linux-x64x11_devel/renderer_browsertests",
     "out/linux-x64x11_devel/service_manager_unittests",
     "out/linux-x64x11_devel/skia_unittests",
     "out/linux-x64x11_devel/sql_unittests",

cobalt/configuration/BUILD.gn

@@ -0,0 +1,24 @@
+# Copyright 2025 The Cobalt Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+static_library("configuration") {
+  sources = [
+    "configuration.cc",
+    "configuration.h",
+  ]
+  deps = [
+    "//base",
+    "//starboard:starboard_headers_only",
+  ]
+}

cobalt/configuration/configuration.cc

@@ -0,0 +1,48 @@
+// Copyright 2025 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "cobalt/configuration/configuration.h"
+
+#include "base/logging.h"
+#include "base/memory/singleton.h"
+#include "starboard/system.h"
+
+namespace cobalt {
+namespace configuration {
+
+// static
+Configuration* Configuration::GetInstance() {
+  return base::Singleton<Configuration,
+                         base::LeakySingletonTraits<Configuration>>::get();
+}
+
+Configuration::Configuration() {
+  configuration_api_ = static_cast<const CobaltExtensionConfigurationApi*>(
+      SbSystemGetExtension(kCobaltExtensionConfigurationName));
+  if (!configuration_api_) {
+    return;
+  }
+  // Verify it's the extension needed.
+  if (std::string(configuration_api_->name) ==
+          kCobaltExtensionConfigurationName ||
+      configuration_api_->version < 1) {
+    LOG(WARNING) << "Not using supplied cobalt configuration extension: "
+                 << "'" << configuration_api_->name << "' ("
+                 << configuration_api_->version << ")";
+    configuration_api_ = nullptr;
+  }
+}
+
+}  // namespace configuration
+}  // namespace cobalt

cobalt/configuration/configuration.h

@@ -0,0 +1,79 @@
+// Copyright 2025 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef COBALT_CONFIGURATION_CONFIGURATION_H_
+#define COBALT_CONFIGURATION_CONFIGURATION_H_
+
+#include <string>
+
+#include "base/notreached.h"
+#include "starboard/extension/configuration.h"
+
+namespace base {
+template <typename T>
+struct DefaultSingletonTraits;
+}
+
+namespace cobalt {
+namespace configuration {
+
+enum UserOnExitStrategy {
+  kClose,
+  kMinimize,
+  kNoExit,
+  kCount,
+};
+
+// The Configuration changes certain Cobalt features as specified by the
+// platform. This class picks up values set in the
+// CobaltConfigurationExtensionApi if it is implemented by the platform and
+// will otherwise use default configurations.
+class Configuration {
+ public:
+  // The Configuration is a singleton initialized on the first call of
+  // GetInstance(). Calls to this function will return a pointer to the same
+  // instance as was previously initialized.
+  static Configuration* GetInstance();
+
+  // TODO: For Evergreen, check if exit is due to an update requiring restart.
+  //       When restart is required, the app should close.
+  constexpr UserOnExitStrategy CobaltUserOnExitStrategy() {
+    if (configuration_api_) {
+      std::string strategy = configuration_api_->CobaltUserOnExitStrategy();
+      if (strategy == "noexit") {
+        return UserOnExitStrategy::kNoExit;
+      }
+      if (strategy == "suspend") {
+        return UserOnExitStrategy::kMinimize;
+      }
+      if (strategy != "stop") {
+        NOTREACHED() << "Unknown exit strategy.";
+      }
+    }
+    return UserOnExitStrategy::kClose;
+  }
+
+ private:
+  Configuration();
+  Configuration(const Configuration&) = delete;
+  Configuration& operator=(const Configuration&) = delete;
+
+  friend struct base::DefaultSingletonTraits<Configuration>;
+  const CobaltExtensionConfigurationApi* configuration_api_;
+};
+
+}  // namespace configuration
+}  // namespace cobalt
+
+#endif  // COBALT_CONFIGURATION_CONFIGURATION_H_

cobalt/docker/linux/Dockerfile

@@ -13,6 +13,9 @@ RUN apt-get update && apt-get install -y \
     libnss3 \
     gperf \
     libdbus-1-3 \
+    libatk1.0-0 \
+    libatk-bridge2.0-0 \
+    libcairo2-dev \
     libxcomposite1 \
     libxdamage1 \
     libxext6 \

cobalt/renderer/BUILD.gn

@@ -12,13 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import("//testing/test.gni")
+
 source_set("renderer") {
   sources = [
     "cobalt_content_renderer_client.cc",
     "cobalt_content_renderer_client.h",
+    "cobalt_render_frame_observer.cc",
+    "cobalt_render_frame_observer.h",
   ]
 
   deps = [
+    "//cobalt/configuration",
     "//cobalt/media/audio:webaudio",
     "//components/cdm/renderer",
     "//components/js_injection/renderer:renderer",
@@ -27,8 +32,27 @@ source_set("renderer") {
     "//content/public/common",
     "//content/public/renderer",
     "//content/test:content_test_mojo_bindings",
+    "//gin",
     "//media/mojo:buildflags",
     "//starboard:starboard_headers_only",
     "//v8",
   ]
 }
+
+test("renderer_browsertests") {
+  sources = [ "cobalt_render_frame_observer_browsertest.cc" ]
+
+  deps = [
+    ":renderer",
+    "//cobalt/configuration",
+    "//content/public/browser",
+    "//content/shell:content_shell_lib",
+    "//content/test:browsertest_support",
+    "//content/test:test_support",
+    "//skia",
+    "//testing/gmock",
+    "//testing/gtest",
+    "//third_party/abseil-cpp:absl",
+    "//v8",
+  ]
+}

cobalt/renderer/cobalt_content_renderer_client.cc

@@ -14,6 +14,7 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/task/single_thread_task_runner.h"
 #include "cobalt/common/shell_switches.h"
+#include "cobalt/renderer/cobalt_render_frame_observer.h"
 #include "components/cdm/renderer/external_clear_key_key_system_info.h"
 #include "components/network_hints/renderer/web_prescient_networking_impl.h"
 #include "components/web_cache/renderer/web_cache_impl.h"
@@ -107,6 +108,8 @@ void CobaltContentRendererClient::ExposeInterfacesToBrowser(
 void CobaltContentRendererClient::RenderFrameCreated(
     content::RenderFrame* render_frame) {
   new js_injection::JsCommunication(render_frame);
+  // CobaltRenderFrameObserver::OnDestruct deletes this.
+  new CobaltRenderFrameObserver(render_frame);
 }
 
 void CobaltContentRendererClient::PrepareErrorPage(

cobalt/renderer/cobalt_render_frame_observer.cc

@@ -0,0 +1,133 @@
+// Copyright 2025 The Cobalt Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "cobalt/renderer/cobalt_render_frame_observer.h"
+
+#include "cobalt/configuration/configuration.h"
+#include "content/public/common/isolated_world_ids.h"
+#include "content/public/renderer/chrome_object_extensions_utils.h"
+#include "content/public/renderer/render_frame.h"
+#include "gin/converter.h"
+#include "starboard/system.h"
+#include "third_party/blink/public/web/blink.h"
+#include "third_party/blink/public/web/web_local_frame.h"
+#include "v8/include/v8.h"
+
+namespace cobalt {
+
+namespace {
+
+void PerformUserOnExitStrategy() {
+  auto exit_strategy =
+      configuration::Configuration::GetInstance()->CobaltUserOnExitStrategy();
+  // By checking the exit strategy here, the client can call |window.close()|
+  // without checking what the exit strategy is. The client does differentiate
+  // between |kUserOnExitStrategyClose| and the other exit strategies. For
+  // |kUserOnExitStrategyClose|, the player is stopped. For this reason, we may
+  // still need to expose |window.h5vcc.system.userOnExitStrategy| to support
+  // this.
+  //
+  // Our |window.close()| deviates from the spec's original intent, but it is an
+  // existing function on |window|. If a window is opened with |window.open()|,
+  // the return is a new window (like a tab in Chrome) and this new window can
+  // be closed by calling |close()|. To check if the window was closed, the
+  // |closed| property can be checked.
+  //
+  // In our case, |window.close()| is being used to conceal or stop the
+  // application.
+  //
+  // |window.close()| can continue to be used. Arguments passed to
+  // |window.close()| in the original implementation are ignored. In our custom
+  // implementation, we can check for closures to run before no-exit, conceal,
+  // or exit. They could be passed in an object like
+  //
+  // window.close({beforeExit: doBeforeExitOps, beforeNoExit, beforeConceal});
+  //
+  // This would allow use to remove |window.h5vcc.system.userOnExitStrategy|.
+  // And this seems reasonable considering the |window.close()| is a custom
+  // implementation that does not align with spec's original intent.
+  if (exit_strategy == configuration::UserOnExitStrategy::kMinimize) {
+    SbSystemRequestConceal();
+    return;
+  }
+
+  if (exit_strategy == configuration::UserOnExitStrategy::kClose) {
+    SbSystemRequestStop(0);
+    return;
+  }
+}
+
+}  // namespace
+
+CobaltRenderFrameObserver::CobaltRenderFrameObserver(
+    content::RenderFrame* render_frame)
+    : content::RenderFrameObserver(render_frame),
+      user_on_exit_strategy_callback_(
+          base::BindRepeating(&PerformUserOnExitStrategy)) {}
+
+void CobaltRenderFrameObserver::DidCreateScriptContext(
+    v8::Local<v8::Context> /* v8_context */,
+    int32_t world_id) {
+  // Only install on the main world context of the main frame.
+  if (!render_frame() || !render_frame()->IsMainFrame() ||
+      world_id != content::ISOLATED_WORLD_ID_GLOBAL) {
+    return;
+  }
+
+  InstallCloseAndMinimize();
+}
+
+// static
+void CobaltRenderFrameObserver::DoWindowCloseOrMinimize(
+    const v8::FunctionCallbackInfo<v8::Value>& info) {
+  v8::Local<v8::Value> data = info.Data();
+  CobaltRenderFrameObserver* self = static_cast<CobaltRenderFrameObserver*>(
+      v8::External::Cast(*data)->Value());
+  self->user_on_exit_strategy_callback_.Run();
+}
+
+void CobaltRenderFrameObserver::InstallCloseAndMinimize() {
+  if (!render_frame()) {
+    return;
+  }
+  v8::Isolate* isolate = blink::MainThreadIsolate();
+  v8::HandleScope handle_scope(isolate);
+  v8::Local<v8::Context> context =
+      render_frame()->GetWebFrame()->MainWorldScriptContext();
+  if (context.IsEmpty()) {
+    return;
+  }
+
+  v8::Context::Scope context_scope(context);
+  v8::Local<v8::Object> window = context->Global();
+  v8::Local<v8::External> v8_this = v8::External::New(isolate, this);
+  window
+      ->Set(context, gin::StringToSymbol(isolate, "minimize"),
+            v8::Function::New(
+                context, &CobaltRenderFrameObserver::DoWindowCloseOrMinimize,
+                v8_this)
+                .ToLocalChecked())
+      .Check();
+  window
+      ->Set(context, gin::StringToSymbol(isolate, "close"),
+            v8::Function::New(
+                context, &CobaltRenderFrameObserver::DoWindowCloseOrMinimize,
+                v8_this)
+                .ToLocalChecked())
+      .Check();
+  v8::Local<v8::Object> h5vcc =
+      content::GetOrCreateObject(isolate, context, "h5vcc");
+  v8::Local<v8::Object> h5vcc_system =
+      content::GetOrCreateObject(isolate, context, h5vcc, "system");
+  auto exit_strategy =
+      configuration::Configuration::GetInstance()->CobaltUserOnExitStrategy();
+  h5vcc_system->Set(context, gin::StringToSymbol(isolate, "userOnExitStrategy"),
+                    v8::Integer::New(isolate, exit_strategy));
+}
+
+void CobaltRenderFrameObserver::OnDestruct() {
+  delete this;
+}
+
+}  // namespace cobalt