Show splash screen when entering VR from a deep-link

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 19 matching lines @@
   MOCK_METHOD1(OnUnsupportedMode, void(UiUnsupportedMode mode));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockBrowserInterface);
 };
 
 std::set<UiElementDebugId> kElementsVisibleInBrowsing = {
     kContentQuad, kBackplane, kCeiling, kFloor, kUrlBar};
 std::set<UiElementDebugId> kElementsVisibleWithExitPrompt = {
     kExitPrompt, kExitPromptBackplane, kCeiling, kFloor};
+std::set<UiElementDebugId> kElementsVisibleForSplashScreen = {

[cjgrant, 2017/06/23 19:26:33]

If used in only one test, should be in the test, IMO.

[ymalik, 2017/06/25 20:27:14]

Done.

+    kSplashScreenIcon};
 
 }  // namespace
 
 class UiSceneManagerTest : public testing::Test {
  public:
   void SetUp() override { browser_ = base::MakeUnique<MockBrowserInterface>(); }
 
  protected:
   enum InCct : bool {
     kNotInCct = false,
@@ skipping 12 matching lines @@
 
   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, kNotAutopresented);
   }
 
   void MakeAutoPresentedManager() {
     scene_ = base::MakeUnique<UiScene>();
     manager_ = base::MakeUnique<UiSceneManager>(
-        browser_.get(), scene_.get(), kNotInCct, kInWebVr, kAutopresented);
+        browser_.get(), scene_.get(), kNotInCct, kNotInWebVr, kAutopresented);
   }
 
   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);
@@ skipping 28 matching lines @@
   EXPECT_TRUE(IsVisible(kWebVrTransientHttpSecurityWarning));
 
   manager_->SetWebVrSecureOrigin(true);
   EXPECT_FALSE(IsVisible(kWebVrPermanentHttpSecurityWarning));
   EXPECT_FALSE(IsVisible(kWebVrTransientHttpSecurityWarning));
 
   manager_->SetWebVrSecureOrigin(false);
   EXPECT_TRUE(IsVisible(kWebVrPermanentHttpSecurityWarning));
   EXPECT_TRUE(IsVisible(kWebVrTransientHttpSecurityWarning));
 
-  manager_->SetWebVrMode(false, false);
+  manager_->SetWebVrMode(false);
   EXPECT_FALSE(IsVisible(kWebVrPermanentHttpSecurityWarning));
   EXPECT_FALSE(IsVisible(kWebVrTransientHttpSecurityWarning));
 }
 
 TEST_F(UiSceneManagerTest, WebVrWarningsDoNotShowWhenInitiallyOutsideWebVr) {
   MakeManager(kNotInCct, kNotInWebVr);
 
   EXPECT_FALSE(IsVisible(kWebVrPermanentHttpSecurityWarning));
   EXPECT_FALSE(IsVisible(kWebVrTransientHttpSecurityWarning));
 
-  manager_->SetWebVrMode(true, false);
+  manager_->SetWebVrMode(true);
   EXPECT_TRUE(IsVisible(kWebVrPermanentHttpSecurityWarning));
   EXPECT_TRUE(IsVisible(kWebVrTransientHttpSecurityWarning));
 }
 
 TEST_F(UiSceneManagerTest, CloseButtonVisibleInCctFullscreen) {
   // Button should be visible in cct.
   MakeManager(kInCct, kNotInWebVr);
   EXPECT_TRUE(IsVisible(kCloseButton));
 
   // Button should not be visible when not in cct or fullscreen.
   MakeManager(kNotInCct, kNotInWebVr);
   EXPECT_FALSE(IsVisible(kCloseButton));
 
   // Button should be visible in fullscreen and hidden when leaving fullscreen.
   manager_->SetFullscreen(true);
   EXPECT_TRUE(IsVisible(kCloseButton));
   manager_->SetFullscreen(false);
   EXPECT_FALSE(IsVisible(kCloseButton));
 
   // Button should not be visible when in WebVR.
   MakeManager(kInCct, kInWebVr);
   EXPECT_FALSE(IsVisible(kCloseButton));
-  manager_->SetWebVrMode(false, false);
+  manager_->SetWebVrMode(false);
   EXPECT_TRUE(IsVisible(kCloseButton));
 
   // Button should be visible in Cct across transistions in fullscreen.
   MakeManager(kInCct, kNotInWebVr);
   EXPECT_TRUE(IsVisible(kCloseButton));
   manager_->SetFullscreen(true);
   EXPECT_TRUE(IsVisible(kCloseButton));
   manager_->SetFullscreen(false);
   EXPECT_TRUE(IsVisible(kCloseButton));
 }
