CrOS: Enable immersive fullscreen mode via window property

This makes us more consistent in how the ImmersiveFullscreenController
gets enabled. This patch also fixes the UMA for Chrome app windows.

Change-Id: Ib81d7401239cdcf42a415e81b01c29f3f378075c
Reviewed-on: https://chromium-review.googlesource.com/1207213Reviewed-by: Scott Violet <sky@chromium.org>
Commit-Queue: Evan Stade <estade@chromium.org>
Cr-Commit-Position: refs/heads/master@{#589662}

ash/frame/non_client_frame_view_ash_unittest.cc

@@ -768,7 +768,7 @@ TEST_F(NonClientFrameViewAshTest, WideFrame) {
   EXPECT_FALSE(wide_header_view->in_immersive_mode());
   EXPECT_FALSE(header_view->in_immersive_mode());
 
-  controller.SetEnabled(ImmersiveFullscreenController::WINDOW_TYPE_OTHER, true);
+  ImmersiveFullscreenController::EnableForWidget(widget.get(), true);
   EXPECT_TRUE(header_view->in_immersive_mode());
   EXPECT_TRUE(wide_header_view->in_immersive_mode());
   // The height should be ~(33 *.5)
@@ -794,8 +794,7 @@ TEST_F(NonClientFrameViewAshTest, WideFrame) {
   EXPECT_TRUE(ImmersiveFullscreenControllerTestApi(&controller)
                   .IsTopEdgeHoverTimerRunning());
 
-  controller.SetEnabled(ImmersiveFullscreenController::WINDOW_TYPE_OTHER,
-                        false);
+  ImmersiveFullscreenController::EnableForWidget(widget.get(), false);
   EXPECT_FALSE(header_view->in_immersive_mode());
   EXPECT_FALSE(wide_header_view->in_immersive_mode());
   // visible fraction should be ignored in non immersive.

ash/public/cpp/immersive/immersive_fullscreen_controller.cc

@@ -103,54 +103,6 @@ void ImmersiveFullscreenController::Init(
   EnableWindowObservers(true);
 }
 
-void ImmersiveFullscreenController::SetEnabled(WindowType window_type,
-                                               bool enabled) {
-  if (enabled_ == enabled)
-    return;
-  enabled_ = enabled;
-
-  EnableEventObservers(enabled_);
-
-  ImmersiveContext::Get()->OnEnteringOrExitingImmersive(this, enabled);
-
-  if (enabled_) {
-    // Animate enabling immersive mode by sliding out the top-of-window views.
-    // No animation occurs if a lock is holding the top-of-window views open.
-
-    // Do a reveal to set the initial state for the animation. (And any
-    // required state in case the animation cannot run because of a lock holding
-    // the top-of-window views open.)
-    MaybeStartReveal(ANIMATE_NO);
-
-    // Reset the located event so that it does not affect whether the
-    // top-of-window views are hidden.
-    located_event_revealed_lock_.reset();
-
-    // Try doing the animation.
-    MaybeEndReveal(ANIMATE_SLOW);
-
-    if (reveal_state_ == REVEALED) {
-      // Reveal was unsuccessful. Reacquire the revealed locks if appropriate.
-      UpdateLocatedEventRevealedLock();
-      if (immersive_focus_watcher_)
-        immersive_focus_watcher_->UpdateFocusRevealedLock();
-    }
-
-    delegate_->OnImmersiveFullscreenEntered();
-  } else {
-    // Stop cursor-at-top tracking.
-    top_edge_hover_timer_.Stop();
-    reveal_state_ = CLOSED;
-
-    delegate_->OnImmersiveFullscreenExited();
-  }
-
-  if (enabled_) {
-    UMA_HISTOGRAM_ENUMERATION("Ash.ImmersiveFullscreen.WindowType", window_type,
-                              WINDOW_TYPE_COUNT);
-  }
-}
-
 bool ImmersiveFullscreenController::IsEnabled() const {
   return enabled_;
 }
@@ -272,10 +224,8 @@ void ImmersiveFullscreenController::OnWindowPropertyChanged(
     aura::Window* window,
     const void* key,
     intptr_t old) {
-  if (key == kImmersiveIsActive) {
-    SetEnabled(ImmersiveFullscreenController::WINDOW_TYPE_OTHER,
-               window->GetProperty(kImmersiveIsActive));
-  }
+  if (key == kImmersiveIsActive)
+    UpdateEnabled();
 }
 
 void ImmersiveFullscreenController::OnWindowDestroying(aura::Window* window) {
@@ -391,11 +341,6 @@ void ImmersiveFullscreenController::EnableEventObservers(bool enable) {
   }
 }
 
-bool ImmersiveFullscreenController::IsTargetForWidget(
-    views::Widget* target) const {
-  return target == widget_ || target == top_container_->GetWidget();
-}
-
 void ImmersiveFullscreenController::UpdateTopEdgeHoverTimer(
     const ui::MouseEvent& event,
     const gfx::Point& location_in_screen,
@@ -720,4 +665,65 @@ gfx::Rect ImmersiveFullscreenController::GetDisplayBoundsInScreen() const {
   return ImmersiveContext::Get()->GetDisplayBoundsInScreen(widget_);
 }
 
+bool ImmersiveFullscreenController::IsTargetForWidget(
+    views::Widget* target) const {
+  return target == widget_ || target == top_container_->GetWidget();
+}
+
+void ImmersiveFullscreenController::UpdateEnabled() {
+  if (!widget_)
+    return;
+
+  const bool enabled =
+      widget_->GetNativeWindow()->GetProperty(kImmersiveIsActive);
+
+  if (enabled_ == enabled)
+    return;
+  enabled_ = enabled;
+
+  EnableEventObservers(enabled_);
+
+  ImmersiveContext::Get()->OnEnteringOrExitingImmersive(this, enabled);
+
+  if (enabled_) {
+    // Animate enabling immersive mode by sliding out the top-of-window views.
+    // No animation occurs if a lock is holding the top-of-window views open.
+
+    // Do a reveal to set the initial state for the animation. (And any
+    // required state in case the animation cannot run because of a lock holding
+    // the top-of-window views open.)
+    MaybeStartReveal(ANIMATE_NO);
+
+    // Reset the located event so that it does not affect whether the
+    // top-of-window views are hidden.
+    located_event_revealed_lock_.reset();
+
+    // Try doing the animation.
+    MaybeEndReveal(ANIMATE_SLOW);
+
+    if (reveal_state_ == REVEALED) {
+      // Reveal was unsuccessful. Reacquire the revealed locks if appropriate.
+      UpdateLocatedEventRevealedLock();
+      if (immersive_focus_watcher_)
+        immersive_focus_watcher_->UpdateFocusRevealedLock();
+    }
+
+    delegate_->OnImmersiveFullscreenEntered();
+  } else {
+    // Stop cursor-at-top tracking.
+    top_edge_hover_timer_.Stop();
+    reveal_state_ = CLOSED;
+
+    delegate_->OnImmersiveFullscreenExited();
+  }
+
+  if (enabled_) {
+    UMA_HISTOGRAM_ENUMERATION(
+        "Ash.ImmersiveFullscreen.WindowType",
+        static_cast<WindowType>(
+            widget_->GetNativeWindow()->GetProperty(kImmersiveWindowType)),
+        WINDOW_TYPE_COUNT);
+  }
+}
+
 }  // namespace ash

ash/public/cpp/immersive/immersive_fullscreen_controller.h

@@ -74,7 +74,7 @@ class ASH_PUBLIC_EXPORT ImmersiveFullscreenController
   ~ImmersiveFullscreenController() override;
 
   // Initializes the controller. Must be called prior to enabling immersive
-  // fullscreen via SetEnabled(). |top_container| is used to keep the
+  // fullscreen via EnableForWidget(). |top_container| is used to keep the
   // top-of-window views revealed when a child of |top_container| has focus.
   // |top_container| does not affect which mouse and touch events keep the
   // top-of-window views revealed. |widget| is the widget to make fullscreen.
@@ -82,13 +82,6 @@ class ASH_PUBLIC_EXPORT ImmersiveFullscreenController
             views::Widget* widget,
             views::View* top_container);
 
-  // Enables or disables immersive fullscreen.
-  // |window_type| is the type of window which is put in immersive fullscreen.
-  // It is only used for histogramming.
-  // TODO(estade): make clients use kImmersiveIsActive key and move this method
-  // to private.
-  void SetEnabled(WindowType window_type, bool enable);
-
   // Returns true if in immersive fullscreen.
   bool IsEnabled() const;
 
@@ -243,6 +236,10 @@ class ASH_PUBLIC_EXPORT ImmersiveFullscreenController
   // Test if the |widget| is the event target to control reveal state.
   bool IsTargetForWidget(views::Widget* widget) const;
 
+  // Enables or disables immersive fullscreen in accordance with the
+  // kImmersiveIsActive property.
+  void UpdateEnabled();
+
   // Not owned.
   ImmersiveFullscreenControllerDelegate* delegate_;
   views::View* top_container_;

ash/public/cpp/mus_property_mirror_ash.cc

@@ -117,6 +117,9 @@ void MusPropertyMirrorAsh::MirrorPropertyFromWidgetWindowToRootWindow(
   } else if (key == kImmersiveTopContainerBoundsInScreen) {
     MirrorOwnedProperty(window, root_window,
                         kImmersiveTopContainerBoundsInScreen);
+  } else if (key == kImmersiveWindowType) {
+    root_window->SetProperty(kImmersiveWindowType,
+                             window->GetProperty(kImmersiveWindowType));
   }
 }
 

ash/public/cpp/window_properties.cc

@@ -5,6 +5,7 @@
 #include "ash/public/cpp/window_properties.h"
 
 #include "ash/public/cpp/ash_constants.h"
+#include "ash/public/cpp/immersive/immersive_fullscreen_controller.h"
 #include "ash/public/cpp/shelf_types.h"
 #include "ash/public/cpp/window_pin_type.h"
 #include "ash/public/cpp/window_state_type.h"
@@ -172,6 +173,10 @@ DEFINE_UI_CLASS_PROPERTY_KEY(bool, kImmersiveIsActive, false);
 DEFINE_OWNED_UI_CLASS_PROPERTY_KEY(gfx::Rect,
                                    kImmersiveTopContainerBoundsInScreen,
                                    nullptr);
+DEFINE_UI_CLASS_PROPERTY_KEY(
+    int,
+    kImmersiveWindowType,
+    ImmersiveFullscreenController::WindowType::WINDOW_TYPE_OTHER);
 DEFINE_UI_CLASS_PROPERTY_KEY(bool,
                              kIsDeferredTabDraggingTargetWindowKey,
                              false);

ash/public/cpp/window_properties.h

@@ -134,6 +134,11 @@ ASH_PUBLIC_EXPORT extern const aura::WindowProperty<bool>* const
 ASH_PUBLIC_EXPORT extern const aura::WindowProperty<gfx::Rect*>* const
     kImmersiveTopContainerBoundsInScreen;
 
+// The type of window for logging immersive metrics. Type:
+// ImmersiveFullscreenController::WindowType.
+ASH_PUBLIC_EXPORT extern const aura::WindowProperty<int>* const
+    kImmersiveWindowType;
+
 // If true, the window is the target window for the tab-dragged window. The key
 // is used by overview to show a highlight indication to indicate which overview
 // window the dragged tabs will merge into when the user releases the pointer.

ash/wm/immersive_fullscreen_controller_unittest.cc

@@ -193,8 +193,7 @@ class ImmersiveFullscreenControllerTest : public AshTestBase {
 
   // Enables / disables immersive fullscreen.
   void SetEnabled(bool enabled) {
-    controller_->SetEnabled(ImmersiveFullscreenController::WINDOW_TYPE_OTHER,
-                            enabled);
+    ImmersiveFullscreenController::EnableForWidget(widget_, enabled);
   }
 
   // Attempt to reveal the top-of-window views via |modality|.

chrome/browser/ui/views/apps/chrome_native_app_window_views_aura_ash.cc

@@ -69,6 +69,10 @@ void ChromeNativeAppWindowViewsAuraAsh::InitializeWindow(
   aura::Window* window = GetNativeWindow();
   window->SetProperty(aura::client::kAppType,
                       static_cast<int>(ash::AppType::CHROME_APP));
+  window->SetProperty(
+      ash::kImmersiveWindowType,
+      static_cast<int>(
+          ash::ImmersiveFullscreenController::WINDOW_TYPE_PACKAGED_APP));
   // Fullscreen doesn't always imply immersive mode (see
   // ShouldEnableImmersive()).
   window->SetProperty(ash::kImmersiveImpliedByFullscreen, false);

chrome/browser/ui/views/frame/immersive_mode_controller_ash.cc

@@ -116,6 +116,13 @@ void ImmersiveModeControllerAsh::Init(BrowserView* browser_view) {
       !features::IsUsingWindowService()
           ? browser_view_->GetNativeWindow()
           : browser_view_->GetNativeWindow()->GetRootWindow());
+
+  browser_view_->GetNativeWindow()->SetProperty(
+      ash::kImmersiveWindowType,
+      static_cast<int>(
+          browser_view_->browser()->is_app()
+              ? ash::ImmersiveFullscreenController::WINDOW_TYPE_HOSTED_APP
+              : ash::ImmersiveFullscreenController::WINDOW_TYPE_BROWSER));
 }
 
 void ImmersiveModeControllerAsh::SetEnabled(bool enabled) {
@@ -130,11 +137,8 @@ void ImmersiveModeControllerAsh::SetEnabled(bool enabled) {
     registrar_.Add(this, chrome::NOTIFICATION_FULLSCREEN_CHANGED, source);
   }
 
-  controller_->SetEnabled(
-      browser_view_->browser()->is_app()
-          ? ash::ImmersiveFullscreenController::WINDOW_TYPE_HOSTED_APP
-          : ash::ImmersiveFullscreenController::WINDOW_TYPE_BROWSER,
-      enabled);
+  ash::ImmersiveFullscreenController::EnableForWidget(browser_view_->frame(),
+                                                      enabled);
 }
 
 bool ImmersiveModeControllerAsh::IsEnabled() const {
@@ -189,11 +193,8 @@ void ImmersiveModeControllerAsh::OnWidgetActivationChanged(
 
   // Enable immersive mode if the widget is activated. Do not disable immersive
   // mode if the widget deactivates, but is not minimized.
-  controller_->SetEnabled(
-      browser_view_->browser()->is_app()
-          ? ash::ImmersiveFullscreenController::WINDOW_TYPE_HOSTED_APP
-          : ash::ImmersiveFullscreenController::WINDOW_TYPE_BROWSER,
-      active || !widget->IsMinimized());
+  ash::ImmersiveFullscreenController::EnableForWidget(
+      browser_view_->frame(), active || !widget->IsMinimized());
 }
 
 void ImmersiveModeControllerAsh::LayoutBrowserRootView() {

components/exo/client_controlled_shell_surface.cc

@@ -487,8 +487,7 @@ void ClientControlledShellSurface::UpdateAutoHideFrame() {
     bool enabled = (frame_type_ == SurfaceFrameType::AUTOHIDE &&
                     (GetWindowState()->IsMaximizedOrFullscreenOrPinned() ||
                      GetWindowState()->IsSnapped()));
-    immersive_fullscreen_controller_->SetEnabled(
-        ash::ImmersiveFullscreenController::WINDOW_TYPE_OTHER, enabled);
+    ash::ImmersiveFullscreenController::EnableForWidget(widget_, enabled);
   }
 }
 
@@ -968,16 +967,14 @@ void ClientControlledShellSurface::UpdateFrame() {
       work_area.width() != geometry().width()) {
     if (!wide_frame_) {
       wide_frame_ = std::make_unique<ash::WideFrameView>(widget_);
-      immersive_fullscreen_controller_->SetEnabled(
-          ash::ImmersiveFullscreenController::WINDOW_TYPE_OTHER, false);
+      ash::ImmersiveFullscreenController::EnableForWidget(widget_, false);
       wide_frame_->Init(immersive_fullscreen_controller_.get());
       wide_frame_->GetWidget()->Show();
       UpdateCaptionButtonModel();
     }
   } else {
     if (wide_frame_) {
-      immersive_fullscreen_controller_->SetEnabled(
-          ash::ImmersiveFullscreenController::WINDOW_TYPE_OTHER, false);
+      ash::ImmersiveFullscreenController::EnableForWidget(widget_, false);
       wide_frame_.reset();
       GetFrameView()->InitImmersiveFullscreenControllerForView(
           immersive_fullscreen_controller_.get());