Move MaximizeModeWindowManager to the controller

ash/wm/maximize_mode/maximize_mode_controller.cc

 // Copyright 2014 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 "ash/wm/maximize_mode/maximize_mode_controller.h"
 
 #include "ash/accelerators/accelerator_controller.h"
 #include "ash/accelerators/accelerator_table.h"
 #include "ash/accelerometer/accelerometer_controller.h"
 #include "ash/ash_switches.h"
 #include "ash/display/display_manager.h"
 #include "ash/shell.h"
 #include "ash/wm/maximize_mode/maximize_mode_event_blocker.h"
+#include "ash/wm/maximize_mode/maximize_mode_window_manager.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/events/event.h"
 #include "ui/events/event_handler.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/vector3d_f.h"
 
 namespace ash {
 
@@ skipping 106 matching lines @@
 }
 
 #endif  // OS_CHROMEOS
 
 }  // namespace
 
 MaximizeModeController::MaximizeModeController()
     : rotation_locked_(false),
       have_seen_accelerometer_data_(false),
       in_set_screen_rotation_(false),
       user_rotation_(gfx::Display::ROTATE_0) {

[Mr4D (OOO till 08-26), 2014/05/29 22:15:24]

Just wondering - when debugging on goobuntu - is there a dummy
accelerometer_controller?

[jonross, 2014/05/30 14:37:50]

The controller is fully created, however there is no dummy accelerometer to
actually be read. So no readings take place, and OnAccelerometerUpdated is never
triggered.

   Shell::GetInstance()->accelerometer_controller()->AddObserver(this);
 }
 
 MaximizeModeController::~MaximizeModeController() {
   Shell::GetInstance()->accelerometer_controller()->RemoveObserver(this);
 }
 
 bool MaximizeModeController::CanEnterMaximizeMode() {
   // If we have ever seen accelerometer data, then HandleHingeRotation may
   // trigger maximize mode at some point in the future.
   // The --enable-touch-view-testing switch can also mean that we may enter
   // maximize mode.
   return have_seen_accelerometer_data_ ||
          CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kAshEnableTouchViewTesting);
 }
 
+void MaximizeModeController::EnableMaximizeModeWindowManager(bool enable) {
+  if (enable && !maximize_mode_window_manager_.get()) {
+    maximize_mode_window_manager_.reset(new MaximizeModeWindowManager());
+    // TODO(jonross): Move the maximize mode notifications from ShellObserver
+    // to MaximizeModeController::Observer
+    Shell::GetInstance()->OnMaximizeModeStarted();
+  } else if (!enable && maximize_mode_window_manager_.get()) {
+    maximize_mode_window_manager_.reset();
+    Shell::GetInstance()->OnMaximizeModeEnded();
+  }
+}
+
+bool MaximizeModeController::IsMaximizeModeWindowManagerEnabled() const {
+  return maximize_mode_window_manager_.get() != NULL;
+}
+
+void MaximizeModeController::Shutdown() {
+  maximize_mode_window_manager_.reset();
+  Shell::GetInstance()->OnMaximizeModeEnded();
+}
+
 void MaximizeModeController::OnAccelerometerUpdated(
     const gfx::Vector3dF& base,
     const gfx::Vector3dF& lid) {
   have_seen_accelerometer_data_ = true;
 
   // Ignore the reading if it appears unstable. The reading is considered
   // unstable if it deviates too much from gravity and/or the magnitude of the
   // reading from the lid differs too much from the reading from the base.
   float base_magnitude = base.Length();
   float lid_magnitude = lid.Length();
   if (std::abs(base_magnitude - lid_magnitude) > kNoisyMagnitudeDeviation ||
       std::abs(base_magnitude - 1.0f) > kDeviationFromGravityThreshold ||
       std::abs(lid_magnitude - 1.0f) > kDeviationFromGravityThreshold) {
       return;
   }
 
   // Responding to the hinge rotation can change the maximize mode state which
   // affects screen rotation, so we handle hinge rotation first.
   HandleHingeRotation(base, lid);
   HandleScreenRotation(lid);
 }
 
 void MaximizeModeController::HandleHingeRotation(const gfx::Vector3dF& base,
                                                  const gfx::Vector3dF& lid) {
   static const gfx::Vector3dF hinge_vector(0.0f, 1.0f, 0.0f);
-  bool maximize_mode_engaged =
-      Shell::GetInstance()->IsMaximizeModeWindowManagerEnabled();
+  bool maximize_mode_engaged = IsMaximizeModeWindowManagerEnabled();
   // Ignore the component of acceleration parallel to the hinge for the purposes
   // of hinge angle calculation.
   gfx::Vector3dF base_flattened(base);
   gfx::Vector3dF lid_flattened(lid);
   base_flattened.set_y(0.0f);
   lid_flattened.set_y(0.0f);
 
   // As the hinge approaches a vertical angle, the base and lid accelerometers
   // approach the same values making any angle calculations highly inaccurate.
   // Bail out early when it is too close.
@@ skipping 14 matching lines @@
       angle > kFullyOpenAngleErrorTolerance &&
       angle < kExitMaximizeModeAngle) {
     LeaveMaximizeMode();
   } else if (!maximize_mode_engaged &&
       angle > kEnterMaximizeModeAngle) {
     EnterMaximizeMode();
   }
 }
 
 void MaximizeModeController::HandleScreenRotation(const gfx::Vector3dF& lid) {
-  bool maximize_mode_engaged =
-      Shell::GetInstance()->IsMaximizeModeWindowManagerEnabled();
+  bool maximize_mode_engaged = IsMaximizeModeWindowManagerEnabled();
 
   if (!maximize_mode_engaged || rotation_locked_)
     return;
 
   DisplayManager* display_manager =
       Shell::GetInstance()->display_manager();
   gfx::Display::Rotation current_rotation = display_manager->GetDisplayInfo(
       gfx::Display::InternalDisplayId()).rotation();
 
   // After determining maximize mode state, determine if the screen should
@@ skipping 54 matching lines @@
                                       rotation);
 }
 
 void MaximizeModeController::EnterMaximizeMode() {
   // TODO(jonross): Listen for display configuration changes. If the user
   // causes a rotation change a rotation lock should be applied.
   // https://crbug.com/369505
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   user_rotation_ = display_manager->
       GetDisplayInfo(gfx::Display::InternalDisplayId()).rotation();
-  Shell::GetInstance()->EnableMaximizeModeWindowManager(true);
+  EnableMaximizeModeWindowManager(true);
   event_blocker_.reset(new MaximizeModeEventBlocker);
 #if defined(OS_CHROMEOS)
   event_handler_.reset(new ScreenshotActionHandler);
 #endif
 }
 
 void MaximizeModeController::LeaveMaximizeMode() {
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   DisplayInfo info = display_manager->
       GetDisplayInfo(gfx::Display::InternalDisplayId());
   gfx::Display::Rotation current_rotation = info.rotation();
   if (current_rotation != user_rotation_)
     SetDisplayRotation(display_manager, user_rotation_);
   rotation_locked_ = false;
-  Shell::GetInstance()->EnableMaximizeModeWindowManager(false);
+  EnableMaximizeModeWindowManager(false);
   event_blocker_.reset();
   event_handler_.reset();
 }
 
 }  // namespace ash