Shuffles around immersive related classes

ash/shared/immersive_fullscreen_controller.h

 // Copyright 2013 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 ASH_WM_IMMERSIVE_FULLSCREEN_CONTROLLER_H_
-#define ASH_WM_IMMERSIVE_FULLSCREEN_CONTROLLER_H_
+#ifndef ASH_SHARED_IMMERSIVE_FULLSCREEN_CONTROLLER_H_
+#define ASH_SHARED_IMMERSIVE_FULLSCREEN_CONTROLLER_H_
 
 #include <memory>
 #include <vector>
 
 #include "ash/ash_export.h"
-#include "ash/common/wm/immersive/wm_immersive_fullscreen_controller.h"
-#include "ash/common/wm/immersive_revealed_lock.h"
+#include "ash/shared/immersive_revealed_lock.h"
 #include "base/macros.h"
 #include "base/timer/timer.h"
 #include "ui/gfx/animation/animation_delegate.h"
 #include "ui/views/pointer_watcher.h"
 #include "ui/views/widget/widget_observer.h"
 
 namespace gfx {
 class Point;
 class SlideAnimation;
 }
 
 namespace ui {
 class GestureEvent;
 class LocatedEvent;
 class MouseEvent;
 class TouchEvent;
 }
 
 namespace views {
 class View;
 class Widget;
 }
 
 namespace ash {
 
 class ImmersiveFocusWatcher;
+class ImmersiveFullscreenControllerDelegate;
 class ImmersiveFullscreenControllerTestApi;
 class ImmersiveGestureHandler;
 class WmWindow;
 
 class ASH_EXPORT ImmersiveFullscreenController
-    : public WmImmersiveFullscreenController,
-      public gfx::AnimationDelegate,
+    : public gfx::AnimationDelegate,
       public views::PointerWatcher,
       public views::WidgetObserver,
       public ImmersiveRevealedLock::Delegate {
  public:
+  // The enum is used for an enumerated histogram. New items should be only
+  // added to the end.
+  enum WindowType {
+    WINDOW_TYPE_OTHER,
+    WINDOW_TYPE_BROWSER,
+    WINDOW_TYPE_HOSTED_APP,
+    WINDOW_TYPE_PACKAGED_APP,
+    WINDOW_TYPE_COUNT
+  };
+
+  // How many pixels are reserved for touch-events towards the top of an
+  // immersive-fullscreen window.
+  static const int kImmersiveFullscreenTopEdgeInset;
+
+  // The height in pixels of the region below the top edge of the display in
+  // which the mouse can trigger revealing the top-of-window views. The height
+  // must be greater than 1px because the top pixel is used to trigger moving
+  // the cursor between displays if the user has a vertical display layout
+  // (primary display above/below secondary display).
   static const int kMouseRevealBoundsHeight;
 
   ImmersiveFullscreenController();
   ~ImmersiveFullscreenController() override;
 
-  // WmImmersiveFullscreenController overrides:
-  void Init(WmImmersiveFullscreenControllerDelegate* delegate,
+  // 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. |widget| is the widget to make fullscreen.
+  void Init(ImmersiveFullscreenControllerDelegate* delegate,
             views::Widget* widget,
-            views::View* top_container) override;
-  void SetEnabled(WindowType window_type, bool enable) override;
-  bool IsEnabled() const override;
-  bool IsRevealed() const override;
+            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.
+  void SetEnabled(WindowType window_type, bool enable);
+
+  // Returns true if in immersive fullscreen.
+  bool IsEnabled() const;
+
+  // Returns true if 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.
@@ skipping 114 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;
 
   // Returns the display bounds of the screen |widget_| is on.
   gfx::Rect GetDisplayBoundsInScreen() const;
 
   // Not owned.
-  WmImmersiveFullscreenControllerDelegate* delegate_;
+  ImmersiveFullscreenControllerDelegate* delegate_;
   views::View* top_container_;
   views::Widget* widget_;
   // The WmWindow for |widget_|.
   WmWindow* widget_window_ = nullptr;
 
   // True if the observers have been enabled.
   bool observers_enabled_;
 
   // True when in immersive fullscreen.
   bool enabled_;
@@ skipping 29 matching lines @@
   std::unique_ptr<ImmersiveFocusWatcher> immersive_focus_watcher_;
   std::unique_ptr<ImmersiveGestureHandler> immersive_gesture_handler_;
 
   base::WeakPtrFactory<ImmersiveFullscreenController> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ImmersiveFullscreenController);
 };
 
 }  // namespace ash
 
-#endif  // ASH_WM_IMMERSIVE_FULLSCREEN_CONTROLLER_H_
+#endif  // ASH_SHARED_IMMERSIVE_FULLSCREEN_CONTROLLER_H_