Hook up TABLET_MODE switch to maximize_mode_controller

ash/wm/maximize_mode/maximize_mode_controller.cc

Index: ash/wm/maximize_mode/maximize_mode_controller.cc
diff --git a/ash/wm/maximize_mode/maximize_mode_controller.cc b/ash/wm/maximize_mode/maximize_mode_controller.cc
index 9d8b18dae29de82390b61d4e439eca666dfd59db..0b5417903402816aacd16644d2350b6122b968b9 100644
--- a/ash/wm/maximize_mode/maximize_mode_controller.cc
+++ b/ash/wm/maximize_mode/maximize_mode_controller.cc
@@ -100,9 +100,11 @@ bool IsAngleBetweenAccelerometerReadingsStable(
 
 MaximizeModeController::MaximizeModeController()
     : have_seen_accelerometer_data_(false),
-      lid_open_past_180_(false),
       touchview_usage_interval_start_time_(base::Time::Now()),
       tick_clock_(new base::DefaultTickClock()),
+#if defined(OS_CHROMEOS)
+      tablet_mode_switch_is_on_(false),
+#endif
       lid_is_closed_(false) {
   Shell* shell = Shell::GetInstance();
   shell->AddShellObserver(this);
@@ -208,6 +210,8 @@ void MaximizeModeController::OnAccelerometerUpdated(
              ui::IsAccelerometerReadingStable(
                  *update, chromeos::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD) &&
              IsAngleBetweenAccelerometerReadingsStable(*update)) {
+    if (tablet_mode_switch_is_on_)
+      return;

[Daniel Erat, 2016/06/06 17:23:07]

i'm wondering if this early return can cause problems. i'm not familiar with
this code, but HandleHingeRotation looks like it updates some other members
(mostly related to smoothing readings, i think). is it really okay to skip all
of that?

[jcliang, 2016/06/06 18:19:25]

I think the {base|lid}_smoothed_ essentially act like filters to discard
unstable readings, e.g. the readings got when the device is held vertical. I
don't see a need to continuously compute the smoothed readings.

[jonross, 2016/06/07 15:27:15]

We continuously compute them as the motion from flat to near vertical can be
quite quick. We didn't want to have false exits due to accelerometer jank right
after this motion.

In general the smoothed accelerometer data leads to better decisions when there
is no tablet switch.

If the user flips the switch while nearly vertical the device may be flaky in
deciding which mode to be in, without a history of accelerometer values.

[jcliang, 2016/06/07 16:57:23]

Should I remove the early return here? The smoothed values seem to converge to
the right lid angle fairly quickly if the device is horizontal.

I noticed that when the device is nearly vertical the smoothed values keep the
computed lid angle stay at the last value seen before the device is close to
vertical. In other words, if I open the lid to 90 degrees when the device is
horizontal, flip the device vertically, and open the lid to 360 degrees, the
smoothed values will give me lid_angle=90 ever since the device is vertical.

In the above example if the device has a tablet mode switch, the switch is on
when the lid angle is 360 degrees. If the device is still vertical when the
switch is off the device will exit maximize mode since the smoothed values give
lid_angle=90. So I added a is_angle_reliable check in HandleHingeRotation() to
ignore any lid angles we get while the device is vertical, which keeps the
device in maximize mode when switch is off until we have a reliable lid angle to
decide the new state.

[jonross, 2016/06/07 22:04:42]

I think I would like to see this check after the smoothing has been calculated. 

While you have added a is_angle_reliable, one problem that occurs is often while
vertical, small movements of the device reduce the x-axis component of gravity
to be less than 1g. It's during these times that the smoothing helps lock to the
previous value.

[jcliang, 2016/06/08 04:12:38]

Done.

     // update.has(chromeos::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD)
     // 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
@@ -224,6 +228,18 @@ void MaximizeModeController::LidEventReceived(bool open,
   LeaveMaximizeMode();
 }
 
+void MaximizeModeController::TabletModeEventReceived(
+    bool on,
+    const base::TimeTicks& time) {
+  if (on) {
+    tablet_mode_switch_is_on_ = true;
+    if (!IsMaximizeModeWindowManagerEnabled())
+      EnterMaximizeMode();
+  } else {
+    tablet_mode_switch_is_on_ = false;
+  }
+}
+
 void MaximizeModeController::SuspendImminent() {
   // The system is about to suspend, so record TouchView usage interval metrics
   // based on whether TouchView mode is currently active.
@@ -255,6 +271,8 @@ void MaximizeModeController::HandleHingeRotation(
                                      kHingeVerticalSmoothingStart) /
                                         (kHingeVerticalSmoothingMaximum -
                                          kHingeVerticalSmoothingStart)));
+  bool is_base_vertical =
+      std::abs(base_reading.x()) > kHingeVerticalSmoothingMaximum;
 
   base_smoothed_.Scale(smoothing_ratio);
   base_reading.Scale(1.0f - smoothing_ratio);
@@ -277,7 +295,7 @@ void MaximizeModeController::HandleHingeRotation(
   if (lid_angle < 0.0f)
     lid_angle += 360.0f;
 
-  bool is_angle_stable = lid_angle >= kMinStableAngle &&
+  bool is_angle_stable = !is_base_vertical && lid_angle >= kMinStableAngle &&
                          lid_angle <= kMaxStableAngle;
 
   // Clear the last_lid_open_time_ for a stable reading so that there is less
@@ -287,14 +305,12 @@ void MaximizeModeController::HandleHingeRotation(
     last_lid_open_time_ = base::TimeTicks();
 
   // Toggle maximize mode on or off when corresponding thresholds are passed.
-  if (lid_open_past_180_ && is_angle_stable &&
+  if (IsMaximizeModeWindowManagerEnabled() && is_angle_stable &&
       lid_angle <= kExitMaximizeModeAngle) {
-    lid_open_past_180_ = false;
     LeaveMaximizeMode();
-  } else if (!lid_open_past_180_ && !lid_is_closed_ &&
+  } else if (!IsMaximizeModeWindowManagerEnabled() && !lid_is_closed_ &&
              lid_angle >= kEnterMaximizeModeAngle &&
              (is_angle_stable || !WasLidOpenedRecently())) {
-    lid_open_past_180_ = true;
     EnterMaximizeMode();
   }
 }