Hook up TABLET_MODE switch to maximize_mode_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 <utility>
 
 #include "ash/accelerators/accelerator_controller.h"
 #include "ash/accelerators/accelerator_table.h"
@@ skipping 82 matching lines @@
              ui::ConvertAccelerometerReadingToVector3dF(
                  update.get(chromeos::ACCELEROMETER_SOURCE_SCREEN)).Length()) <=
          kNoisyMagnitudeDeviation;
 }
 #endif  // OS_CHROMEOS
 
 }  // namespace
 
 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);
   shell->metrics()->RecordUserMetricsAction(
       ash::UMA_MAXIMIZE_MODE_INITIALLY_DISABLED);
 
 #if defined(OS_CHROMEOS)
   // TODO(jonross): Do not create MaximizeModeController if the flag is
   // unavailable. This will require refactoring
   // IsMaximizeModeWindowManagerEnabled to check for the existance of the
@@ skipping 85 matching lines @@
   // Whether or not we enter maximize mode affects whether we handle screen
   // rotation, so determine whether to enter maximize mode first.
   if (!update->has(chromeos::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD)) {
     if (first_accelerometer_update)
       EnterMaximizeMode();
   } else if (ui::IsAccelerometerReadingStable(
                  *update, chromeos::ACCELEROMETER_SOURCE_SCREEN) &&
              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
     // reading from the lid differs too much from the reading from the base.
     HandleHingeRotation(update);
   }
 }
 
 void MaximizeModeController::LidEventReceived(bool open,
                                               const base::TimeTicks& time) {
   if (open)
     last_lid_open_time_ = time;
   lid_is_closed_ = !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.
   RecordTouchViewUsageInterval(CurrentTouchViewIntervalType());
 }
 
 void MaximizeModeController::SuspendDone(
     const base::TimeDelta& sleep_duration) {
   // We do not want TouchView usage metrics to include time spent in suspend.
   touchview_usage_interval_start_time_ = base::Time::Now();
@@ skipping 11 matching lines @@
   // approach the same values making any angle calculations highly inaccurate.
   // Smooth out instantaneous acceleration when nearly vertical to increase
   // accuracy.
   float largest_hinge_acceleration =
       std::max(std::abs(base_reading.x()), std::abs(lid_reading.x()));
   float smoothing_ratio =
       std::max(0.0f, std::min(1.0f, (largest_hinge_acceleration -
                                      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);
   base_smoothed_.Add(base_reading);
 
   lid_smoothed_.Scale(smoothing_ratio);
   lid_reading.Scale(1.0f - smoothing_ratio);
   lid_smoothed_.Add(lid_reading);
 
   // Ignore the component of acceleration parallel to the hinge for the purposes
   // of hinge angle calculation.
   gfx::Vector3dF base_flattened(base_smoothed_);
   gfx::Vector3dF lid_flattened(lid_smoothed_);
   base_flattened.set_x(0.0f);
   lid_flattened.set_x(0.0f);
 
   // Compute the angle between the base and the lid.
   float lid_angle = 180.0f - gfx::ClockwiseAngleBetweenVectorsInDegrees(
                                  base_flattened, lid_flattened, hinge_vector);
   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
   // chance of a delay if the lid is moved from the close state to the fully
   // open state very quickly.
   if (is_angle_stable)
     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();
   }
 }
 #endif  // OS_CHROMEOS
 
 void MaximizeModeController::EnterMaximizeMode() {
   // Always reset first to avoid creation before destruction of a previous
   // object.
   event_blocker_.reset();
 #if defined(USE_X11)
@@ skipping 107 matching lines @@
   return elapsed_time.InSeconds() <= kLidRecentlyOpenedDurationSeconds;
 }
 
 void MaximizeModeController::SetTickClockForTest(
     std::unique_ptr<base::TickClock> tick_clock) {
   DCHECK(tick_clock_);
   tick_clock_ = std::move(tick_clock);
 }
 
 }  // namespace ash