basalt-win32 0.0.0-rc5

package/native/tests/test_win32_accessibility.cpp

@@ -0,0 +1,271 @@
+// What a screen reader is told.
+//
+// The union of tests/test_accessibility.cpp on GTK and
+// tests/test_appkit_accessibility.mm on AppKit. What differs is how the answer
+// is obtained: those two set a property on a widget and read it back, while
+// UI Automation is a pull interface, so these build the provider and ask it the
+// same questions a screen reader would -- by property id, through
+// GetPropertyValue.
+//
+// Nothing here needs a window. UIA's tree navigation does, because a fragment
+// root is an HWND, and that half lands with the host; the property half is
+// answerable now and is most of what the other two suites check.
+
+#include "TestHarness.h"
+
+#include "RnWin32Accessible.h"
+#include "RnWin32View.h"
+// For narrow(): UIA answers in BSTRs and these assertions are written in UTF-8,
+// like the rest of the project.
+#include "Win32Strings.h"
+
+#include <windows.h>
+
+// WIN32_LEAN_AND_MEAN keeps combaseapi.h out of windows.h, and that is where the
+// `interface` macro lives -- without it UIAutomationCore.h fails on its own
+// first typedef, which reads as a broken SDK rather than a missing include.
+#include <objbase.h>
+
+#include <uiautomation.h>
+#include <wrl/client.h>
+
+#include <memory>
+#include <sstream>
+#include <string>
+
+using Microsoft::WRL::ComPtr;
+using basalt::win32::RnAccessibleFlag;
+using basalt::win32::RnAccessibleInfo;
+using basalt::win32::RnWin32View;
+
+namespace {
+
+ComPtr<IRawElementProviderSimple> providerFor(const RnAccessibleInfo &info) {
+  ComPtr<IRawElementProviderSimple> provider;
+  provider.Attach(basalt::win32::createAccessibleProvider(info));
+  return provider;
+}
+
+// The control type a provider reports, or -1 if it has none.
+long controlTypeOf(const ComPtr<IRawElementProviderSimple> &provider) {
+  if (!provider) {
+    return -1;
+  }
+  VARIANT value;
+  VariantInit(&value);
+  if (FAILED(provider->GetPropertyValue(UIA_ControlTypePropertyId, &value))) {
+    return -1;
+  }
+  const long result = value.vt == VT_I4 ? value.lVal : -1;
+  VariantClear(&value);
+  return result;
+}
+
+// A string property, or "" when the provider declined to answer.
+std::string stringProperty(const ComPtr<IRawElementProviderSimple> &provider, PROPERTYID id) {
+  if (!provider) {
+    return {};
+  }
+  VARIANT value;
+  VariantInit(&value);
+  if (FAILED(provider->GetPropertyValue(id, &value))) {
+    return {};
+  }
+  std::string result;
+  if (value.vt == VT_BSTR && value.bstrVal != nullptr) {
+    const std::wstring wide(value.bstrVal, SysStringLen(value.bstrVal));
+    result = basalt::win32::narrow(wide);
+  }
+  VariantClear(&value);
+  return result;
+}
+
+// A VARIANT's type tag, so a test can say "this property was left unset" --
+// which is a different claim from "this property is false".
+VARTYPE propertyType(const ComPtr<IRawElementProviderSimple> &provider, PROPERTYID id) {
+  if (!provider) {
+    return VT_EMPTY;
+  }
+  VARIANT value;
+  VariantInit(&value);
+  if (FAILED(provider->GetPropertyValue(id, &value))) {
+    return VT_EMPTY;
+  }
+  const VARTYPE type = value.vt;
+  VariantClear(&value);
+  return type;
+}
+
+long longProperty(const ComPtr<IRawElementProviderSimple> &provider, PROPERTYID id) {
+  VARIANT value;
+  VariantInit(&value);
+  provider->GetPropertyValue(id, &value);
+  const long result = value.vt == VT_I4 ? value.lVal : -1;
+  VariantClear(&value);
+  return result;
+}
+
+bool boolProperty(const ComPtr<IRawElementProviderSimple> &provider, PROPERTYID id) {
+  VARIANT value;
+  VariantInit(&value);
+  provider->GetPropertyValue(id, &value);
+  const bool result = value.vt == VT_BOOL && value.boolVal == VARIANT_TRUE;
+  VariantClear(&value);
+  return result;
+}
+
+RnAccessibleInfo withRole(const std::string &role) {
+  RnAccessibleInfo info;
+  info.role = role;
+  return info;
+}
+
+} // namespace
+
+TEST(accessibility_maps_react_native_roles_onto_uia) {
+  EXPECT_EQ(controlTypeOf(providerFor(withRole("button"))),
+            static_cast<long>(UIA_ButtonControlTypeId));
+  EXPECT_EQ(controlTypeOf(providerFor(withRole("link"))),
+            static_cast<long>(UIA_HyperlinkControlTypeId));
+  EXPECT_EQ(controlTypeOf(providerFor(withRole("image"))),
+            static_cast<long>(UIA_ImageControlTypeId));
+  EXPECT_EQ(controlTypeOf(providerFor(withRole("text"))),
+            static_cast<long>(UIA_TextControlTypeId));
+  EXPECT_EQ(controlTypeOf(providerFor(withRole("checkbox"))),
+            static_cast<long>(UIA_CheckBoxControlTypeId));
+  EXPECT_EQ(controlTypeOf(providerFor(withRole("adjustable"))),
+            static_cast<long>(UIA_SliderControlTypeId));
+  EXPECT_EQ(controlTypeOf(providerFor(withRole("tablist"))),
+            static_cast<long>(UIA_TabControlTypeId));
+}
+
+TEST(accessibility_falls_back_to_a_group) {
+  // A role UIA has no control type for is a group, not a guess. A wrong control
+  // type is worse than a vague one: it makes a view announce itself as
+  // something it is not.
+  EXPECT_EQ(controlTypeOf(providerFor(withRole("summary"))),
+            static_cast<long>(UIA_GroupControlTypeId));
+  EXPECT_EQ(controlTypeOf(providerFor(withRole("somethingnobodyhasheardof"))),
+            static_cast<long>(UIA_GroupControlTypeId));
+
+  // And a switch is a checkbox, because UIA has no switch. Named here rather
+  // than left to be rediscovered, since it is a deliberate approximation.
+  EXPECT_EQ(controlTypeOf(providerFor(withRole("switch"))),
+            static_cast<long>(UIA_CheckBoxControlTypeId));
+}
+
+TEST(accessibility_leaves_plain_views_out_of_the_tree) {
+  // A <View> with no role, no label and no hint is scaffolding. A tree full of
+  // untyped groups is worse for a screen reader user than a tree without them.
+  RnAccessibleInfo plain;
+  EXPECT(!basalt::win32::isAccessibilityElement(plain));
+  EXPECT(basalt::win32::createAccessibleProvider(plain) == nullptr);
+
+  // A label alone is enough to make it worth reporting.
+  RnAccessibleInfo labelled;
+  labelled.label = "Close";
+  EXPECT(basalt::win32::isAccessibilityElement(labelled));
+}
+
+TEST(accessibility_honours_a_presentational_role) {
+  EXPECT(basalt::win32::roleIsPresentational("none"));
+  EXPECT(basalt::win32::roleIsPresentational("presentation"));
+  EXPECT(!basalt::win32::roleIsPresentational("button"));
+
+  // Explicitly presentational beats having a label: the app said not to report
+  // this one.
+  RnAccessibleInfo info = withRole("none");
+  info.label = "ignored";
+  EXPECT(basalt::win32::createAccessibleProvider(info) == nullptr);
+}
+
+TEST(accessibility_label_and_hint_reach_uia) {
+  RnAccessibleInfo info = withRole("button");
+  info.label = "Save";
+  info.hint = "Writes the file to disk";
+
+  auto provider = providerFor(info);
+  EXPECT(provider != nullptr);
+  EXPECT_EQ(stringProperty(provider, UIA_NamePropertyId), std::string("Save"));
+  // React Native's hint is "what happens if you do this", which is what UIA
+  // calls help text.
+  EXPECT_EQ(stringProperty(provider, UIA_HelpTextPropertyId),
+            std::string("Writes the file to disk"));
+}
+
+TEST(accessibility_states_reach_uia) {
+  RnAccessibleInfo info = withRole("checkbox");
+  info.state.disabled = RnAccessibleFlag::True;
+  info.state.checked = RnAccessibleFlag::True;
+  info.state.selected = RnAccessibleFlag::True;
+  info.state.expanded = RnAccessibleFlag::False;
+
+  auto provider = providerFor(info);
+  EXPECT(provider != nullptr);
+
+  EXPECT(!boolProperty(provider, UIA_IsEnabledPropertyId));
+  EXPECT_EQ(longProperty(provider, UIA_ToggleToggleStatePropertyId),
+            static_cast<long>(ToggleState_On));
+  EXPECT(boolProperty(provider, UIA_SelectionItemIsSelectedPropertyId));
+  EXPECT_EQ(longProperty(provider, UIA_ExpandCollapseExpandCollapseStatePropertyId),
+            static_cast<long>(ExpandCollapseState_Collapsed));
+}
+
+TEST(accessibility_unset_leaves_uia_alone) {
+  // The tri-state, stated as a test. A view that never mentions being checked
+  // is not an unchecked checkbox, and must not report ToggleState_Off -- which
+  // a screen reader would read aloud as "not checked".
+  auto provider = providerFor(withRole("button"));
+  EXPECT(provider != nullptr);
+
+  EXPECT_EQ(propertyType(provider, UIA_ToggleToggleStatePropertyId), VT_EMPTY);
+  EXPECT_EQ(propertyType(provider, UIA_SelectionItemIsSelectedPropertyId), VT_EMPTY);
+  EXPECT_EQ(propertyType(provider, UIA_ExpandCollapseExpandCollapseStatePropertyId), VT_EMPTY);
+
+  // IsEnabled is the exception, and deliberately: UIA has no "unknown" for it,
+  // and its default is enabled, which is React Native's default too.
+  EXPECT_EQ(propertyType(provider, UIA_IsEnabledPropertyId), VT_BOOL);
+  EXPECT(boolProperty(provider, UIA_IsEnabledPropertyId));
+}
+
+TEST(accessibility_hidden_takes_a_view_out_of_the_tree) {
+  RnAccessibleInfo info = withRole("button");
+  info.label = "Save";
+  info.hidden = true;
+
+  EXPECT(!basalt::win32::isAccessibilityElement(info));
+  EXPECT(basalt::win32::createAccessibleProvider(info) == nullptr);
+}
+
+TEST(accessibility_role_is_reported_in_the_tree) {
+  auto view = std::make_unique<RnWin32View>(3);
+  view->setFrame(0, 0, 100, 40);
+
+  RnAccessibleInfo info = withRole("button");
+  info.label = "Save";
+  view->setAccessibleInfo(info);
+
+  // React Native's role name, not UIA's -- the same string GTK and AppKit
+  // print, so the three dumps compare.
+  EXPECT_EQ(view->describeTree(), std::string("view tag=3 frame=(0,0 100x40) role=button\n"));
+}
+
+TEST(accessibility_role_can_change_after_mount) {
+  // GTK cannot do this: a GtkAccessible's role is construct-only, so
+  // `docs/DECISIONS.md` records that accessibilityRole is fixed once a widget
+  // exists. UI Automation pulls rather than being pushed to, so there is
+  // nothing baked in, and the mounting manager should not copy GTK's
+  // restriction when it arrives.
+  auto view = std::make_unique<RnWin32View>(4);
+  view->setAccessibleInfo(withRole("button"));
+
+  ComPtr<IRawElementProviderSimple> asButton;
+  asButton.Attach(view->createAccessibleProvider());
+  EXPECT_EQ(controlTypeOf(asButton), static_cast<long>(UIA_ButtonControlTypeId));
+
+  view->setAccessibleInfo(withRole("checkbox"));
+
+  ComPtr<IRawElementProviderSimple> asCheckbox;
+  asCheckbox.Attach(view->createAccessibleProvider());
+  EXPECT_EQ(controlTypeOf(asCheckbox), static_cast<long>(UIA_CheckBoxControlTypeId));
+}

