[vr] Close exit prompt when clicking on background

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/memory/ptr_util.h"
 #include "base/test/scoped_task_environment.h"
 #include "chrome/browser/android/vr_shell/ui_browser_interface.h"
@@ skipping 17 matching lines @@
   MOCK_METHOD0(NavigateBack, void());
   MOCK_METHOD0(ExitCct, void());
   MOCK_METHOD1(OnUnsupportedMode, void(UiUnsupportedMode mode));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockBrowserInterface);
 };
 
 std::set<UiElementDebugId> kElementsVisibleInBrowsing = {
     kContentQuad, kBackplane, kCeiling, kFloor, kUrlBar, kLoadingIndicator};
+std::set<UiElementDebugId> kElementsVisibleWithExitPrompt = {
+    kExitPrompt, kExitPromptBackplane, kCeiling, kFloor};
 
 }  // namespace
 
 class UiSceneManagerTest : public testing::Test {
  public:
   void SetUp() override { browser_ = base::MakeUnique<MockBrowserInterface>(); }
 
  protected:
   enum InCct : bool {
     kNotInCct = false,
     kInCct = true,
   };
 
   enum InWebVr : bool {
     kNotInWebVr = false,
     kInWebVr = true,
   };
 
   void MakeManager(InCct in_cct, InWebVr in_web_vr) {
     scene_ = base::MakeUnique<UiScene>();
     manager_ = base::MakeUnique<UiSceneManager>(browser_.get(), scene_.get(),
                                                 in_cct, in_web_vr);
   }
 
   bool IsVisible(UiElementDebugId debug_id) {
     UiElement* element = scene_->GetUiElementByDebugId(debug_id);
     return element ? element->visible() : false;
   }
 
+  void VerifyElementsVisible(const std::string& debug_name,
+                             const std::set<UiElementDebugId>& elements) {
+    SCOPED_TRACE(debug_name);
+    for (const auto& element : scene_->GetUiElements()) {
+      SCOPED_TRACE(element->debug_id());
+      bool should_be_visible =
+          elements.find(element->debug_id()) != elements.end();
+      EXPECT_EQ(should_be_visible, element->visible());
+    }
+  }
+
   base::test::ScopedTaskEnvironment scoped_task_environment_;
   std::unique_ptr<MockBrowserInterface> browser_;
   std::unique_ptr<UiScene> scene_;
   std::unique_ptr<UiSceneManager> manager_;
 };
 
 TEST_F(UiSceneManagerTest, ExitPresentAndFullscreenOnAppButtonClick) {
   MakeManager(kNotInCct, kInWebVr);
 
   // Clicking app button should trigger to exit presentation.
@@ skipping 119 matching lines @@
 }
 
 TEST_F(UiSceneManagerTest, UiUpdatesForFullscreenChanges) {
   std::set<UiElementDebugId> visible_in_fullscreen = {
       kContentQuad, kCloseButton, kBackplane, kCeiling, kFloor};
 
   MakeManager(kNotInCct, kNotInWebVr);
 
   // Hold onto the background color to make sure it changes.
   SkColor initial_background = scene_->GetWorldBackgroundColor();
+  VerifyElementsVisible("Initial", kElementsVisibleInBrowsing);
 
-  for (const auto& element : scene_->GetUiElements()) {
-    SCOPED_TRACE(element->debug_id());
-    bool should_be_visible =
-        kElementsVisibleInBrowsing.find(element->debug_id()) !=
-        kElementsVisibleInBrowsing.end();
-    EXPECT_EQ(should_be_visible, element->visible());
-  }
-
-  // Transistion to fullscreen.
+  // In fullscreen mode, content elements should be visible, control elements
+  // should be hidden.
   manager_->SetFullscreen(true);
-
-  // Content elements should be visible, control elements should be hidden.
-  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();
-    EXPECT_EQ(should_be_visible, element->visible());
-  }
-
+  VerifyElementsVisible("In fullscreen", visible_in_fullscreen);
   {
     SCOPED_TRACE("Entered Fullsceen");
     // Make sure background has changed for fullscreen.
     EXPECT_NE(initial_background, scene_->GetWorldBackgroundColor());
   }
 
