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)
+      force_maximize_mode_(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) {
+    force_maximize_mode_ = true;
+    EnterMaximizeMode();
+  } else {
+    force_maximize_mode_ = false;
+    // Set lid_open_past_180_ so that we get a chance to decide whether to
+    // leave maximize mode.
+    lid_open_past_180_ = true;

[jonross, 2016/06/03 03:27:19]

I think that this should be set when the tablet mode on event is received. 

Then the tablet mode early exit could be in HandleHingeRotation.

[jcliang, 2016/06/03 05:28:49]

If lid_open_past_180_ is set when the tablet mode on event is received, there
will be a race between HandleHingeRotation() and here. HandleHingeRotation()
could unset lid_open_past_180_ right after we set it here.

+  }
+}
+
 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 88 matching lines @@
 void MaximizeModeController::LeaveMaximizeMode() {
   event_blocker_.reset();
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshEnableTouchViewTesting)) {
     // We don't let accelerometer updates interfere with the maximize mode
     // status as set by the touch-view-testing keyboard shortcut.
     return;
   }
 
+#if defined(OS_CHROMEOS)
+  if (force_maximize_mode_)
+    return;

[jonross, 2016/06/03 03:27:19]

With this here it is possible for the tablet mode to be active, and for the
keyboard to be reenabled on line 343

[jcliang, 2016/06/03 05:28:49]

Done.

+#endif
   if (!IsMaximizeModeWindowManagerEnabled())
     return;
   EnableMaximizeModeWindowManager(false);
 }
 
 // Called after maximize mode has started, windows might still animate though.
 void MaximizeModeController::OnMaximizeModeStarted() {
   RecordTouchViewUsageInterval(TOUCH_VIEW_INTERVAL_INACTIVE);
 }
 
@@ skipping 70 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