[Refactor] Move the non-browser specific logic of ImmersiveModeControllerAsh into ash part 2

ash/wm/immersive_fullscreen_controller.h

 // Copyright 2012 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.
 
-#ifndef CHROME_BROWSER_UI_VIEWS_FRAME_IMMERSIVE_MODE_CONTROLLER_ASH_H_
-#define CHROME_BROWSER_UI_VIEWS_FRAME_IMMERSIVE_MODE_CONTROLLER_ASH_H_
+#ifndef ASH_WM_IMMERSIVE_FULLSCREEN_CONTROLLER_H_
+#define ASH_WM_IMMERSIVE_FULLSCREEN_CONTROLLER_H_
 
-#include "chrome/browser/ui/views/frame/immersive_mode_controller.h"
+#include <vector>
 
+#include "ash/ash_export.h"
+#include "ash/wm/immersive_revealed_lock.h"
 #include "base/timer/timer.h"
-#include "content/public/browser/notification_observer.h"
-#include "content/public/browser/notification_registrar.h"
 #include "ui/aura/window_observer.h"
 #include "ui/events/event_handler.h"
 #include "ui/gfx/animation/animation_delegate.h"
-#include "ui/gfx/rect.h"
 #include "ui/views/focus/focus_manager.h"
 #include "ui/views/widget/widget_observer.h"
 
-class BrowserView;
-class BookmarkBarView;
-
 namespace aura {
 class Window;
 }
 
 namespace gfx {
+class Point;
+class Rect;
 class SlideAnimation;
-class Transform;
 }
 
 namespace ui {
-class Layer;
 class LocatedEvent;
 }
 
 namespace views {
 class View;
+class Widget;
 }
 
