Reland "[vr] Restore opacity when transient elements are shown again."

This is a reland of c1405389
Original change's description:
> [vr] Restore opacity when transient elements are shown again.
> 
> We'd previously set opacity to 0.0 when hiding elements in the
> transience manager which makes it tricky to see them when they come
> back. With this change, we inform the manager of the desired "opacity
> when visible" and it will restore elements to that opacity when
> shown again.
> 
> Bug: None
> Change-Id: I1a941c3032c35adab5afed17a8afc60bd41230f5
> Reviewed-on: https://chromium-review.googlesource.com/582069
> Commit-Queue: Ian Vollick <vollick@chromium.org>
> Reviewed-by: Christopher Grant <cjgrant@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#488788}

TBR=cjgrant@chromium.org

Bug: 747633
Change-Id: I340ed94f61f016243dc4495d687cab1d58ea2e67
Reviewed-on: https://chromium-review.googlesource.com/582529Reviewed-by: Ian Vollick <vollick@chromium.org>
Commit-Queue: Ian Vollick <vollick@chromium.org>
Cr-Commit-Position: refs/heads/master@{#488833}

chrome/browser/vr/elements/simple_textured_element.h

@@ -44,7 +44,8 @@ class TransientSimpleTexturedElement : public SimpleTexturedElement<T> {
  public:
   TransientSimpleTexturedElement(int maximum_width,
                                  const base::TimeDelta& timeout)
-      : SimpleTexturedElement<T>(maximum_width), transience_(this, timeout) {}
+      : SimpleTexturedElement<T>(maximum_width),
+        transience_(this, 1.0f, timeout) {}
 
   ~TransientSimpleTexturedElement() override {}
 

chrome/browser/vr/elements/transience_manager.cc

@@ -7,8 +7,11 @@
 namespace vr {
 
 TransienceManager::TransienceManager(UiElement* element,
+                                     float opacity_when_enabled,
                                      const base::TimeDelta& timeout)
-    : element_(element), timeout_(timeout) {
+    : element_(element),
+      opacity_when_enabled_(opacity_when_enabled),
+      timeout_(timeout) {
   element_->SetVisible(false);
 }
 
@@ -17,24 +20,24 @@ void TransienceManager::SetEnabled(bool enabled) {
     return;
   enabled_ = enabled;
   if (enabled) {
-    element_->SetVisible(true);
+    Show();
     StartTimer();
   } else {
-    element_->SetVisible(false);
+    Hide();
     visibility_timer_.Stop();
   }
 }
 
 void TransienceManager::KickVisibilityIfEnabled() {
   if (enabled_) {
-    element_->SetVisible(true);
+    Show();
     StartTimer();
   }
 }
 
 void TransienceManager::EndVisibilityIfEnabled() {
   if (enabled_) {
-    element_->SetVisible(false);
+    Hide();
     visibility_timer_.Stop();
   }
 }
@@ -46,6 +49,15 @@ void TransienceManager::StartTimer() {
 }
 
 void TransienceManager::OnTimeout() {
+  Hide();
+}
+
+void TransienceManager::Show() {
+  element_->SetVisible(true);
+  element_->SetOpacity(opacity_when_enabled_);
+}
+
+void TransienceManager::Hide() {
   element_->SetVisible(false);
   element_->SetOpacity(0);
 }

chrome/browser/vr/elements/transience_manager.h

@@ -15,7 +15,9 @@ namespace vr {
 
 class TransienceManager {
  public:
-  TransienceManager(UiElement* element, const base::TimeDelta& timeout);
+  TransienceManager(UiElement* element,
+                    float opacity_when_enabled,
+                    const base::TimeDelta& timeout);
   virtual ~TransienceManager() = default;
 
   void SetEnabled(bool enabled);
@@ -25,8 +27,11 @@ class TransienceManager {
  private:
   void StartTimer();
   void OnTimeout();
+  void Show();
+  void Hide();
 
   UiElement* element_;
+  float opacity_when_enabled_;
   base::TimeDelta timeout_;
   bool enabled_ = false;
   base::OneShotTimer visibility_timer_;

chrome/browser/vr/elements/transience_manager_unittest.cc

@@ -18,42 +18,57 @@ TEST(TransienceManager, Visibility) {
   base::ScopedMockTimeMessageLoopTaskRunner task_runner_;
 
   UiElement element;
+  float opacity_when_enabled = 0.8;
+  element.SetOpacity(0.0f);
 
-  TransienceManager transience(&element, base::TimeDelta::FromSeconds(10));
-  EXPECT_EQ(element.visible(), false);
+  TransienceManager transience(&element, opacity_when_enabled,
+                               base::TimeDelta::FromSeconds(10));
+  EXPECT_EQ(false, element.visible());
+  EXPECT_EQ(0.0f, element.opacity());
 
   transience.KickVisibilityIfEnabled();
-  EXPECT_EQ(element.visible(), false);
+  EXPECT_EQ(false, element.visible());
+  EXPECT_EQ(0.0f, element.opacity());
 
   // Enable and disable, making sure the element appears and disappears.
   transience.SetEnabled(true);
-  EXPECT_EQ(element.visible(), true);
+  EXPECT_EQ(true, element.visible());
+  EXPECT_EQ(opacity_when_enabled, element.opacity());
   transience.SetEnabled(false);
-  EXPECT_EQ(element.visible(), false);
+  EXPECT_EQ(false, element.visible());
+  EXPECT_EQ(0.0f, element.opacity());
 
   // Enable, and ensure that the element transiently disappears.
   transience.SetEnabled(true);
-  EXPECT_EQ(element.visible(), true);
+  EXPECT_EQ(true, element.visible());
+  EXPECT_EQ(opacity_when_enabled, element.opacity());
   task_runner_->FastForwardUntilNoTasksRemain();
-  EXPECT_EQ(element.visible(), false);
+  EXPECT_EQ(false, element.visible());
+  EXPECT_EQ(0.0f, element.opacity());
 
   // Kick visibility, and ensure that the element transiently disappears.
   transience.KickVisibilityIfEnabled();
-  EXPECT_EQ(element.visible(), true);
+  EXPECT_EQ(true, element.visible());
+  EXPECT_EQ(opacity_when_enabled, element.opacity());
   task_runner_->FastForwardUntilNoTasksRemain();
-  EXPECT_EQ(element.visible(), false);
+  EXPECT_EQ(false, element.visible());
+  EXPECT_EQ(0.0f, element.opacity());
 
   // Kick visibility, and ensure that ending visibility hides the element.
   transience.KickVisibilityIfEnabled();
-  EXPECT_EQ(element.visible(), true);
+  EXPECT_EQ(true, element.visible());
+  EXPECT_EQ(opacity_when_enabled, element.opacity());
   transience.EndVisibilityIfEnabled();
-  EXPECT_EQ(element.visible(), false);
+  EXPECT_EQ(false, element.visible());
+  EXPECT_EQ(0.0f, element.opacity());
 
   // Kick visibility, and ensure that disabling hides the element.
   transience.KickVisibilityIfEnabled();
-  EXPECT_EQ(element.visible(), true);
+  EXPECT_EQ(true, element.visible());
+  EXPECT_EQ(opacity_when_enabled, element.opacity());
   transience.SetEnabled(false);
-  EXPECT_EQ(element.visible(), false);
+  EXPECT_EQ(false, element.visible());
+  EXPECT_EQ(0.0f, element.opacity());
 }
 
 }  // namespace vr

chrome/browser/vr/elements/transient_url_bar.cc

@@ -19,7 +19,7 @@ TransientUrlBar::TransientUrlBar(
     const base::Callback<void(UiUnsupportedMode)>& failure_callback)
     : TexturedElement(preferred_width),
       texture_(base::MakeUnique<UrlBarTexture>(true, failure_callback)),
-      transience_(this, timeout) {}
+      transience_(this, 1.0f, timeout) {}
 
 TransientUrlBar::~TransientUrlBar() = default;