CrOS: Apply flag which enables us to force maximize mode.

ash/common/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/common/wm/maximize_mode/maximize_mode_controller.h"
 
 #include <utility>
 
 #include "ash/common/ash_switches.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_window_manager.h"
@@ skipping 67 matching lines @@
              ui::ConvertAccelerometerReadingToVector3dF(
                  update.get(chromeos::ACCELEROMETER_SOURCE_SCREEN))
                  .Length()) <= kNoisyMagnitudeDeviation;
 }
 
 bool IsEnabled() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kAshEnableTouchView);
 }
 
+// Checks the command line to see which force maximize mode is turned on, if
+// any.
+MaximizeModeController::ForceTabletMode GetMaximizeMode() {
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kAshForceTabletMode)) {
+    std::string switch_value =
+        command_line->GetSwitchValueASCII(switches::kAshForceTabletMode);
+    if (switch_value == switches::kAshForceTabletModeClamshell)
+      return MaximizeModeController::ForceTabletMode::CLAMSHELL;
+
+    if (switch_value == switches::kAshForceTabletModeTouchView)
+      return MaximizeModeController::ForceTabletMode::TOUCHVIEW;
+  }
+  return MaximizeModeController::ForceTabletMode::NONE;
+}
+
 }  // namespace
 
 MaximizeModeController::MaximizeModeController()
     : have_seen_accelerometer_data_(false),
       can_detect_lid_angle_(false),
       touchview_usage_interval_start_time_(base::Time::Now()),
       tick_clock_(new base::DefaultTickClock()),
       tablet_mode_switch_is_on_(false),
       lid_is_closed_(false),
       weak_factory_(this) {
@@ skipping 75 matching lines @@
     maximize_mode_window_manager_->AddWindow(window);
 }
 
 void MaximizeModeController::BindRequest(
     mojom::TouchViewManagerRequest request) {
   bindings_.AddBinding(this, std::move(request));
 }
 
 void MaximizeModeController::OnAccelerometerUpdated(
     scoped_refptr<const chromeos::AccelerometerUpdate> update) {
+  if (!AllowEnterExitMaximizeMode())
+    return;
+
   have_seen_accelerometer_data_ = true;
   can_detect_lid_angle_ =
       update->has(chromeos::ACCELEROMETER_SOURCE_SCREEN) &&
       update->has(chromeos::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD);
 
   if (!can_detect_lid_angle_)
     return;
 
   if (!display::Display::HasInternalDisplay())
     return;
@@ skipping 14 matching lines @@
     // 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(
     chromeos::PowerManagerClient::LidState state,
     const base::TimeTicks& time) {
+  if (!AllowEnterExitMaximizeMode())
+    return;
+
   const bool open = state == chromeos::PowerManagerClient::LidState::OPEN;
   if (open)
     last_lid_open_time_ = time;
   lid_is_closed_ = !open;
   LeaveMaximizeMode();
 }
 
 void MaximizeModeController::TabletModeEventReceived(
     chromeos::PowerManagerClient::TabletMode mode,
     const base::TimeTicks& time) {
+  if (!AllowEnterExitMaximizeMode())
+    return;
+
   const bool on = mode == chromeos::PowerManagerClient::TabletMode::ON;
   tablet_mode_switch_is_on_ = on;
   // Do not change if docked.
   if (!display::Display::HasInternalDisplay() ||
       !WmShell::Get()->IsActiveDisplayId(
           display::Display::InternalDisplayId())) {
     return;
   }
   // The tablet mode switch activates at 300 degrees, so it is always reliable
   // when |on|. However we wish to exit maximize mode at a smaller angle, so
@@ skipping 109 matching lines @@
 void MaximizeModeController::OnMaximizeModeStarted() {
   RecordTouchViewUsageInterval(TOUCH_VIEW_INTERVAL_INACTIVE);
 }
 
 // Called after maximize mode has ended, windows might still be returning to
 // their original position.
 void MaximizeModeController::OnMaximizeModeEnded() {
   RecordTouchViewUsageInterval(TOUCH_VIEW_INTERVAL_ACTIVE);
 }
 
+void MaximizeModeController::OnShellInitialized() {
+  force_tablet_mode_ = GetMaximizeMode();
+  if (force_tablet_mode_ == ForceTabletMode::TOUCHVIEW)
+    EnterMaximizeMode();
+}
+
 void MaximizeModeController::OnDisplayConfigurationChanged() {
   if (!display::Display::HasInternalDisplay() ||
       !WmShell::Get()->IsActiveDisplayId(
           display::Display::InternalDisplayId())) {
     LeaveMaximizeMode();
   } else if (tablet_mode_switch_is_on_ &&
              !IsMaximizeModeWindowManagerEnabled()) {
     // The internal display has returned, as we are exiting docked mode.
     // The device is still in tablet mode, so trigger maximize mode, as this
     // switch leads to the ignoring of accelerometer events. When the switch is
@@ skipping 29 matching lines @@
   if (IsMaximizeModeWindowManagerEnabled())
     return TOUCH_VIEW_INTERVAL_ACTIVE;
   return TOUCH_VIEW_INTERVAL_INACTIVE;
 }
 
 void MaximizeModeController::AddObserver(mojom::TouchViewObserverPtr observer) {
   observer->OnTouchViewToggled(IsMaximizeModeWindowManagerEnabled());
   observers_.AddPtr(std::move(observer));
 }
 
+bool MaximizeModeController::AllowEnterExitMaximizeMode() const {
+  return force_tablet_mode_ == ForceTabletMode::NONE;
+}
+
 void MaximizeModeController::OnAppTerminating() {
   // The system is about to shut down, so record TouchView usage interval
   // metrics based on whether TouchView mode is currently active.
   RecordTouchViewUsageInterval(CurrentTouchViewIntervalType());
 
   if (CanEnterMaximizeMode()) {
     UMA_HISTOGRAM_CUSTOM_COUNTS("Ash.TouchView.TouchViewActiveTotal",
                                 total_touchview_time_.InMinutes(), 1,
                                 base::TimeDelta::FromDays(7).InMinutes(), 50);
     UMA_HISTOGRAM_CUSTOM_COUNTS("Ash.TouchView.TouchViewInactiveTotal",
@@ skipping 26 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