-class ImmersiveModeControllerAsh : public ImmersiveModeController,
-                                   public content::NotificationObserver,
-                                   public gfx::AnimationDelegate,
-                                   public ui::EventHandler,
-                                   public views::FocusChangeListener,
-                                   public views::WidgetObserver,
-                                   public aura::WindowObserver {
+namespace ash {
+
+class ASH_EXPORT ImmersiveFullscreenController
+    : public gfx::AnimationDelegate,
+      public ui::EventHandler,
+      public views::FocusChangeListener,
+      public views::WidgetObserver,
+      public aura::WindowObserver,
+      public ImmersiveRevealedLock::Delegate {
  public:
-  ImmersiveModeControllerAsh();
-  virtual ~ImmersiveModeControllerAsh();
+  class Delegate {
+   public:
+    // Called when a reveal of the top-of-window views starts.
+    virtual void OnImmersiveRevealStarted() = 0;
 
-  // These methods are used to increment and decrement |revealed_lock_count_|.
-  // If immersive mode is enabled, a transition from 1 to 0 in
-  // |revealed_lock_count_| closes the top-of-window views and a transition
-  // from 0 to 1 in |revealed_lock_count_| reveals the top-of-window views.
-  void LockRevealedState(AnimateReveal animate_reveal);
-  void UnlockRevealedState();
+    // Called when the top-of-window views have finished closing. This call
+    // implies a visible fraction of 0. SetVisibleFraction(0) may not be called
+    // prior to OnImmersiveRevealEnded().
+    virtual void OnImmersiveRevealEnded() = 0;
 
-  // ImmersiveModeController overrides:
-  virtual void Init(Delegate* delegate,
-                    views::Widget* widget,
-                    views::View* top_container) OVERRIDE;
-  virtual void SetEnabled(bool enabled) OVERRIDE;
-  virtual bool IsEnabled() const OVERRIDE;
-  virtual bool ShouldHideTabIndicators() const OVERRIDE;
-  virtual bool ShouldHideTopViews() const OVERRIDE;
-  virtual bool IsRevealed() const OVERRIDE;
-  virtual int GetTopContainerVerticalOffset(
-      const gfx::Size& top_container_size) const OVERRIDE;
-  virtual ImmersiveRevealedLock* GetRevealedLock(
-      AnimateReveal animate_reveal) OVERRIDE WARN_UNUSED_RESULT;
-  virtual void OnFindBarVisibleBoundsChanged(
-      const gfx::Rect& new_visible_bounds_in_screen) OVERRIDE;
-  virtual void SetupForTest() OVERRIDE;
+    // Called as a result of disabling immersive fullscreen via SetEnabled().
+    virtual void OnImmersiveFullscreenExited() = 0;
 
-  // content::NotificationObserver override:
-  virtual void Observe(int type,
-                       const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE;
+    // Called to update the fraction of the top-of-window views height which is
+    // visible.
+    virtual void SetVisibleFraction(double visible_fraction) = 0;
+
+    // Returns a list of rects whose union makes up the top-of-window views.
+    // The returned list is used for hittesting when the top-of-window views
+    // are revealed. GetVisibleBoundsInScreen() must return a valid value when
+    // not in immersive fullscreen for the sake of SetupForTest().
+    virtual std::vector<gfx::Rect> GetVisibleBoundsInScreen() = 0;
+
+   protected:
+    virtual ~Delegate() {}
+  };
+
+  ImmersiveFullscreenController();
+  virtual ~ImmersiveFullscreenController();
+
+  // Initializes the controller. Must be called prior to enabling immersive
+  // fullscreen via SetEnabled(). |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.
+  void Init(Delegate* delegate,
+            views::Widget* widget,
+            views::View* top_container);
+
+  // Enables or disables immersive fullscreen.
+  void SetEnabled(bool enable);
+
+  // Returns true if |native_window_| is in immersive fullscreen.
+  bool IsEnabled() const;
+
+  // Returns true if |native_window_| is in immersive fullscreen and the
+  // top-of-window views are fully or partially visible.
+  bool IsRevealed() const;
+
+  // Returns a lock which will keep the top-of-window views revealed for its
+  // lifetime. Several locks can be obtained. When all of the locks are
+  // destroyed, if immersive fullscreen is enabled and there is nothing else
+  // keeping the top-of-window views revealed, the top-of-window views will be
+  // closed. This method always returns a valid lock regardless of whether
+  // immersive fullscreen is enabled. The lock's lifetime can span immersive
+  // fullscreen being enabled / disabled. If acquiring the lock causes a reveal,
+  // the top-of-window views will animate according to |animate_reveal|. The
+  // caller takes ownership of the returned lock.
+  ImmersiveRevealedLock* GetRevealedLock(
+      AnimateReveal animate_reveal) WARN_UNUSED_RESULT;
+
+  // Disables animations and moves the mouse so that it is not over the
+  // top-of-window views for the sake of testing.
+  void SetupForTest();
 
   // ui::EventHandler overrides:
   virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
 
   // views::FocusChangeObserver overrides:
   virtual void OnWillChangeFocus(views::View* focused_before,
                                  views::View* focused_now) OVERRIDE;
   virtual void OnDidChangeFocus(views::View* focused_before,
                                 views::View* focused_now) OVERRIDE;
 
   // views::WidgetObserver overrides:
   virtual void OnWidgetDestroying(views::Widget* widget) OVERRIDE;
   virtual void OnWidgetActivationChanged(views::Widget* widget,
                                          bool active) OVERRIDE;
 
   // gfx::AnimationDelegate overrides:
   virtual void AnimationEnded(const gfx::Animation* animation) OVERRIDE;
   virtual void AnimationProgressed(const gfx::Animation* animation) OVERRIDE;
 
   // aura::WindowObserver overrides:
-  virtual void OnWindowPropertyChanged(aura::Window* window,
-                                       const void* key,
-                                       intptr_t old) OVERRIDE;
   virtual void OnAddTransientChild(aura::Window* window,
                                    aura::Window* transient) OVERRIDE;
   virtual void OnRemoveTransientChild(aura::Window* window,
                                       aura::Window* transient) OVERRIDE;
 
+  // ash::ImmersiveRevealedLock::Delegate overrides:
+  virtual void LockRevealedState(AnimateReveal animate_reveal) OVERRIDE;
+  virtual void UnlockRevealedState() OVERRIDE;
+
  private:
-  friend class ImmersiveModeControllerAshTest;
+  friend class ImmersiveFullscreenControllerTest;
 
   enum AllowRevealWhileClosing {
     ALLOW_REVEAL_WHILE_CLOSING_YES,
     ALLOW_REVEAL_WHILE_CLOSING_NO
   };
   enum Animate {
     ANIMATE_NO,
     ANIMATE_SLOW,
     ANIMATE_FAST,
   };
-  enum Layout {
-    LAYOUT_YES,
-    LAYOUT_NO
-  };
   enum RevealState {
-    CLOSED,          // Top container only showing tabstrip, y = 0.
-    SLIDING_OPEN,    // All views showing, y animating from -height to 0.
-    REVEALED,        // All views showing, y = 0.
-    SLIDING_CLOSED,  // All views showing, y animating from 0 to -height.
-  };
-  enum TabIndicatorVisibility {
-    TAB_INDICATORS_FORCE_HIDE,
-    TAB_INDICATORS_HIDE,
-    TAB_INDICATORS_SHOW
+    CLOSED,
+    SLIDING_OPEN,
+    REVEALED,
+    SLIDING_CLOSED,
   };
   enum SwipeType {
     SWIPE_OPEN,
     SWIPE_CLOSE,
     SWIPE_NONE
   };
 
-  // Enables or disables observers for mouse move, focus, and window restore.
+  // Enables or disables observers for mouse, touch, focus, and activation.
   void EnableWindowObservers(bool enable);
 
   // Updates |top_edge_hover_timer_| based on a mouse |event|. If the mouse is
   // hovered at the top of the screen the timer is started. If the mouse moves
   // away from the top edge, or moves too much in the x direction, the timer is
   // stopped.
   void UpdateTopEdgeHoverTimer(ui::MouseEvent* event);
 
   // Updates |located_event_revealed_lock_| based on the current mouse state and
   // the current touch state.
@@ skipping 10 matching lines @@
 
   // Updates |focus_revealed_lock_| based on the currently active view and the
   // currently active widget.
   void UpdateFocusRevealedLock();
 
   // Update |located_event_revealed_lock_| and |focus_revealed_lock_| as a
   // result of a gesture of |swipe_type|. Returns true if any locks were
   // acquired or released.
   bool UpdateRevealedLocksForSwipe(SwipeType swipe_type);
 
-  // Updates whether fullscreen uses any chrome at all. When using minimal
-  // chrome, a 'light bar' is permanently visible for the launcher and possibly
-  // for the tabstrip.
-  void UpdateUseMinimalChrome(Layout layout);
-
   // Returns the animation duration given |animate|.
   int GetAnimationDuration(Animate animate) const;
 
   // Temporarily reveals the top-of-window views while in immersive mode,
   // hiding them when the cursor exits the area of the top views. If |animate|
   // is not ANIMATE_NO, slides in the view, otherwise shows it immediately.
   void MaybeStartReveal(Animate animate);
 
-  // Updates the browser root view's layout including window caption controls.
-  void LayoutBrowserRootView();
-
   // Called when the animation to slide open the top-of-window views has
   // completed.
-  void OnSlideOpenAnimationCompleted(Layout layout);
+  void OnSlideOpenAnimationCompleted();
 
   // Hides the top-of-window views if immersive mode is enabled and nothing is
   // keeping them revealed. Optionally animates.
   void MaybeEndReveal(Animate animate);
 
   // Called when the animation to slide out the top-of-window views has
   // completed.
   void OnSlideClosedAnimationCompleted();
 
   // Returns the type of swipe given |event|.
@@ skipping 10 matching lines @@
   // the top container is closed "near" means either within the displayed
   // bounds, above it, or within a few pixels below it. This allow the container
   // to steal enough pixels to detect a swipe in and handles the case that there
   // is a bezel sensor above the top container.
   bool ShouldHandleGestureEvent(const gfx::Point& location) const;
 
   // Recreate |bubble_manager_| and start observing any bubbles anchored to a
   // child of |top_container_|.
   void RecreateBubbleManager();
 
-  // Shrinks or expands the touch hit test by updating insets for the render
-  // window depending on if top_inset is positive or negative respectively.
-  // Used to ensure that touch events at the top of the screen go to the top
-  // container so a slide gesture can be generated when the content window is
-  // consuming all touch events sent to it.
-  void SetRenderWindowTopInsetsForTouch(int top_inset);
+  // Not owned.
+  Delegate* delegate_;
+  views::View* top_container_;
+  views::Widget* widget_;
+  aura::Window* native_window_;
 
-  // Injected dependencies. Not owned.
-  Delegate* delegate_;
-  views::Widget* widget_;
-  views::View* top_container_;
-
-  // True if the window observers are enabled.
+  // True if the observers have been enabled.
   bool observers_enabled_;
 
-  // True when in immersive mode.
+  // True when in immersive fullscreen.
   bool enabled_;
 
   // State machine for the revealed/closed animations.
   RevealState reveal_state_;
 
   int revealed_lock_count_;
 
-  // The visibility of the miniature "tab indicators" in the main browser view
-  // when immersive mode is enabled and the top-of-window views are closed.
-  TabIndicatorVisibility tab_indicator_visibility_;
-
   // Timer to track cursor being held at the top edge of the screen.
-  base::OneShotTimer<ImmersiveModeController> top_edge_hover_timer_;
+  base::OneShotTimer<ImmersiveFullscreenController> top_edge_hover_timer_;
 
   // The cursor x position in screen coordinates when the cursor first hit the
   // top edge of the screen.
   int mouse_x_when_hit_top_in_screen_;
 
   // Tracks if the controller has seen a ET_GESTURE_SCROLL_BEGIN, without the
   // following events.
   bool gesture_begun_;
 
-  // The current visible bounds of the find bar, in screen coordinates. This is
-  // an empty rect if the find bar is not visible.
-  gfx::Rect find_bar_visible_bounds_in_screen_;
-
   // Lock which keeps the top-of-window views revealed based on the current
   // mouse state and the current touch state. Acquiring the lock is used to
   // trigger a reveal when the user moves the mouse to the top of the screen
   // and when the user does a SWIPE_OPEN edge gesture.
   scoped_ptr<ImmersiveRevealedLock> located_event_revealed_lock_;
 
   // Lock which keeps the top-of-window views revealed based on the focused view
   // and the active widget. Acquiring the lock never triggers a reveal because
   // a view is not focusable till a reveal has made it visible.
   scoped_ptr<ImmersiveRevealedLock> focus_revealed_lock_;
 
-  // Native window for the browser.
-  aura::Window* native_window_;
-
   // The animation which controls sliding the top-of-window views in and out.
   scoped_ptr<gfx::SlideAnimation> animation_;
 
   // Whether the animations are disabled for testing.
   bool animations_disabled_for_test_;
 
   // Manages bubbles which are anchored to a child of |top_container_|.
   class BubbleManager;
   scoped_ptr<BubbleManager> bubble_manager_;
 
-  content::NotificationRegistrar registrar_;
+  base::WeakPtrFactory<ImmersiveFullscreenController> weak_ptr_factory_;
 
-  base::WeakPtrFactory<ImmersiveModeControllerAsh> weak_ptr_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(ImmersiveModeControllerAsh);
+  DISALLOW_COPY_AND_ASSIGN(ImmersiveFullscreenController);
 };
 
-#endif  // CHROME_BROWSER_UI_VIEWS_FRAME_IMMERSIVE_MODE_CONTROLLER_ASH_H_
+}  // namespace ash
+
+#endif  // ASH_WM_IMMERSIVE_FULLSCREEN_CONTROLLER_H_