src/ui/scenic/lib/input/tests/focus_transfer_test.cc - fuchsia - Git at Google

 // Copyright 2019 The Fuchsia 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 <fuchsia/ui/input/cpp/fidl.h>
 #include <lib/syslog/cpp/macros.h>
 #include <lib/ui/scenic/cpp/resources.h>
 #include <lib/ui/scenic/cpp/view_ref_pair.h>
 #include <lib/ui/scenic/cpp/view_token_pair.h>

 #include <memory>

 #include "src/ui/scenic/lib/gfx/engine/engine.h"
 #include "src/ui/scenic/lib/gfx/engine/view_tree.h"
 #include "src/ui/scenic/lib/input/tests/util.h"
 #include "src/ui/scenic/lib/scenic/scenic.h"

 // This test exercises focus transfer logic when touch or mouse events are involved.
 //
 // A pointer DOWN event typically triggers a pair of focus/unfocus events, each sent to a client.
 // However, when the DOWN event does not have associated views, then focus should revert to the root
 // of a valid focus chain.
 //
 // The geometry is constrained to a 9x9 display and layer. We need one root session to set up the
 // Scene (with no geometry), and two ordinary sessions to each set up its 5x5 View. The spatial
 // layout is as follows:
 //
 // - - - - - - - - -    (invisible) - scene's origin translated to (1,1), relative to display
 // - 1 1 1 1 1 - - -    1 - view 1: a 5x5 square, origin coincides with scene origin
 // - 1 1 1 1 1 - y -        (z depth is 1 - lower than view 2)
 // - 1 1 2 2 2 2 x -    2 - view 2: a 5x5 square, origin translated (2,2) from scene origin
 // - 1 1 2 2 2 2 2 -        (z depth is 0 - higher than view 1)
 // - 1 1 2 2 2 2 2 -    x - touch/mouse down on view 2: focus transfers to view 2
 // - - - 2 2 2 2 2 -    y - touch/mouse down outside of view: focus transfers to scene
 // - - - 2 2 2 2 2 -
 // - - - - - - - - -
 //
 // The scene graph has the following topology:
 //         scene
 //        /     \
 //   holder 1   holder 2
 //       |        |
 //    view 1     view 2
 //
 // To create this test setup, we perform translation of each holder (a (0,0,1) and (2,2,0)
 // translation for each view holder, respectively, within the scene), in addition to translating the
 // Rectangle shape within each view's space (a constant (2,2) translation). Setup finishes by
 // transferring focus to view 1.
 //
 // The first (ADD, DOWN) touch sequence, on x, should successfully transfer focus to view 2.
 // The second (ADD, DOWN) touch sequence, on y, should successfully transfer focus to the scene.

 namespace src_ui_scenic_lib_input_tests {

 using A11yPointerEvent = fuchsia::ui::input::accessibility::PointerEvent;
 using A11yStreamResponse = fuchsia::ui::input::accessibility::EventHandling;
 using fuchsia::ui::input::InputEvent;
 using fuchsia::ui::input::PointerEventPhase;
 using fuchsia::ui::input::PointerEventType;
 using lib_ui_input_tests::InputSystemTest;
 using lib_ui_input_tests::PointerCommandGenerator;
 using lib_ui_input_tests::PointerMatches;
 using lib_ui_input_tests::ResourceGraph;
 using lib_ui_input_tests::SessionWrapper;
 using scenic_impl::gfx::ViewTree;

 // Class fixture for TEST _F. Sets up a 9x9 "display".
 class FocusTransferTest : public InputSystemTest {
  protected:
   uint32_t test_display_width_px() const override { return 9; }
   uint32_t test_display_height_px() const override { return 9; }

   // Accessors.
   SessionWrapper* root_session() { return root_session_.get(); }
   ResourceGraph* root_resources() { return root_resources_.get(); }
   SessionWrapper* client_1() { return client_1_.get(); }
   SessionWrapper* client_2() { return client_2_.get(); }

   void ClearEventsInAllSessions() {
     if (root_session_)
       root_session_->events().clear();
     if (client_1_)
       client_1_->events().clear();
     if (client_2_)
       client_2_->events().clear();
   }

  private:
   // Scene setup.
   void SetUp() override {
     InputSystemTest::SetUp();

     auto view_pair_1 = scenic::ViewTokenPair::New();  // root - client 1
     auto view_pair_2 = scenic::ViewTokenPair::New();  // root - client 2

     // Set up a scene with two views.
     auto [root_session, root_resources] = CreateScene();
     {
       scenic::Session* const session = root_session.session();
       scenic::Scene* const scene = &root_resources.scene;

       // Translate the scene.
       scene->SetTranslation(1, 1, 0);

       // Attach the translated view holders.
       scenic::ViewHolder holder_1(session, std::move(view_pair_1.view_holder_token), "holder_1"),
           holder_2(session, std::move(view_pair_2.view_holder_token), "holder_2");

       holder_1.SetViewProperties(k5x5x1);
       holder_2.SetViewProperties(k5x5x1);

       scene->AddChild(holder_1);
       holder_1.SetTranslation(0, 0, 1);  // View 1's origin coincides with Scene's origin.

       scene->AddChild(holder_2);
       holder_2.SetTranslation(2, 2, 0);  // View 2's origin translated (2, 2) wrt Scene's origin.

       RequestToPresent(session);
     }

     // Clients.
     SessionWrapper client_1 = CreateClient("View 1", std::move(view_pair_1.view_token)),
                    client_2 = CreateClient("View 2", std::move(view_pair_2.view_token));

     // Transfer focus to client 1.
     {
       root_session.SetViewKoid(engine()->scene_graph()->view_tree().focus_chain()[0]);
       auto status =
           engine()->scene_graph()->RequestFocusChange(root_session.ViewKoid(), client_1.ViewKoid());
       ASSERT_EQ(status, ViewTree::FocusChangeStatus::kAccept);

       RunLoopUntilIdle();  // Flush out focus events to clients.
     }

     // Transfer ownership to test fixture.
     root_session_ = std::make_unique<SessionWrapper>(std::move(root_session));
     root_resources_ = std::make_unique<ResourceGraph>(std::move(root_resources));
     client_1_ = std::make_unique<SessionWrapper>(std::move(client_1));
     client_2_ = std::make_unique<SessionWrapper>(std::move(client_2));

     ClearEventsInAllSessions();
   }

   void TearDown() override {
     root_resources_ = nullptr;
     root_session_ = nullptr;
     client_1_ = nullptr;
     client_2_ = nullptr;
     InputSystemTest::TearDown();
   }

   std::unique_ptr<SessionWrapper> root_session_;
   std::unique_ptr<ResourceGraph> root_resources_;
   std::unique_ptr<SessionWrapper> client_1_;
   std::unique_ptr<SessionWrapper> client_2_;
 };

 // Class for testing if turning pointer auto focus off works.
 class NoFocusTransferTest : public FocusTransferTest {
  private:
   bool auto_focus_behavior() const override { return false; }
 };

 // Some tests require the presence of an accessibility listener to trigger pointer interception.
 class A11yListener : public fuchsia::ui::input::accessibility::PointerEventListener {
  public:
   A11yListener(scenic_impl::input::InputSystem* input_system) : listener_binding_(this) {
     input_system->RegisterA11yListener(listener_binding_.NewBinding(),
                                        [](bool success) { ASSERT_TRUE(success); });
   }

  private:
   // |fuchsia::ui::input::accessibility::PointerEventListener|
   // Simple response: always reject on MOVE event.
   void OnEvent(A11yPointerEvent event) override {
     if (event.phase() == PointerEventPhase::MOVE) {
       listener_binding_.events().OnStreamHandled(event.device_id(), event.pointer_id(),
                                                  A11yStreamResponse::REJECTED);
     }
   }

   fidl::Binding<fuchsia::ui::input::accessibility::PointerEventListener> listener_binding_;
 };

 // Normally, focus gets transferred to a valid target on the DOWN phase.
 TEST_F(FocusTransferTest, TouchFocusWithValidTarget) {
   // Inject ADD/DOWN on client 2 to trigger focus dispatch.
   {
     scenic::Session* const session = root_session()->session();

     PointerCommandGenerator finger(root_resources()->compositor.id(), /*device id*/ 1,
                                    /*pointer id*/ 1, PointerEventType::TOUCH);
     session->Enqueue(finger.Add(7.5, 3.5));
     session->Enqueue(finger.Down(7.5, 3.5));
   }
   RunLoopUntilIdle();

   // Verify client 1 receives unfocus event.
   {
     const std::vector<InputEvent>& events = client_1()->events();
     ASSERT_EQ(events.size(), 1u);
     EXPECT_TRUE(events[0].is_focus());
     EXPECT_FALSE(events[0].focus().focused);
   }

   // Verify client 2 receives focus event.
   {
     const std::vector<InputEvent>& events = client_2()->events();
     ASSERT_EQ(events.size(), 3u);

     // ADD
     EXPECT_TRUE(events[0].is_pointer());
     EXPECT_TRUE(PointerMatches(events[0].pointer(), 1u, PointerEventPhase::ADD, 4.5, 0.5));

     // FOCUS
     EXPECT_TRUE(events[1].is_focus());
     EXPECT_TRUE(events[1].focus().focused);

     // DOWN
     EXPECT_TRUE(events[2].is_pointer());
     EXPECT_TRUE(PointerMatches(events[2].pointer(), 1u, PointerEventPhase::DOWN, 4.5, 0.5));
   }

   // Verify root session receives nothing.
   {
     const std::vector<InputEvent>& events = root_session()->events();
     EXPECT_EQ(events.size(), 0u);
   }
 }

 // Sometimes, focus does not have a valid target; instead, transfer focus to the root of the focus
 // chain, which is the Scene-creating session in GFX.
 TEST_F(FocusTransferTest, TouchFocusWithInvalidTarget) {
   // Inject ADD/DOWN outside of clients to trigger focus dispatch.
   {
     scenic::Session* const session = root_session()->session();

     PointerCommandGenerator finger(root_resources()->compositor.id(), /*device id*/ 1,
                                    /*pointer id*/ 1, PointerEventType::TOUCH);
     session->Enqueue(finger.Add(7.5, 2.5));
     session->Enqueue(finger.Down(7.5, 2.5));
   }
   RunLoopUntilIdle();

   // Verify client 1 receives unfocus event.
   {
     const std::vector<InputEvent>& events = client_1()->events();
     ASSERT_EQ(events.size(), 1u);

     EXPECT_TRUE(events[0].is_focus());
     EXPECT_FALSE(events[0].focus().focused);
   }

   // Verify client 2 receives nothing, since nothing was hit.
   {
     const std::vector<InputEvent>& events = client_2()->events();
     EXPECT_EQ(events.size(), 0u);
   }

   // Verify root session receives focus event, since we revert to root of focus chain.
   {
     const std::vector<InputEvent>& events = root_session()->events();
     ASSERT_EQ(events.size(), 1u);

     EXPECT_TRUE(events[0].is_focus());
     EXPECT_TRUE(events[0].focus().focused);
   }
 }

 // When a valid but unfocused target (client 2) receives an ADD event and DOWN event, and then the
 // scene disconnects, the target receives an unfocus event (where focus=false).
 TEST_F(FocusTransferTest, TouchFocusDisconnectSceneAfterDown) {
   // Inject ADD/DOWN on client 2 to trigger focus dispatch.
   {
     scenic::Session* const session = root_session()->session();

     PointerCommandGenerator finger(root_resources()->compositor.id(), /*device id*/ 1,
                                    /*pointer id*/ 1, PointerEventType::TOUCH);
     session->Enqueue(finger.Add(7.5, 3.5));
     session->Enqueue(finger.Down(7.5, 3.5));
   }
   RunLoopUntilIdle();

   ClearEventsInAllSessions();

   // Disconnect scene from compositor.
   {
     scenic::Session* const session = root_session()->session();

     scenic::LayerStack alternate_layer_stack(session);
     root_resources()->compositor.SetLayerStack(alternate_layer_stack);
     RequestToPresent(session);
   }

   // Verify client 2 receives unfocus event.
   {
     const std::vector<InputEvent>& events = client_2()->events();
     ASSERT_EQ(events.size(), 1u);

     // FOCUS
     EXPECT_TRUE(events[0].is_focus());
     EXPECT_FALSE(events[0].focus().focused);
   }

   // Verify client 1 receives nothing.
   {
     const std::vector<InputEvent>& events = client_1()->events();
     EXPECT_EQ(events.size(), 0u);
   }

   // Verify root session receives nothing.
   {
     const std::vector<InputEvent>& events = root_session()->events();
     EXPECT_EQ(events.size(), 0u);
   }
 }

 // Ensure TouchFocusWithValidTarget works after accessibility rejects the pointer stream.
 TEST_F(FocusTransferTest, TouchFocusWithValidTargetAfterA11yRejects) {
   A11yListener a11y_listener(input_system());  // Turn on accessibility interception.
   RunLoopUntilIdle();                          // Ensure FIDL calls get processed.

   // Inject ADD/DOWN on client 2 to trigger delayed focus dispatch.
   {
     scenic::Session* const session = root_session()->session();

     PointerCommandGenerator finger(root_resources()->compositor.id(), /*device id*/ 1,
                                    /*pointer id*/ 1, PointerEventType::TOUCH);
     session->Enqueue(finger.Add(7.5, 3.5));
     session->Enqueue(finger.Down(7.5, 3.5));
   }
   RunLoopUntilIdle();

   // Ordinary clients should not see focus events.
   EXPECT_EQ(client_1()->events().size(), 0u);
   EXPECT_EQ(client_2()->events().size(), 0u);
   EXPECT_EQ(root_session()->events().size(), 0u);

   // Inject MOVE to trigger a11y rejection.
   // Inject ADD/DOWN on client 2 to trigger delayed focus dispatch.
   {
     scenic::Session* const session = root_session()->session();

     PointerCommandGenerator finger(root_resources()->compositor.id(), /*device id*/ 1,
                                    /*pointer id*/ 1, PointerEventType::TOUCH);
     session->Enqueue(finger.Move(7.5, 3.5));
   }
   RunLoopUntilIdle();

   // A11y rejection of MOVE should cause event dispatch to ordinary clients.

   // Verify client 1 receives unfocus event.
   {
     const std::vector<InputEvent>& events = client_1()->events();
     ASSERT_EQ(events.size(), 1u);

     // FOCUS
     EXPECT_TRUE(events[0].is_focus());
     EXPECT_FALSE(events[0].focus().focused);
   }

   // Verify  client 2 receives focus event.
   {
     const std::vector<InputEvent>& events = client_2()->events();
     ASSERT_EQ(events.size(), 4u);

     // ADD
     EXPECT_TRUE(events[0].is_pointer());
     EXPECT_TRUE(PointerMatches(events[0].pointer(), 1u, PointerEventPhase::ADD, 4.5, 0.5));

     // FOCUS
     EXPECT_TRUE(events[1].is_focus());
     EXPECT_TRUE(events[1].focus().focused);

     // DOWN
     EXPECT_TRUE(events[2].is_pointer());
     EXPECT_TRUE(PointerMatches(events[2].pointer(), 1u, PointerEventPhase::DOWN, 4.5, 0.5));

     // MOVE
     EXPECT_TRUE(events[3].is_pointer());
     EXPECT_TRUE(PointerMatches(events[3].pointer(), 1u, PointerEventPhase::MOVE, 4.5, 0.5));
   }

   // Verify root session receives nothing.
   {
     const std::vector<InputEvent>& events = root_session()->events();
     EXPECT_EQ(events.size(), 0u);
   }
 }

 // Ensure TouchFocusWithInvalidTarget works after accessibility rejects the pointer stream.
 TEST_F(FocusTransferTest, TouchFocusWithInvalidTargetAfterA11yRejects) {
   A11yListener a11y_listener(input_system());  // Turn on accessibility interception.
   RunLoopUntilIdle();                          // Ensure FIDL calls get processed.

   // Inject ADD, DOWN, and MOVE (the MOVE triggers a11y rejection).
   {
     scenic::Session* const session = root_session()->session();

     PointerCommandGenerator finger(root_resources()->compositor.id(), /*device id*/ 1,
                                    /*pointer id*/ 1, PointerEventType::TOUCH);
     session->Enqueue(finger.Add(7, 2));
     session->Enqueue(finger.Down(7, 2));
     session->Enqueue(finger.Move(7, 2));
   }
   RunLoopUntilIdle();

   // A11y rejection of MOVE should cause focus event dispatch to ordinary clients.
   // However, there was no latch on DOWN, so nothing should see pointer events.

   // Verify client 1 receives unfocus event.
   {
     const std::vector<InputEvent>& events = client_1()->events();
     ASSERT_EQ(events.size(), 1u);

     // FOCUS
     EXPECT_TRUE(events[0].is_focus());
     EXPECT_FALSE(events[0].focus().focused);
   }

   // Verify client 2 receives nothing, since nothing was hit.
   {
     const std::vector<InputEvent>& events = client_2()->events();
     EXPECT_EQ(events.size(), 0u);
   }

   // Verify root session receives focus event, since we revert to root of focus chain.
   {
     const std::vector<InputEvent>& events = root_session()->events();
     ASSERT_EQ(events.size(), 1u);

     // FOCUS
     EXPECT_TRUE(events[0].is_focus());
     EXPECT_TRUE(events[0].focus().focused);
   }
 }

 // Normally, focus gets transferred to a valid target on the DOWN phase.
 TEST_F(FocusTransferTest, MouseFocusWithValidTarget) {
   // Inject ADD/DOWN on client 2 to trigger delayed focus dispatch.
   {
     scenic::Session* const session = root_session()->session();

     PointerCommandGenerator finger(root_resources()->compositor.id(), /*device id*/ 1,
                                    /*pointer id*/ 1, PointerEventType::MOUSE);
     session->Enqueue(finger.Move(7.5, 3.5));
     session->Enqueue(finger.Down(7.5, 3.5));
   }
   RunLoopUntilIdle();

   // Verify client 1 receives unfocus event.
   {
     const std::vector<InputEvent>& events = client_1()->events();
     ASSERT_EQ(events.size(), 1u);

     // FOCUS
     EXPECT_TRUE(events[0].is_focus());
     EXPECT_FALSE(events[0].focus().focused);
   }

   // Verify client 2 receives focus event.
   {
     const std::vector<InputEvent>& events = client_2()->events();
     ASSERT_EQ(events.size(), 3u);

     // MOVE
     EXPECT_TRUE(events[0].is_pointer());
     EXPECT_TRUE(PointerMatches(events[0].pointer(), 1u, PointerEventPhase::MOVE, 4.5, 0.5,
                                fuchsia::ui::input::PointerEventType::MOUSE));

     // FOCUS
     EXPECT_TRUE(events[1].is_focus());
     EXPECT_TRUE(events[1].focus().focused);

     // DOWN
     EXPECT_TRUE(events[2].is_pointer());
     EXPECT_TRUE(PointerMatches(events[2].pointer(), 1u, PointerEventPhase::DOWN, 4.5, 0.5,
                                fuchsia::ui::input::PointerEventType::MOUSE));
   }

   // Verify root session receives nothing.
   {
     const std::vector<InputEvent>& events = root_session()->events();
     EXPECT_EQ(events.size(), 0u);
   }
 }

 // Sometimes, focus does not have a valid target; instead, transfer focus to the root of the focus
 // chain, which is the Scene-creating session in GFX.
 TEST_F(FocusTransferTest, MouseFocusWithInvalidTarget) {
   // Inject ADD/DOWN outside of clients to trigger focus dispatch.
   {
     scenic::Session* const session = root_session()->session();

     PointerCommandGenerator finger(root_resources()->compositor.id(), /*device id*/ 1,
                                    /*pointer id*/ 1, PointerEventType::MOUSE);
     session->Enqueue(finger.Move(7, 2));
     session->Enqueue(finger.Down(7, 2));
   }
   RunLoopUntilIdle();

   // Verify client 1 receives unfocus event.
   {
     const std::vector<InputEvent>& events = client_1()->events();
     ASSERT_EQ(events.size(), 1u) << "Should receive exactly 1 input event.";

     // FOCUS
     EXPECT_TRUE(events[0].is_focus());
     EXPECT_FALSE(events[0].focus().focused);
   }

   // Verify client 2 receives nothing, since nothing was hit.
   {
     const std::vector<InputEvent>& events = client_2()->events();
     EXPECT_EQ(events.size(), 0u) << "Should receive exactly 0 input events.";
   }

   // Verify root session receives focus event, since we revert to root of focus chain.
   {
     const std::vector<InputEvent>& events = root_session()->events();
     ASSERT_EQ(events.size(), 1u) << "Should receive exactly 1 input event.";

     // FOCUS
     EXPECT_TRUE(events[0].is_focus());
     EXPECT_TRUE(events[0].focus().focused);
   }
 }

 TEST_F(NoFocusTransferTest, TouchFocusWithValidTarget) {
   // Inject ADD/DOWN on client 2 to trigger focus dispatch.
   {
     scenic::Session* const session = root_session()->session();

     PointerCommandGenerator finger(root_resources()->compositor.id(), /*device id*/ 1,
                                    /*pointer id*/ 1, PointerEventType::TOUCH);
     session->Enqueue(finger.Add(7.5, 3.5));
     session->Enqueue(finger.Down(7.5, 3.5));
   }
   RunLoopUntilIdle();

   // Verify no client receives focus events.
   EXPECT_TRUE(client_1()->events().empty());
   {
     const std::vector<InputEvent>& events = client_2()->events();
     ASSERT_EQ(events.size(), 2u);
     EXPECT_TRUE(events[0].is_pointer());
     EXPECT_TRUE(events[1].is_pointer());
   }
 }

 TEST_F(NoFocusTransferTest, MouseFocusWithValidTarget) {
   // Inject ADD/DOWN on client 2 and observe no focus dispatch.
   {
     scenic::Session* const session = root_session()->session();

     PointerCommandGenerator finger(root_resources()->compositor.id(), /*device id*/ 1,
                                    /*pointer id*/ 1, PointerEventType::MOUSE);
     session->Enqueue(finger.Move(7.5, 3.5));
     session->Enqueue(finger.Down(7.5, 3.5));
   }
   RunLoopUntilIdle();

   // Verify no client receives focus events.
   EXPECT_TRUE(client_1()->events().empty());
   {
     const std::vector<InputEvent>& events = client_2()->events();
     ASSERT_EQ(events.size(), 2u);
     EXPECT_TRUE(events[0].is_pointer());
     EXPECT_TRUE(events[1].is_pointer());
   }
 }

 }  // namespace src_ui_scenic_lib_input_tests
	// Copyright 2019 The Fuchsia 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 <fuchsia/ui/input/cpp/fidl.h>
	#include <lib/syslog/cpp/macros.h>
	#include <lib/ui/scenic/cpp/resources.h>
	#include <lib/ui/scenic/cpp/view_ref_pair.h>
	#include <lib/ui/scenic/cpp/view_token_pair.h>

	#include <memory>

	#include "src/ui/scenic/lib/gfx/engine/engine.h"
	#include "src/ui/scenic/lib/gfx/engine/view_tree.h"
	#include "src/ui/scenic/lib/input/tests/util.h"
	#include "src/ui/scenic/lib/scenic/scenic.h"

	// This test exercises focus transfer logic when touch or mouse events are involved.
	//
	// A pointer DOWN event typically triggers a pair of focus/unfocus events, each sent to a client.
	// However, when the DOWN event does not have associated views, then focus should revert to the root
	// of a valid focus chain.
	//
	// The geometry is constrained to a 9x9 display and layer. We need one root session to set up the
	// Scene (with no geometry), and two ordinary sessions to each set up its 5x5 View. The spatial
	// layout is as follows:
	//
	// - - - - - - - - - (invisible) - scene's origin translated to (1,1), relative to display
	// - 1 1 1 1 1 - - - 1 - view 1: a 5x5 square, origin coincides with scene origin
	// - 1 1 1 1 1 - y - (z depth is 1 - lower than view 2)
	// - 1 1 2 2 2 2 x - 2 - view 2: a 5x5 square, origin translated (2,2) from scene origin
	// - 1 1 2 2 2 2 2 - (z depth is 0 - higher than view 1)
	// - 1 1 2 2 2 2 2 - x - touch/mouse down on view 2: focus transfers to view 2
	// - - - 2 2 2 2 2 - y - touch/mouse down outside of view: focus transfers to scene
	// - - - 2 2 2 2 2 -
	// - - - - - - - - -
	//
	// The scene graph has the following topology:
	// scene
	// / \
	// holder 1 holder 2
	// \| \|
	// view 1 view 2
	//
	// To create this test setup, we perform translation of each holder (a (0,0,1) and (2,2,0)
	// translation for each view holder, respectively, within the scene), in addition to translating the
	// Rectangle shape within each view's space (a constant (2,2) translation). Setup finishes by
	// transferring focus to view 1.
	//
	// The first (ADD, DOWN) touch sequence, on x, should successfully transfer focus to view 2.
	// The second (ADD, DOWN) touch sequence, on y, should successfully transfer focus to the scene.

	namespace src_ui_scenic_lib_input_tests {

	using A11yPointerEvent = fuchsia::ui::input::accessibility::PointerEvent;
	using A11yStreamResponse = fuchsia::ui::input::accessibility::EventHandling;
	using fuchsia::ui::input::InputEvent;
	using fuchsia::ui::input::PointerEventPhase;
	using fuchsia::ui::input::PointerEventType;
	using lib_ui_input_tests::InputSystemTest;
	using lib_ui_input_tests::PointerCommandGenerator;
	using lib_ui_input_tests::PointerMatches;
	using lib_ui_input_tests::ResourceGraph;
	using lib_ui_input_tests::SessionWrapper;
	using scenic_impl::gfx::ViewTree;

	// Class fixture for TEST _F. Sets up a 9x9 "display".
	class FocusTransferTest : public InputSystemTest {
	protected:
	uint32_t test_display_width_px() const override { return 9; }
	uint32_t test_display_height_px() const override { return 9; }

	// Accessors.
	SessionWrapper* root_session() { return root_session_.get(); }
	ResourceGraph* root_resources() { return root_resources_.get(); }
	SessionWrapper* client_1() { return client_1_.get(); }
	SessionWrapper* client_2() { return client_2_.get(); }

	void ClearEventsInAllSessions() {
	if (root_session_)
	root_session_->events().clear();
	if (client_1_)
	client_1_->events().clear();
	if (client_2_)
	client_2_->events().clear();
	}

	private:
	// Scene setup.
	void SetUp() override {
	InputSystemTest::SetUp();

	auto view_pair_1 = scenic::ViewTokenPair::New(); // root - client 1
	auto view_pair_2 = scenic::ViewTokenPair::New(); // root - client 2

	// Set up a scene with two views.
	auto [root_session, root_resources] = CreateScene();
	{
	scenic::Session* const session = root_session.session();
	scenic::Scene* const scene = &root_resources.scene;

	// Translate the scene.
	scene->SetTranslation(1, 1, 0);

	// Attach the translated view holders.
	scenic::ViewHolder holder_1(session, std::move(view_pair_1.view_holder_token), "holder_1"),
	holder_2(session, std::move(view_pair_2.view_holder_token), "holder_2");

	holder_1.SetViewProperties(k5x5x1);
	holder_2.SetViewProperties(k5x5x1);

	scene->AddChild(holder_1);
	holder_1.SetTranslation(0, 0, 1); // View 1's origin coincides with Scene's origin.

	scene->AddChild(holder_2);
	holder_2.SetTranslation(2, 2, 0); // View 2's origin translated (2, 2) wrt Scene's origin.

	RequestToPresent(session);
	}

	// Clients.
	SessionWrapper client_1 = CreateClient("View 1", std::move(view_pair_1.view_token)),
	client_2 = CreateClient("View 2", std::move(view_pair_2.view_token));

	// Transfer focus to client 1.
	{
	root_session.SetViewKoid(engine()->scene_graph()->view_tree().focus_chain()[0]);
	auto status =
	engine()->scene_graph()->RequestFocusChange(root_session.ViewKoid(), client_1.ViewKoid());
	ASSERT_EQ(status, ViewTree::FocusChangeStatus::kAccept);

	RunLoopUntilIdle(); // Flush out focus events to clients.
	}

	// Transfer ownership to test fixture.
	root_session_ = std::make_unique<SessionWrapper>(std::move(root_session));
	root_resources_ = std::make_unique<ResourceGraph>(std::move(root_resources));
	client_1_ = std::make_unique<SessionWrapper>(std::move(client_1));
	client_2_ = std::make_unique<SessionWrapper>(std::move(client_2));

	ClearEventsInAllSessions();
	}

	void TearDown() override {
	root_resources_ = nullptr;
	root_session_ = nullptr;
	client_1_ = nullptr;
	client_2_ = nullptr;
	InputSystemTest::TearDown();
	}

	std::unique_ptr<SessionWrapper> root_session_;
	std::unique_ptr<ResourceGraph> root_resources_;
	std::unique_ptr<SessionWrapper> client_1_;
	std::unique_ptr<SessionWrapper> client_2_;
	};

	// Class for testing if turning pointer auto focus off works.
	class NoFocusTransferTest : public FocusTransferTest {
	private:
	bool auto_focus_behavior() const override { return false; }
	};

	// Some tests require the presence of an accessibility listener to trigger pointer interception.
	class A11yListener : public fuchsia::ui::input::accessibility::PointerEventListener {
	public:
	A11yListener(scenic_impl::input::InputSystem* input_system) : listener_binding_(this) {
	input_system->RegisterA11yListener(listener_binding_.NewBinding(),
	[](bool success) { ASSERT_TRUE(success); });
	}

	private:
	// \|fuchsia::ui::input::accessibility::PointerEventListener\|
	// Simple response: always reject on MOVE event.
	void OnEvent(A11yPointerEvent event) override {
	if (event.phase() == PointerEventPhase::MOVE) {
	listener_binding_.events().OnStreamHandled(event.device_id(), event.pointer_id(),
	A11yStreamResponse::REJECTED);
	}
	}

	fidl::Binding<fuchsia::ui::input::accessibility::PointerEventListener> listener_binding_;
	};

	// Normally, focus gets transferred to a valid target on the DOWN phase.
	TEST_F(FocusTransferTest, TouchFocusWithValidTarget) {
	// Inject ADD/DOWN on client 2 to trigger focus dispatch.
	{
	scenic::Session* const session = root_session()->session();

	PointerCommandGenerator finger(root_resources()->compositor.id(), /device id/ 1,
	/pointer id/ 1, PointerEventType::TOUCH);
	session->Enqueue(finger.Add(7.5, 3.5));
	session->Enqueue(finger.Down(7.5, 3.5));
	}
	RunLoopUntilIdle();

	// Verify client 1 receives unfocus event.
	{
	const std::vector<InputEvent>& events = client_1()->events();
	ASSERT_EQ(events.size(), 1u);
	EXPECT_TRUE(events[0].is_focus());
	EXPECT_FALSE(events[0].focus().focused);
	}

	// Verify client 2 receives focus event.
	{
	const std::vector<InputEvent>& events = client_2()->events();
	ASSERT_EQ(events.size(), 3u);

	// ADD
	EXPECT_TRUE(events[0].is_pointer());
	EXPECT_TRUE(PointerMatches(events[0].pointer(), 1u, PointerEventPhase::ADD, 4.5, 0.5));

	// FOCUS
	EXPECT_TRUE(events[1].is_focus());
	EXPECT_TRUE(events[1].focus().focused);

	// DOWN
	EXPECT_TRUE(events[2].is_pointer());
	EXPECT_TRUE(PointerMatches(events[2].pointer(), 1u, PointerEventPhase::DOWN, 4.5, 0.5));
	}

	// Verify root session receives nothing.
	{
	const std::vector<InputEvent>& events = root_session()->events();
	EXPECT_EQ(events.size(), 0u);
	}
	}

	// Sometimes, focus does not have a valid target; instead, transfer focus to the root of the focus
	// chain, which is the Scene-creating session in GFX.
	TEST_F(FocusTransferTest, TouchFocusWithInvalidTarget) {
	// Inject ADD/DOWN outside of clients to trigger focus dispatch.
	{
	scenic::Session* const session = root_session()->session();

	PointerCommandGenerator finger(root_resources()->compositor.id(), /device id/ 1,
	/pointer id/ 1, PointerEventType::TOUCH);
	session->Enqueue(finger.Add(7.5, 2.5));
	session->Enqueue(finger.Down(7.5, 2.5));
	}
	RunLoopUntilIdle();

	// Verify client 1 receives unfocus event.
	{
	const std::vector<InputEvent>& events = client_1()->events();
	ASSERT_EQ(events.size(), 1u);

	EXPECT_TRUE(events[0].is_focus());
	EXPECT_FALSE(events[0].focus().focused);
	}

	// Verify client 2 receives nothing, since nothing was hit.
	{
	const std::vector<InputEvent>& events = client_2()->events();
	EXPECT_EQ(events.size(), 0u);
	}

	// Verify root session receives focus event, since we revert to root of focus chain.
	{
	const std::vector<InputEvent>& events = root_session()->events();
	ASSERT_EQ(events.size(), 1u);

	EXPECT_TRUE(events[0].is_focus());
	EXPECT_TRUE(events[0].focus().focused);
	}
	}

	// When a valid but unfocused target (client 2) receives an ADD event and DOWN event, and then the
	// scene disconnects, the target receives an unfocus event (where focus=false).
	TEST_F(FocusTransferTest, TouchFocusDisconnectSceneAfterDown) {
	// Inject ADD/DOWN on client 2 to trigger focus dispatch.
	{
	scenic::Session* const session = root_session()->session();

	PointerCommandGenerator finger(root_resources()->compositor.id(), /device id/ 1,
	/pointer id/ 1, PointerEventType::TOUCH);
	session->Enqueue(finger.Add(7.5, 3.5));
	session->Enqueue(finger.Down(7.5, 3.5));
	}
	RunLoopUntilIdle();

	ClearEventsInAllSessions();

	// Disconnect scene from compositor.
	{
	scenic::Session* const session = root_session()->session();

	scenic::LayerStack alternate_layer_stack(session);
	root_resources()->compositor.SetLayerStack(alternate_layer_stack);
	RequestToPresent(session);
	}

	// Verify client 2 receives unfocus event.
	{
	const std::vector<InputEvent>& events = client_2()->events();
	ASSERT_EQ(events.size(), 1u);

	// FOCUS
	EXPECT_TRUE(events[0].is_focus());
	EXPECT_FALSE(events[0].focus().focused);
	}

	// Verify client 1 receives nothing.
	{
	const std::vector<InputEvent>& events = client_1()->events();
	EXPECT_EQ(events.size(), 0u);
	}

	// Verify root session receives nothing.
	{
	const std::vector<InputEvent>& events = root_session()->events();
	EXPECT_EQ(events.size(), 0u);
	}
	}

	// Ensure TouchFocusWithValidTarget works after accessibility rejects the pointer stream.
	TEST_F(FocusTransferTest, TouchFocusWithValidTargetAfterA11yRejects) {
	A11yListener a11y_listener(input_system()); // Turn on accessibility interception.
	RunLoopUntilIdle(); // Ensure FIDL calls get processed.

	// Inject ADD/DOWN on client 2 to trigger delayed focus dispatch.
	{
	scenic::Session* const session = root_session()->session();

	PointerCommandGenerator finger(root_resources()->compositor.id(), /device id/ 1,
	/pointer id/ 1, PointerEventType::TOUCH);
	session->Enqueue(finger.Add(7.5, 3.5));
	session->Enqueue(finger.Down(7.5, 3.5));
	}
	RunLoopUntilIdle();

	// Ordinary clients should not see focus events.
	EXPECT_EQ(client_1()->events().size(), 0u);
	EXPECT_EQ(client_2()->events().size(), 0u);
	EXPECT_EQ(root_session()->events().size(), 0u);

	// Inject MOVE to trigger a11y rejection.
	// Inject ADD/DOWN on client 2 to trigger delayed focus dispatch.
	{
	scenic::Session* const session = root_session()->session();

	PointerCommandGenerator finger(root_resources()->compositor.id(), /device id/ 1,
	/pointer id/ 1, PointerEventType::TOUCH);
	session->Enqueue(finger.Move(7.5, 3.5));
	}
	RunLoopUntilIdle();

	// A11y rejection of MOVE should cause event dispatch to ordinary clients.

	// Verify client 1 receives unfocus event.
	{
	const std::vector<InputEvent>& events = client_1()->events();
	ASSERT_EQ(events.size(), 1u);

	// FOCUS
	EXPECT_TRUE(events[0].is_focus());
	EXPECT_FALSE(events[0].focus().focused);
	}

	// Verify client 2 receives focus event.
	{
	const std::vector<InputEvent>& events = client_2()->events();
	ASSERT_EQ(events.size(), 4u);

	// ADD
	EXPECT_TRUE(events[0].is_pointer());
	EXPECT_TRUE(PointerMatches(events[0].pointer(), 1u, PointerEventPhase::ADD, 4.5, 0.5));

	// FOCUS
	EXPECT_TRUE(events[1].is_focus());
	EXPECT_TRUE(events[1].focus().focused);

	// DOWN
	EXPECT_TRUE(events[2].is_pointer());
	EXPECT_TRUE(PointerMatches(events[2].pointer(), 1u, PointerEventPhase::DOWN, 4.5, 0.5));

	// MOVE
	EXPECT_TRUE(events[3].is_pointer());
	EXPECT_TRUE(PointerMatches(events[3].pointer(), 1u, PointerEventPhase::MOVE, 4.5, 0.5));
	}

	// Verify root session receives nothing.
	{
	const std::vector<InputEvent>& events = root_session()->events();
	EXPECT_EQ(events.size(), 0u);
	}
	}

	// Ensure TouchFocusWithInvalidTarget works after accessibility rejects the pointer stream.
	TEST_F(FocusTransferTest, TouchFocusWithInvalidTargetAfterA11yRejects) {
	A11yListener a11y_listener(input_system()); // Turn on accessibility interception.
	RunLoopUntilIdle(); // Ensure FIDL calls get processed.

	// Inject ADD, DOWN, and MOVE (the MOVE triggers a11y rejection).
	{
	scenic::Session* const session = root_session()->session();

	PointerCommandGenerator finger(root_resources()->compositor.id(), /device id/ 1,
	/pointer id/ 1, PointerEventType::TOUCH);
	session->Enqueue(finger.Add(7, 2));
	session->Enqueue(finger.Down(7, 2));
	session->Enqueue(finger.Move(7, 2));
	}
	RunLoopUntilIdle();

	// A11y rejection of MOVE should cause focus event dispatch to ordinary clients.
	// However, there was no latch on DOWN, so nothing should see pointer events.

	// Verify client 1 receives unfocus event.
	{
	const std::vector<InputEvent>& events = client_1()->events();
	ASSERT_EQ(events.size(), 1u);

	// FOCUS
	EXPECT_TRUE(events[0].is_focus());
	EXPECT_FALSE(events[0].focus().focused);
	}

	// Verify client 2 receives nothing, since nothing was hit.
	{
	const std::vector<InputEvent>& events = client_2()->events();
	EXPECT_EQ(events.size(), 0u);
	}

	// Verify root session receives focus event, since we revert to root of focus chain.
	{
	const std::vector<InputEvent>& events = root_session()->events();
	ASSERT_EQ(events.size(), 1u);

	// FOCUS
	EXPECT_TRUE(events[0].is_focus());
	EXPECT_TRUE(events[0].focus().focused);
	}
	}

	// Normally, focus gets transferred to a valid target on the DOWN phase.
	TEST_F(FocusTransferTest, MouseFocusWithValidTarget) {
	// Inject ADD/DOWN on client 2 to trigger delayed focus dispatch.
	{
	scenic::Session* const session = root_session()->session();

	PointerCommandGenerator finger(root_resources()->compositor.id(), /device id/ 1,
	/pointer id/ 1, PointerEventType::MOUSE);
	session->Enqueue(finger.Move(7.5, 3.5));
	session->Enqueue(finger.Down(7.5, 3.5));
	}
	RunLoopUntilIdle();

	// Verify client 1 receives unfocus event.
	{
	const std::vector<InputEvent>& events = client_1()->events();
	ASSERT_EQ(events.size(), 1u);

	// FOCUS
	EXPECT_TRUE(events[0].is_focus());
	EXPECT_FALSE(events[0].focus().focused);
	}

	// Verify client 2 receives focus event.
	{
	const std::vector<InputEvent>& events = client_2()->events();
	ASSERT_EQ(events.size(), 3u);

	// MOVE
	EXPECT_TRUE(events[0].is_pointer());
	EXPECT_TRUE(PointerMatches(events[0].pointer(), 1u, PointerEventPhase::MOVE, 4.5, 0.5,
	fuchsia::ui::input::PointerEventType::MOUSE));

	// FOCUS
	EXPECT_TRUE(events[1].is_focus());
	EXPECT_TRUE(events[1].focus().focused);

	// DOWN
	EXPECT_TRUE(events[2].is_pointer());
	EXPECT_TRUE(PointerMatches(events[2].pointer(), 1u, PointerEventPhase::DOWN, 4.5, 0.5,
	fuchsia::ui::input::PointerEventType::MOUSE));
	}

	// Verify root session receives nothing.
	{
	const std::vector<InputEvent>& events = root_session()->events();
	EXPECT_EQ(events.size(), 0u);
	}
	}

	// Sometimes, focus does not have a valid target; instead, transfer focus to the root of the focus
	// chain, which is the Scene-creating session in GFX.
	TEST_F(FocusTransferTest, MouseFocusWithInvalidTarget) {
	// Inject ADD/DOWN outside of clients to trigger focus dispatch.
	{
	scenic::Session* const session = root_session()->session();

	PointerCommandGenerator finger(root_resources()->compositor.id(), /device id/ 1,
	/pointer id/ 1, PointerEventType::MOUSE);
	session->Enqueue(finger.Move(7, 2));
	session->Enqueue(finger.Down(7, 2));
	}
	RunLoopUntilIdle();

	// Verify client 1 receives unfocus event.
	{
	const std::vector<InputEvent>& events = client_1()->events();
	ASSERT_EQ(events.size(), 1u) << "Should receive exactly 1 input event.";

	// FOCUS
	EXPECT_TRUE(events[0].is_focus());
	EXPECT_FALSE(events[0].focus().focused);
	}

	// Verify client 2 receives nothing, since nothing was hit.
	{
	const std::vector<InputEvent>& events = client_2()->events();
	EXPECT_EQ(events.size(), 0u) << "Should receive exactly 0 input events.";
	}

	// Verify root session receives focus event, since we revert to root of focus chain.
	{
	const std::vector<InputEvent>& events = root_session()->events();
	ASSERT_EQ(events.size(), 1u) << "Should receive exactly 1 input event.";

	// FOCUS
	EXPECT_TRUE(events[0].is_focus());
	EXPECT_TRUE(events[0].focus().focused);
	}
	}

	TEST_F(NoFocusTransferTest, TouchFocusWithValidTarget) {
	// Inject ADD/DOWN on client 2 to trigger focus dispatch.
	{
	scenic::Session* const session = root_session()->session();

	PointerCommandGenerator finger(root_resources()->compositor.id(), /device id/ 1,
	/pointer id/ 1, PointerEventType::TOUCH);
	session->Enqueue(finger.Add(7.5, 3.5));
	session->Enqueue(finger.Down(7.5, 3.5));
	}
	RunLoopUntilIdle();

	// Verify no client receives focus events.
	EXPECT_TRUE(client_1()->events().empty());
	{
	const std::vector<InputEvent>& events = client_2()->events();
	ASSERT_EQ(events.size(), 2u);
	EXPECT_TRUE(events[0].is_pointer());
	EXPECT_TRUE(events[1].is_pointer());
	}
	}

	TEST_F(NoFocusTransferTest, MouseFocusWithValidTarget) {
	// Inject ADD/DOWN on client 2 and observe no focus dispatch.
	{
	scenic::Session* const session = root_session()->session();

	PointerCommandGenerator finger(root_resources()->compositor.id(), /device id/ 1,
	/pointer id/ 1, PointerEventType::MOUSE);
	session->Enqueue(finger.Move(7.5, 3.5));
	session->Enqueue(finger.Down(7.5, 3.5));
	}
	RunLoopUntilIdle();

	// Verify no client receives focus events.
	EXPECT_TRUE(client_1()->events().empty());
	{
	const std::vector<InputEvent>& events = client_2()->events();
	ASSERT_EQ(events.size(), 2u);
	EXPECT_TRUE(events[0].is_pointer());
	EXPECT_TRUE(events[1].is_pointer());
	}
	}

	} // namespace src_ui_scenic_lib_input_tests