package/native/tests/test_win32_clipboard.cpp

@@ -0,0 +1,121 @@
+// Tests for the clipboard half of core/PlatformServices.h on Windows.
+//
+// These use the real clipboard, because the thing being tested is how it
+// behaves when somebody else holds it -- and the only somebody that can be
+// arranged from a test is a second thread in this process, which OpenClipboard
+// treats exactly like another program. What the clipboard held before is put
+// back at the end, as text; anything richer than text is lost, the same as
+// js/modules.js running.
+
+#include "TestHarness.h"
+
+#include "PlatformServices.h"
+
+#include <windows.h>
+
+#include <atomic>
+#include <chrono>
+#include <string>
+#include <thread>
+
+namespace {
+
+// Opens the clipboard on another thread and keeps it for `holdMs`, which is
+// what a clipboard listener does right after every write. Returns once the
+// clipboard is actually held, so the caller's attempt is guaranteed to collide.
+class ClipboardHolder {
+ public:
+  explicit ClipboardHolder(int holdMs) {
+    thread_ = std::thread([this, holdMs] {
+      // Opened against a window, because only that excludes anyone. A holder
+      // that passes no window -- as the code under test does -- blocks nobody,
+      // not even another process, and the first version of this test held the
+      // clipboard that way and passed with the retry removed. A clipboard
+      // listener has a window by definition; that is how it is told.
+      const HWND window = CreateWindowExW(
+          0, L"STATIC", L"", 0, 0, 0, 0, 0, HWND_MESSAGE, nullptr, nullptr, nullptr);
+      // Retried, and for longer than the code under test retries: the write
+      // just before this is announced to every listener on the machine, and
+      // one of them is usually still reading.
+      for (int attempt = 0; attempt < 200 && !held_; ++attempt) {
+        if (OpenClipboard(window)) {
+          held_ = true;
+        } else {
+          Sleep(5);
+        }
+      }
+      if (held_) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(holdMs));
+        CloseClipboard();
+      }
+      if (window != nullptr) {
+        DestroyWindow(window);
+      }
+      finished_ = true;
+    });
+    // Until it is held, or the attempt to hold it has failed and held() says so.
+    while (!held_ && !finished_) {
+      std::this_thread::yield();
+    }
+  }
+  ~ClipboardHolder() {
+    thread_.join();
+  }
+  ClipboardHolder(const ClipboardHolder &) = delete;
+  ClipboardHolder &operator=(const ClipboardHolder &) = delete;
+
+  bool held() const {
+    return held_;
+  }
+
+ private:
+  std::thread thread_;
+  std::atomic<bool> held_{false};
+  std::atomic<bool> finished_{false};
+};
+
+class RestoreClipboard {
+ public:
+  RestoreClipboard() : saved_(basalt::clipboardText()) {}
+  ~RestoreClipboard() {
+    basalt::setClipboardText(saved_);
+  }
+  RestoreClipboard(const RestoreClipboard &) = delete;
+  RestoreClipboard &operator=(const RestoreClipboard &) = delete;
+
+ private:
+  std::string saved_;
+};
+
+} // namespace
+
+TEST(win32_clipboard_round_trips_unicode) {
+  RestoreClipboard restore;
+  const std::string written = "h\xC3\xA9llo \xE4\xB8\x96\xE7\x95\x8C \xF0\x9F\x9C\x82";
+  basalt::setClipboardText(written);
+  EXPECT_EQ(basalt::clipboardText(), written);
+}
+
+TEST(win32_clipboard_write_waits_out_a_brief_holder) {
+  RestoreClipboard restore;
+  basalt::setClipboardText("before");
+  {
+    // Well inside the retry budget, and far longer than one attempt.
+    ClipboardHolder holder(20);
+    EXPECT(holder.held());
+    basalt::setClipboardText("after");
+  }
+  EXPECT_EQ(basalt::clipboardText(), std::string("after"));
+}
+
+TEST(win32_clipboard_read_waits_out_a_brief_holder) {
+  RestoreClipboard restore;
+  basalt::setClipboardText("still here");
+  std::string read;
+  {
+    ClipboardHolder holder(20);
+    EXPECT(holder.held());
+    read = basalt::clipboardText();
+  }
+  EXPECT_EQ(read, std::string("still here"));
+}