-  // Exit fullscreen.
+  // Everything should return to original state after leaving 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 =
-        kElementsVisibleInBrowsing.find(element->debug_id()) !=
-        kElementsVisibleInBrowsing.end();
-    EXPECT_EQ(should_be_visible, element->visible());
-  }
+  VerifyElementsVisible("Restore initial", kElementsVisibleInBrowsing);
   {
     SCOPED_TRACE("Exited Fullsceen");
     EXPECT_EQ(initial_background, scene_->GetWorldBackgroundColor());
   }
 }
 
 TEST_F(UiSceneManagerTest, UiUpdatesExitPrompt) {
-  std::set<UiElementDebugId> visible_when_prompting = {kExitPrompt, kBackplane,
-                                                       kCeiling, kFloor};
   MakeManager(kNotInCct, kNotInWebVr);
 
   manager_->SetWebVrSecureOrigin(true);
 
   // Initial state.
-  for (const auto& element : scene_->GetUiElements()) {
-    SCOPED_TRACE(element->debug_id());
-    bool should_be_visible =
-        kElementsVisibleInBrowsing.find(element->debug_id()) !=
-        kElementsVisibleInBrowsing.end();
-    EXPECT_EQ(should_be_visible, element->visible());
-  }
+  VerifyElementsVisible("Initial", kElementsVisibleInBrowsing);
 
   // Exit prompt visible state.
-  manager_->OnSecurityIconClicked();
-  for (const auto& element : scene_->GetUiElements()) {
-    SCOPED_TRACE(element->debug_id());
-    bool should_be_visible = visible_when_prompting.find(element->debug_id()) !=
-                             visible_when_prompting.end();
-    EXPECT_EQ(should_be_visible, element->visible());
-  }
+  manager_->OnSecurityIconClickedForTesting();
+  VerifyElementsVisible("Prompt visible", kElementsVisibleWithExitPrompt);
 
   // Back to initial state.
-  manager_->OnExitPromptPrimaryButtonClicked();
-  for (const auto& element : scene_->GetUiElements()) {
-    SCOPED_TRACE(element->debug_id());
-    bool should_be_visible =
-        kElementsVisibleInBrowsing.find(element->debug_id()) !=
-        kElementsVisibleInBrowsing.end();
-    EXPECT_EQ(should_be_visible, element->visible());
-  }
+  manager_->OnExitPromptPrimaryButtonClickedForTesting();
+  VerifyElementsVisible("Restore initial", kElementsVisibleInBrowsing);

[amp, 2017/06/07 17:18:41]

If we pass the same string to the scoped trace it won't be able to differentiate
which call it was from (this string looks like it is used on line 233 as well as
in another test below).

Alternatively just call the scoped_trace with the string directly here (instead
of passing it in) and then the scoped trace will output the line number where it
was called (which would tell you which test it was).

[amp, 2017/06/07 17:36:45]

Turns out the test that failed is already output, so duplication across tests is
fine (but within the same test would be hard to debug).

+}
+
+TEST_F(UiSceneManagerTest, BackplaneClickClosesExitPrompt) {
+  MakeManager(kNotInCct, kNotInWebVr);
+
+  manager_->SetWebVrSecureOrigin(true);
+
+  // Initial state.
+  VerifyElementsVisible("Initial", kElementsVisibleInBrowsing);
+
+  // Exit prompt visible state.
+  manager_->OnSecurityIconClickedForTesting();
+  VerifyElementsVisible("Prompt visble", kElementsVisibleWithExitPrompt);
+
+  // Back to initial state.
+  scene_->GetUiElementByDebugId(kExitPromptBackplane)
+      ->OnButtonUp(gfx::PointF());
+  VerifyElementsVisible("Restore initial", kElementsVisibleInBrowsing);
 }
 
 TEST_F(UiSceneManagerTest, UiUpdatesForWebVR) {
   MakeManager(kNotInCct, kInWebVr);
 
   manager_->SetWebVrSecureOrigin(true);
   manager_->SetAudioCapturingIndicator(true);
   manager_->SetVideoCapturingIndicator(true);
   manager_->SetScreenCapturingIndicator(true);
 
   // All elements should be hidden.
-  for (const auto& element : scene_->GetUiElements()) {
-    SCOPED_TRACE(element->debug_id());
-    EXPECT_FALSE(element->visible());
-  }
+  VerifyElementsVisible("Elements hidden", {});
 }
 
 TEST_F(UiSceneManagerTest, UiUpdateTransitionToWebVR) {
   MakeManager(kNotInCct, kNotInWebVr);
   manager_->SetAudioCapturingIndicator(true);
   manager_->SetVideoCapturingIndicator(true);
   manager_->SetScreenCapturingIndicator(true);
 
   // Transition to WebVR mode
   manager_->SetWebVrMode(true);
   manager_->SetWebVrSecureOrigin(true);
 
   // All elements should be hidden.
-  for (const auto& element : scene_->GetUiElements()) {
-    SCOPED_TRACE(element->debug_id());
-    EXPECT_FALSE(element->visible());
-  }
+  VerifyElementsVisible("Elements hidden", {});
 }
 
 TEST_F(UiSceneManagerTest, CaptureIndicatorsVisibility) {
   MakeManager(kNotInCct, kNotInWebVr);
   EXPECT_FALSE(IsVisible(kAudioCaptureIndicator));
   EXPECT_FALSE(IsVisible(kVideoCaptureIndicator));
   EXPECT_FALSE(IsVisible(kScreenCaptureIndicator));
 
   manager_->SetAudioCapturingIndicator(true);
   manager_->SetVideoCapturingIndicator(true);
@@ skipping 15 matching lines @@
 
   manager_->SetAudioCapturingIndicator(false);
   manager_->SetVideoCapturingIndicator(false);
   manager_->SetScreenCapturingIndicator(false);
 
   EXPECT_FALSE(IsVisible(kAudioCaptureIndicator));
   EXPECT_FALSE(IsVisible(kVideoCaptureIndicator));
   EXPECT_FALSE(IsVisible(kScreenCaptureIndicator));
 }
 }  // namespace vr_shell