VrShell: Add test for fullscreen transitions.

chrome/browser/android/vr_shell/ui_scene_manager_unittest.cc

 // Copyright 2017 The Chromium 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 "chrome/browser/android/vr_shell/ui_scene_manager.h"
 
 #include "base/macros.h"
 #include "base/test/scoped_task_environment.h"
 #include "chrome/browser/android/vr_shell/ui_elements/ui_element.h"
 #include "chrome/browser/android/vr_shell/ui_elements/ui_element_debug_id.h"
@@ skipping 65 matching lines @@
 
   bool IsVisible(UiElementDebugId debug_id) {
     UiElement* element = scene_->GetUiElementByDebugId(debug_id);
     return element ? element->visible() : false;
   }
 
   base::test::ScopedTaskEnvironment scoped_task_environment_;
   std::unique_ptr<MockBrowserInterface> browser_;
   std::unique_ptr<UiScene> scene_;
   std::unique_ptr<UiSceneManager> manager_;
+
+  bool ColorEquals(vr::Colorf expected, vr::Colorf actual) {
+    return (expected.r == actual.r) && (expected.g == actual.g) &&
+           (expected.b == actual.b) && (expected.a == actual.a);
+  }
 };
 
 TEST_F(UiSceneManagerTest, ExitPresentAndFullscreenOnAppButtonClick) {
   MakeManager(kNotInCct, kInWebVr);
 
   // Clicking app button should trigger to exit presentation.
   EXPECT_CALL(*browser_, ExitPresent()).Times(1);
   // And also trigger exit fullscreen.
   EXPECT_CALL(*browser_, ExitFullscreen()).Times(1);
   manager_->OnAppButtonClicked();
@@ skipping 35 matching lines @@
 
   MakeManager(kNotInCct, kNotInWebVr);
   EXPECT_FALSE(IsVisible(kCloseButton));
 
   MakeManager(kInCct, kInWebVr);
   EXPECT_FALSE(IsVisible(kCloseButton));
   manager_->SetWebVrMode(false);
   EXPECT_TRUE(IsVisible(kCloseButton));
 }
 
+TEST_F(UiSceneManagerTest, UiUpdatesForFullscreenChanges) {
+  std::set<UiElementDebugId> visible_in_browsing = {
+      UiElementDebugId::kContentQuad, UiElementDebugId::kCeiling,
+      UiElementDebugId::kFloor,       UiElementDebugId::kGrid,
+      UiElementDebugId::kBrowserBar,  UiElementDebugId::kLoadingIndicator};
+  std::set<UiElementDebugId> visible_in_fullscreen = {
+      UiElementDebugId::kContentQuad};
+  std::set<UiElementDebugId> hidden_in_fullscreen = {
+      UiElementDebugId::kBrowserBar, UiElementDebugId::kLoadingIndicator};
+
+  MakeManager(kNotInCct, kNotInWebVr);
+
+  // Hold onto the background color to make sure it changes.
+  vr::Colorf initialBackground = scene_->GetBackgroundColor();

[cjgrant, 2017/05/23 18:58:11]

initial_background

[amp, 2017/05/23 20:56:02]

Done.

+
+  for (const auto& element : scene_->GetUiElements()) {
+    SCOPED_TRACE(element->debug_id());
+    bool should_be_visible = visible_in_browsing.find(element->debug_id()) !=
+                             visible_in_browsing.end();
+    // Ignore elements not in the set.
+    if (should_be_visible) {
+      EXPECT_EQ(should_be_visible, element->visible());
+    }
+  }
+
+  // Transistion to fullscreen.
+  manager_->SetFullscreen(true);
+
+  // All elements should be hidden except for main content.

[cjgrant, 2017/05/23 18:58:11]

Did we say the floor would stay visible in fullscreen?

[amp, 2017/05/23 20:56:02]

Yes, at the point this test was written it wasn't though.  I'll update the
comment in the latest cl where it is.

+  for (const auto& element : scene_->GetUiElements()) {
+    SCOPED_TRACE(element->debug_id());
+    bool should_be_visible = visible_in_fullscreen.find(element->debug_id()) !=
+                             visible_in_fullscreen.end();
+    // Ignore elements not in the set.

[cjgrant, 2017/05/23 18:58:11]

Since this test is focused on fullscreen, why ignore some elements?  Why not
assert that nothing other than the content quad is visible?  If someone adds
another element to fullscreen, they should update this test.  This would also
kill the need for "hidden_in_fullscreen".  Thoughts?

[amp, 2017/05/23 20:56:02]

I went this way because not every element has a debug id.  Multiple elements
could be under kNone and unless they are all supposed to be hidden it could be a
pain to enumerate them all (not to mention the tests won't be helpful in
explaining which element caused the problem).

I've updated the comments to better explain this, but let me know if you want to
fully enumerate all the elements so we don't need a check like this.

[cjgrant, 2017/05/23 21:27:31]

But in fullscreen, there are only a few things visible - the quad, floor,
ceiling and grid, right?  And, you've just assigned ids to each of those.  It
seems totally reasonable that if an element is going to be visible, that it have
a debug id.

Also, part of this test is making sure that stuff you don't want showing,
doesn't show.  If another element comes along, is accidentally visible in
fullscreen, but doesn't get added to the "hidden in fullscreen" set, this test
won't catch it, right?

+    if (should_be_visible) {
+      EXPECT_EQ(should_be_visible, element->visible());
+    }
+    bool should_be_hidden = hidden_in_fullscreen.find(element->debug_id()) !=
+                            hidden_in_fullscreen.end();
+    // Ignore elements not in the set.
+    if (should_be_hidden) {
+      EXPECT_FALSE(element->visible());
+    }
+  }
+
+  {
+    SCOPED_TRACE("Entered Fullsceen");
+    // Make sure background has changed for fullscreen.
+    EXPECT_FALSE(ColorEquals(initialBackground, scene_->GetBackgroundColor()));
+  }
+
+  // Exit fullscreen.
+  manager_->SetFullscreen(false);
+
+  // Everything should return to original state after leaving fullscreen.
+  for (const auto& element : scene_->GetUiElements()) {
+    SCOPED_TRACE(element->debug_id());
+    bool should_be_visible = visible_in_browsing.find(element->debug_id()) !=
+                             visible_in_browsing.end();
+    // Ignore elements not in the set.
+    if (should_be_visible) {
+      EXPECT_EQ(should_be_visible, element->visible());
+    }
+  }
+  {
+    SCOPED_TRACE("Exited Fullsceen");
+    EXPECT_TRUE(ColorEquals(initialBackground, scene_->GetBackgroundColor()));
+  }
+}
+
 }  // namespace vr_shell