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 85 matching lines @@
 }
 #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_was_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 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) {
+  if (on) {
+    chromeos::AccelerometerReader::GetInstance()->RemoveObserver(this);
+    EnterMaximizeMode();
+  } else {
+    tablet_mode_switch_was_on_ = true;
+    chromeos::AccelerometerReader::GetInstance()->AddObserver(this);

[Daniel Erat, 2016/06/06 15:24:55]

this approach seems problematic. if powerd sends multiple notifications (e.g.
because it crashes and restarts, or the switch is malfunctioning, or there's a
kernel bug, or there's a firmware bug, or etc.), won't you double-add or
double-remove the observer? i wouldn't be surprised if that causing a failed
assert and crashes chrome.

what's wrong with the approach that i suggested?

[jcliang, 2016/06/06 16:48:36]

I didn't realize that {Add|Remove}Observer() are not protected against double
{add|remove}. The remove/add observers are not necessary and are just some
enhancements suggested by Jonathan.

We can factor out the state changing logic in HandleHingeRotation() to another
UpdateState() function, but it doesn't really solve the issue here. The problem
we have here is that we're depending on lid_open_past_180_ = true to leave
maximize mode, and we need to check if we need to leave maximize mode after
tablet mode switch if off. Setting lid_open_past_180_ or
tablet_mode_switch_was_on_ both were for this reason.

Now I think to solve this issue we should remove lid_open_past_180_, and replace
it with IsMaximizeModeManagerEnabled().

+  }
+}
+
 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 ((lid_open_past_180_ || tablet_mode_switch_was_on_) && is_angle_stable &&
       lid_angle <= kExitMaximizeModeAngle) {
     lid_open_past_180_ = false;
+    tablet_mode_switch_was_on_ = false;
     LeaveMaximizeMode();
   } else if (!lid_open_past_180_ && !lid_is_closed_ &&
              lid_angle >= kEnterMaximizeModeAngle &&
              (is_angle_stable || !WasLidOpenedRecently())) {
     lid_open_past_180_ = true;
     EnterMaximizeMode();
   }
 }
 #endif  // OS_CHROMEOS
 
@@ skipping 112 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