[fuchsia] Add WebEngine browser-test for document visibilityState.

Add browser-test to verify that the document.visibilityState is set to
"hidden" when a web.Frame is created.

Also clean up FrameImpl::set_semantics_manager_for_test() not to require
a fidl::InterfacePtr<>, to simplify the calling tests.

Bug: 1109270
Change-Id: Ief6acc4aacb2e97d64896d30b75d2a3cf2cb9b98
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2355924
Auto-Submit: Wez <wez@chromium.org>
Commit-Queue: Sergey Ulanov <sergeyu@chromium.org>
Reviewed-by: Sergey Ulanov <sergeyu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#798561}

fuchsia/engine/browser/accessibility_bridge.cc

@@ -27,7 +27,7 @@ constexpr float kRectConversionError = 0.5;
 }  // namespace
 
 AccessibilityBridge::AccessibilityBridge(
-    fuchsia::accessibility::semantics::SemanticsManagerPtr semantics_manager,
+    fuchsia::accessibility::semantics::SemanticsManager* semantics_manager,
     fuchsia::ui::views::ViewRef view_ref,
     content::WebContents* web_contents,
     base::OnceCallback<void(zx_status_t)> on_error_callback)

fuchsia/engine/browser/accessibility_bridge.h

@@ -38,9 +38,10 @@ class WEB_ENGINE_EXPORT AccessibilityBridge
       public fuchsia::accessibility::semantics::SemanticListener,
       public ui::AXTreeObserver {
  public:
+  // |semantics_manager| is used during construction to register the instance.
   // |web_contents| is required to exist for the duration of |this|.
   AccessibilityBridge(
-      fuchsia::accessibility::semantics::SemanticsManagerPtr semantics_manager,
+      fuchsia::accessibility::semantics::SemanticsManager* semantics_manager,
       fuchsia::ui::views::ViewRef view_ref,
       content::WebContents* web_contents,
       base::OnceCallback<void(zx_status_t)> on_error_callback);

fuchsia/engine/browser/accessibility_bridge_browsertest.cc

@@ -45,7 +45,7 @@ fuchsia::math::PointF GetCenterOfBox(fuchsia::ui::gfx::BoundingBox box) {
 
 class AccessibilityBridgeTest : public cr_fuchsia::WebEngineBrowserTest {
  public:
-  AccessibilityBridgeTest() : semantics_manager_binding_(&semantics_manager_) {
+  AccessibilityBridgeTest() {
     cr_fuchsia::WebEngineBrowserTest::set_test_server_root(
         base::FilePath(cr_fuchsia::kTestServerRoot));
   }
@@ -64,15 +64,10 @@ class AccessibilityBridgeTest : public cr_fuchsia::WebEngineBrowserTest {
   }
 
   void SetUpOnMainThread() override {
-    fuchsia::accessibility::semantics::SemanticsManagerPtr
-        semantics_manager_ptr;
-    semantics_manager_binding_.Bind(semantics_manager_ptr.NewRequest());
-
     frame_ptr_ =
         cr_fuchsia::WebEngineBrowserTest::CreateFrame(&navigation_listener_);
     frame_impl_ = context_impl()->GetFrameImplForTest(&frame_ptr_);
-    frame_impl_->set_semantics_manager_for_test(
-        std::move(semantics_manager_ptr));
+    frame_impl_->set_semantics_manager_for_test(&semantics_manager_);
     frame_ptr_->EnableHeadlessRendering();
 
     semantics_manager_.WaitUntilViewRegistered();
@@ -88,8 +83,6 @@ class AccessibilityBridgeTest : public cr_fuchsia::WebEngineBrowserTest {
   fuchsia::web::FramePtr frame_ptr_;
   FrameImpl* frame_impl_;
   FakeSemanticsManager semantics_manager_;
-  fidl::Binding<fuchsia::accessibility::semantics::SemanticsManager>
-      semantics_manager_binding_;
   cr_fuchsia::TestNavigationListener navigation_listener_;
   fuchsia::web::NavigationControllerPtr navigation_controller_;
 };

fuchsia/engine/browser/frame_impl.cc

@@ -552,19 +552,20 @@ void FrameImpl::CreateViewWithViewRef(
   view_ref_pair.view_ref = std::move(view_ref);
   InitWindowTreeHost(std::move(view_token), std::move(view_ref_pair));
 
-  fuchsia::accessibility::semantics::SemanticsManagerPtr semantics_manager =
-      semantics_manager_for_test_
-          ? std::move(semantics_manager_for_test_)
-          : base::ComponentContextForProcess()
-                ->svc()
-                ->Connect<
-                    fuchsia::accessibility::semantics::SemanticsManager>();
+  fuchsia::accessibility::semantics::SemanticsManagerPtr semantics_manager;
+  if (!semantics_manager_for_test_) {
+    semantics_manager =
+        base::ComponentContextForProcess()
+            ->svc()
+            ->Connect<fuchsia::accessibility::semantics::SemanticsManager>();
+  }
 
   // If the SemanticTree owned by |accessibility_bridge_| is disconnected, it
   // will cause |this| to be closed.
   accessibility_bridge_ = std::make_unique<AccessibilityBridge>(
-      std::move(semantics_manager), window_tree_host_->CreateViewRef(),
-      web_contents_.get(),
+      semantics_manager_for_test_ ? semantics_manager_for_test_
+                                  : semantics_manager.get(),
+      window_tree_host_->CreateViewRef(), web_contents_.get(),
       base::BindOnce(&FrameImpl::CloseAndDestroyFrame, base::Unretained(this)));
 }
 
@@ -768,8 +769,8 @@ void FrameImpl::EnableHeadlessRendering() {
   gfx::Rect bounds(kHeadlessWindowSize);
   if (semantics_manager_for_test_) {
     accessibility_bridge_ = std::make_unique<AccessibilityBridge>(
-        std::move(semantics_manager_for_test_),
-        window_tree_host_->CreateViewRef(), web_contents_.get(),
+        semantics_manager_for_test_, window_tree_host_->CreateViewRef(),
+        web_contents_.get(),
         base::BindOnce(&FrameImpl::CloseAndDestroyFrame,
                        base::Unretained(this)));
 

fuchsia/engine/browser/frame_impl.h

@@ -79,9 +79,8 @@ class FrameImpl : public fuchsia::web::Frame,
     return accessibility_bridge_.get();
   }
   void set_semantics_manager_for_test(
-      fuchsia::accessibility::semantics::SemanticsManagerPtr
-          semantics_manager) {
-    semantics_manager_for_test_ = std::move(semantics_manager);
+      fuchsia::accessibility::semantics::SemanticsManager* semantics_manager) {
+    semantics_manager_for_test_ = semantics_manager;
   }
   CastStreamingSessionClient* cast_streaming_session_client_for_test() {
     return cast_streaming_session_client_.get();
@@ -246,7 +245,7 @@ class FrameImpl : public fuchsia::web::Frame,
   FrameLayoutManager* layout_manager_ = nullptr;
 
   std::unique_ptr<AccessibilityBridge> accessibility_bridge_;
-  fuchsia::accessibility::semantics::SemanticsManagerPtr
+  fuchsia::accessibility::semantics::SemanticsManager*
       semantics_manager_for_test_;
 
   EventFilter event_filter_;

fuchsia/engine/browser/frame_impl_browsertest.cc

@@ -118,11 +118,47 @@ class FrameImplTest : public cr_fuchsia::WebEngineBrowserTest {
     return WebEngineBrowserTest::CreateFrame(&navigation_listener_);
   }
 
+  // Dummy SemanticsManager to satisfy tests that call CreateView().
+  FakeSemanticsManager fake_semantics_manager_;
+
   cr_fuchsia::TestNavigationListener navigation_listener_;
 
   DISALLOW_COPY_AND_ASSIGN(FrameImplTest);
 };
 
+std::string GetDocumentVisibilityState(fuchsia::web::Frame* frame) {
+  auto visibility = base::MakeRefCounted<base::RefCountedData<std::string>>();
+  base::RunLoop loop;
+  frame->ExecuteJavaScript(
+      {"*"},
+      cr_fuchsia::MemBufferFromString("document.visibilityState;", "test"),
+      [visibility, quit_loop = loop.QuitClosure()](
+          fuchsia::web::Frame_ExecuteJavaScript_Result result) {
+        ASSERT_TRUE(result.is_response());
+        visibility->data = StringFromMemBufferOrDie(result.response().result);
+        quit_loop.Run();
+      });
+  loop.Run();
+  return visibility->data;
+}
+
+// Verifies that Frames are initially "hidden".
+IN_PROC_BROWSER_TEST_F(FrameImplTest, VisibilityState) {
+  fuchsia::web::FramePtr frame = CreateFrame();
+
+  fuchsia::web::NavigationControllerPtr controller;
+  frame->GetNavigationController(controller.NewRequest());
+
+  // Navigate to a page and wait for it to finish loading.
+  ASSERT_TRUE(cr_fuchsia::LoadUrlAndExpectResponse(
+      controller.get(), fuchsia::web::LoadUrlParams(), url::kAboutBlankURL));
+  navigation_listener_.RunUntilUrlAndTitleEquals(GURL(url::kAboutBlankURL),
+                                                 url::kAboutBlankURL);
+
+  // Query the document.visibilityState before creating a View.
+  EXPECT_EQ(GetDocumentVisibilityState(frame.get()), "\"hidden\"");
+}
+
 void VerifyCanGoBackAndForward(fuchsia::web::NavigationController* controller,
                                bool can_go_back_expected,
                                bool can_go_forward_expected) {
@@ -240,20 +276,13 @@ IN_PROC_BROWSER_TEST_F(FrameImplTest, ContextDeletedBeforeFrameWithView) {
   EXPECT_TRUE(frame);
   FrameImpl* frame_impl = context_impl()->GetFrameImplForTest(&frame);
 
-  // Sets up a FakeSemanticsManager to be used when an AccessibilityBridge is
-  // created. This prevents the remote handle from being dropped, which causes
-  // the Frame to be torn down.
-  FakeSemanticsManager semantics_manager;
-  fidl::Binding<fuchsia::accessibility::semantics::SemanticsManager>
-      semantics_manager_binding(&semantics_manager);
-  fuchsia::accessibility::semantics::SemanticsManagerPtr semantics_manager_ptr;
-  semantics_manager_binding.Bind(semantics_manager_ptr.NewRequest());
-  frame_impl->set_semantics_manager_for_test(std::move(semantics_manager_ptr));
+  // CreateView() will cause the AccessibilityBridge to be created.
+  frame_impl->set_semantics_manager_for_test(&fake_semantics_manager_);
 
   auto view_tokens = scenic::ViewTokenPair::New();
-
   frame->CreateView(std::move(view_tokens.view_token));
   base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(frame_impl->has_view_for_test());
 
   base::RunLoop run_loop;
   frame.set_error_handler([&run_loop](zx_status_t status) {
@@ -1481,19 +1510,12 @@ IN_PROC_BROWSER_TEST_F(FrameImplTest, RecreateView) {
   ASSERT_TRUE(frame_impl);
   EXPECT_FALSE(frame_impl->has_view_for_test());
 
+  // CreateView() will cause the AccessibilityBridge to be created.
+  frame_impl->set_semantics_manager_for_test(&fake_semantics_manager_);
+
   fuchsia::web::NavigationControllerPtr controller;
   frame->GetNavigationController(controller.NewRequest());
 
-  // Sets up a FakeSemanticsManager to be used when an AccessibilityBridge is
-  // created. This prevents the remote handle from being dropped, which causes
-  // the Frame to be torn down.
-  FakeSemanticsManager semantics_manager;
-  fidl::Binding<fuchsia::accessibility::semantics::SemanticsManager>
-      semantics_manager_binding(&semantics_manager);
-  fuchsia::accessibility::semantics::SemanticsManagerPtr semantics_manager_ptr;
-  semantics_manager_binding.Bind(semantics_manager_ptr.NewRequest());
-  frame_impl->set_semantics_manager_for_test(std::move(semantics_manager_ptr));
-
   // Verify that the Frame can navigate, prior to the View being created.
   const GURL page1_url(embedded_test_server()->GetURL(kPage1Path));
   EXPECT_TRUE(cr_fuchsia::LoadUrlAndExpectResponse(
@@ -1501,11 +1523,8 @@ IN_PROC_BROWSER_TEST_F(FrameImplTest, RecreateView) {
   navigation_listener_.RunUntilUrlAndTitleEquals(page1_url, kPage1Title);
 
   // Request a View from the Frame, and pump the loop to process the request.
-  zx::eventpair owner_token, frame_token;
-  ASSERT_EQ(zx::eventpair::create(0, &owner_token, &frame_token), ZX_OK);
-  fuchsia::ui::views::ViewToken view_token;
-  view_token.value = std::move(frame_token);
-  frame->CreateView(std::move(view_token));
+  auto view_tokens = scenic::ViewTokenPair::New();
+  frame->CreateView(std::move(view_tokens.view_token));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(frame_impl->has_view_for_test());
 
@@ -1515,17 +1534,9 @@ IN_PROC_BROWSER_TEST_F(FrameImplTest, RecreateView) {
       controller.get(), fuchsia::web::LoadUrlParams(), page2_url.spec()));
   navigation_listener_.RunUntilUrlAndTitleEquals(page2_url, kPage2Title);
 
-  // Create another FakeSemanticsManager for a second call to CreateView.
-  fuchsia::accessibility::semantics::SemanticsManagerPtr semantics_manager_ptr2;
-  semantics_manager_binding.Bind(semantics_manager_ptr2.NewRequest());
-  frame_impl->set_semantics_manager_for_test(std::move(semantics_manager_ptr2));
-
   // Create new View tokens and request a new view.
-  zx::eventpair owner_token2, frame_token2;
-  ASSERT_EQ(zx::eventpair::create(0, &owner_token2, &frame_token2), ZX_OK);
-  fuchsia::ui::views::ViewToken view_token2;
-  view_token2.value = std::move(frame_token2);
-  frame->CreateView(std::move(view_token2));
+  auto view_tokens2 = scenic::ViewTokenPair::New();
+  frame->CreateView(std::move(view_tokens2.view_token));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(frame_impl->has_view_for_test());