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 83 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) {
   WmShell::Get()->AddShellObserver(this);
   Shell* shell = Shell::GetInstance();
   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 101 matching lines @@
 }
 
 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) {
+  tablet_mode_switch_is_on_ = on;
+  if (on && !IsMaximizeModeWindowManagerEnabled())
+    EnterMaximizeMode();
+}
+
 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 12 matching lines @@
   // 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)));
 
+  // We cannot trust the computed lid angle when the device is held vertically.
+  bool is_angle_reliable =
+      std::abs(base_reading.x()) <= kHingeVerticalSmoothingMaximum;

[flackr, 2016/06/15 07:53:24]

This should check largest_hinge_acceleration instead to be consistent with
smoothing_ratio. Note, smoothing_ratio should also be equal to 1.0f if this is
true meaning no change in computed lid angle as well.

[jcliang, 2016/06/15 08:14:10]

Done.

+
   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);
 
+  if (tablet_mode_switch_is_on_)
+    return;
+
   // 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_angle_reliable && 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 &&

[flackr, 2016/06/15 07:53:24]

Unfortunately IsMaximizeModeWindowManagerEnabled is not synonymous with
lid_open_past_180_. If we want to make this change we should remove
EnableMaximizeModeWindowManager and force all state changes through
(Enter|Exit)MaximizeMode instead. I do think this is a worthwhile cleanup -
having the separate state for testing code is really messy. We can even remove
the keyboard shortcut for touchview testing.

What will happen is with this change, when you enable the touchview testing flag
and use the keyboard shortcut to enable touchview
(https://cs.chromium.org/chromium/src/ash/accelerators/accelerator_controller....)
we won't disable the keyboard and touchpad when the lid is opened past 180
degrees.

[jcliang, 2016/06/15 08:14:10]

So this change will only impact touchview testing flag + enable touchview with
keyboard shortcut + on chromeos, which is limited. I'd like to merge this CL
first and leave the clean-up in another follow up CL because this CL is
currently blocking other people from rolling cros_system_api in DEPS. Does it
sound reasonable to you?

       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