package/native/tests/test_win32_focus.cpp

@@ -0,0 +1,195 @@
+// Keyboard focus: what Tab stops on, in what order, and what Enter does.
+//
+// The same questions the GTK and AppKit suites ask, in the same order, because
+// the answers have to match -- but here they are testable with no window at
+// all. That is the difference this platform makes: on the other two, focus
+// belongs to the toolkit and a test has to show a window to get at it. Here a
+// React Native view is a C++ object with no window behind it, so the whole
+// chain is Win32Focus.cpp's and can be driven directly.
+//
+// No emitter is attached to these hand-built shadow views, so the focus and
+// blur events have nowhere to go and the click dispatch does nothing. What is
+// observable is the part that decides where focus is, which is the part this
+// project can get wrong on its own.
+
+#include "TestHarness.h"
+
+#include "Win32Focus.h"
+#include "Win32MountingManager.h"
+
+#include <react/renderer/components/view/ViewProps.h>
+
+#include <cstdint>
+#include <memory>
+#include <sstream>
+
+using basalt::Win32FocusManager;
+using basalt::Win32MountingManager;
+using basalt::win32::RnWin32View;
+using facebook::react::LayoutMetrics;
+using facebook::react::MountingTransaction;
+using facebook::react::ShadowView;
+using facebook::react::ShadowViewMutation;
+using facebook::react::ShadowViewMutationList;
+using facebook::react::SurfaceId;
+using facebook::react::Tag;
+using facebook::react::TransactionTelemetry;
+using facebook::react::ViewProps;
+
+namespace {
+
+constexpr SurfaceId kSurfaceId = 1;
+
+ShadowView makeAccessibleView(Tag tag, float y, bool accessible) {
+  auto props = std::make_shared<ViewProps>();
+  props->accessible = accessible;
+
+  LayoutMetrics metrics;
+  metrics.frame = {.origin = {.x = 0, .y = y}, .size = {.width = 200, .height = 40}};
+
+  ShadowView view;
+  view.componentName = "View";
+  view.surfaceId = kSurfaceId;
+  view.tag = tag;
+  view.props = props;
+  view.layoutMetrics = metrics;
+  return view;
+}
+
+void mountAll(Win32MountingManager &manager, std::initializer_list<ShadowView> views) {
+  ShadowViewMutationList mutations;
+  int index = 0;
+  for (const ShadowView &view : views) {
+    mutations.push_back(ShadowViewMutation::CreateMutation(view));
+    mutations.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, view, index++));
+  }
+  manager.applyTransaction(
+      kSurfaceId, MountingTransaction(kSurfaceId, 1, std::move(mutations), TransactionTelemetry{}));
+}
+
+} // namespace
+
+TEST(win32_focus_accessible_views_are_the_ones_tab_stops_on) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 400);
+  // React Native's `focusable` prop never reaches this platform, so `accessible`
+  // is the signal -- and it is what <Pressable> sets on everything it renders.
+  mountAll(manager,
+           {makeAccessibleView(10, 0, true),
+            makeAccessibleView(11, 50, false),
+            makeAccessibleView(12, 100, true)});
+
+  EXPECT(manager.viewForTag(10)->focusable());
+  EXPECT(!manager.viewForTag(11)->focusable());
+  EXPECT(manager.viewForTag(12)->focusable());
+  // And it shows up in the tree dump, so the cross-host diff can say the prop
+  // arrived on all three.
+  EXPECT(root->describeTree().find("focusable") != std::string::npos);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(win32_focus_tab_visits_focusable_views_in_tree_order_and_wraps) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 400);
+  Win32FocusManager focus(&manager, root);
+  mountAll(manager,
+           {makeAccessibleView(10, 0, true),
+            makeAccessibleView(11, 50, false),
+            makeAccessibleView(12, 100, true)});
+
+  // Nothing is focused when a window opens, on any of the three.
+  EXPECT_EQ(static_cast<long>(focus.focusedTag()), 0L);
+
+  EXPECT(focus.moveFocus(true));
+  EXPECT_EQ(static_cast<long>(focus.focusedTag()), 10L);
+  // 11 is not accessible, so Tab goes past it.
+  EXPECT(focus.moveFocus(true));
+  EXPECT_EQ(static_cast<long>(focus.focusedTag()), 12L);
+  // And round again: a window's Tab order wraps.
+  EXPECT(focus.moveFocus(true));
+  EXPECT_EQ(static_cast<long>(focus.focusedTag()), 10L);
+  // Backwards is the same order in reverse.
+  EXPECT(focus.moveFocus(false));
+  EXPECT_EQ(static_cast<long>(focus.focusedTag()), 12L);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(win32_focus_moves_the_ring_with_it) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 400);
+  Win32FocusManager focus(&manager, root);
+  mountAll(manager, {makeAccessibleView(10, 0, true), makeAccessibleView(11, 50, true)});
+
+  // The ring is this project's own here: a view is not a window, so there is no
+  // Win32 focus for the painting to ask about.
+  focus.moveFocus(true);
+  EXPECT(manager.viewForTag(10)->showsFocusRing());
+  EXPECT(!manager.viewForTag(11)->showsFocusRing());
+
+  focus.moveFocus(true);
+  EXPECT(!manager.viewForTag(10)->showsFocusRing());
+  EXPECT(manager.viewForTag(11)->showsFocusRing());
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(win32_focus_a_hidden_view_is_not_a_tab_stop) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 400);
+  Win32FocusManager focus(&manager, root);
+  mountAll(manager, {makeAccessibleView(10, 0, true), makeAccessibleView(11, 50, true)});
+
+  // Tab stopping on something nobody can see is worse than Tab skipping it.
+  manager.viewForTag(10)->setHidden(true);
+  focus.moveFocus(true);
+  EXPECT_EQ(static_cast<long>(focus.focusedTag()), 11L);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(win32_focus_activating_nothing_is_not_a_click) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 400);
+  Win32FocusManager focus(&manager, root);
+  mountAll(manager, {makeAccessibleView(10, 0, true)});
+
+  // Nothing has focus yet, so there is nothing to activate -- and reporting a
+  // press with no target is how a keystroke reaches the wrong view.
+  EXPECT(!focus.activateFocused());
+
+  focus.moveFocus(true);
+  // No emitter is attached to these hand-built shadow views, so the click has
+  // nowhere to deliver. It must not crash, and the key is still consumed: that
+  // is exactly the shape of Enter arriving between a Remove and its Delete.
+  EXPECT(focus.activateFocused());
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(win32_focus_keys_that_are_not_tab_or_enter_are_left_alone) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 400);
+  Win32FocusManager focus(&manager, root);
+  mountAll(manager, {makeAccessibleView(10, 0, true)});
+
+  // Reported as unhandled, so the window's own shortcuts still see them. VK_F1
+  // and VK_ESCAPE stand for everything that is not this file's business.
+  EXPECT(!focus.handleKeyDown(0x70)); // VK_F1
+  EXPECT(!focus.handleKeyDown(0x1B)); // VK_ESCAPE
+  // And Enter with nothing focused goes on rather than being swallowed.
+  EXPECT(!focus.handleKeyDown(0x0D)); // VK_RETURN
+
+  EXPECT(focus.handleKeyDown(0x09)); // VK_TAB
+  EXPECT_EQ(static_cast<long>(focus.focusedTag()), 10L);
+  EXPECT(focus.handleKeyDown(0x0D)); // VK_RETURN, now that something has focus
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}