@@ skipping 46 matching lines @@
   }
 
   manager_->SetIncognito(false);
 
   {
     SCOPED_TRACE("Exited Incognito");
     EXPECT_EQ(initial_background, scene_->GetWorldBackgroundColor());
   }
 }
 
-TEST_F(UiSceneManagerTest, WebVrAutopresentedInitially) {
+TEST_F(UiSceneManagerTest, WebVrAutopresented) {
   MakeAutoPresentedManager();
+
   manager_->SetWebVrSecureOrigin(true);
+
+  // Initially, we should only show the splash screen.
+  VerifyElementsVisible("Initial", kElementsVisibleForSplashScreen);
+
+  // Enter WebVR with autopresentation.
+  manager_->SetWebVrMode(true);
   VerifyElementsVisible("Autopresented",
                         std::set<UiElementDebugId>{kTransientUrlBar});
 }
-
-TEST_F(UiSceneManagerTest, WebVrAutopresented) {
-  MakeManager(kNotInCct, kNotInWebVr);
-
-  manager_->SetWebVrSecureOrigin(true);
-
-  // Initial state.
-  VerifyElementsVisible("Initial", kElementsVisibleInBrowsing);
-
-  // Enter WebVR with autopresentation.
-  manager_->SetWebVrMode(true, true);
-  VerifyElementsVisible("Autopresented",
-                        std::set<UiElementDebugId>{kTransientUrlBar});
-}
 
 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);
@@ skipping 64 matching lines @@
   VerifyElementsVisible("Elements hidden", std::set<UiElementDebugId>{});
 }
 
 TEST_F(UiSceneManagerTest, UiUpdateTransitionToWebVR) {
   MakeManager(kNotInCct, kNotInWebVr);
   manager_->SetAudioCapturingIndicator(true);
   manager_->SetVideoCapturingIndicator(true);
   manager_->SetScreenCapturingIndicator(true);
 
   // Transition to WebVR mode
-  manager_->SetWebVrMode(true, false);
+  manager_->SetWebVrMode(true);
   manager_->SetWebVrSecureOrigin(true);
 
   // All elements should be hidden.
   VerifyElementsVisible("Elements hidden", std::set<UiElementDebugId>{});
 }
 
 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);
   manager_->SetScreenCapturingIndicator(true);
 
   EXPECT_TRUE(IsVisible(kAudioCaptureIndicator));
   EXPECT_TRUE(IsVisible(kVideoCaptureIndicator));
   EXPECT_TRUE(IsVisible(kScreenCaptureIndicator));
 
-  manager_->SetWebVrMode(true, false);
+  manager_->SetWebVrMode(true);
   EXPECT_FALSE(IsVisible(kAudioCaptureIndicator));
   EXPECT_FALSE(IsVisible(kVideoCaptureIndicator));
   EXPECT_FALSE(IsVisible(kScreenCaptureIndicator));
 
-  manager_->SetWebVrMode(false, false);
+  manager_->SetWebVrMode(false);
   EXPECT_TRUE(IsVisible(kAudioCaptureIndicator));
   EXPECT_TRUE(IsVisible(kVideoCaptureIndicator));
   EXPECT_TRUE(IsVisible(kScreenCaptureIndicator));
 
   manager_->SetAudioCapturingIndicator(false);
   manager_->SetVideoCapturingIndicator(false);
   manager_->SetScreenCapturingIndicator(false);
 
   EXPECT_FALSE(IsVisible(kAudioCaptureIndicator));
   EXPECT_FALSE(IsVisible(kVideoCaptureIndicator));
   EXPECT_FALSE(IsVisible(kScreenCaptureIndicator));
 }
 }  // namespace vr_shell