Index: ash/wm/tablet_mode/tablet_mode_controller.cc |
diff --git a/ash/wm/maximize_mode/maximize_mode_controller.cc b/ash/wm/tablet_mode/tablet_mode_controller.cc |
similarity index 71% |
rename from ash/wm/maximize_mode/maximize_mode_controller.cc |
rename to ash/wm/tablet_mode/tablet_mode_controller.cc |
index 39b21cd26d09a52c5d54fffbf0a9fdb7ab4c83c0..5525e4635472b90a3d184e5d35f3e4b0f67cdc5a 100644 |
--- a/ash/wm/maximize_mode/maximize_mode_controller.cc |
+++ b/ash/wm/tablet_mode/tablet_mode_controller.cc |
@@ -2,15 +2,15 @@ |
// 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 "ash/wm/tablet_mode/tablet_mode_controller.h" |
#include <utility> |
#include "ash/ash_switches.h" |
#include "ash/shell.h" |
#include "ash/shell_port.h" |
-#include "ash/wm/maximize_mode/maximize_mode_window_manager.h" |
-#include "ash/wm/maximize_mode/scoped_disable_internal_mouse_and_keyboard.h" |
+#include "ash/wm/tablet_mode/scoped_disable_internal_mouse_and_keyboard.h" |
+#include "ash/wm/tablet_mode/tablet_mode_window_manager.h" |
#include "base/bind.h" |
#include "base/command_line.h" |
#include "base/metrics/histogram_macros.h" |
@@ -28,12 +28,12 @@ namespace ash { |
namespace { |
-// The hinge angle at which to enter maximize mode. |
-const float kEnterMaximizeModeAngle = 200.0f; |
+// The hinge angle at which to enter tablet mode. |
+const float kEnterTabletModeAngle = 200.0f; |
-// The angle at which to exit maximize mode, this is specifically less than the |
-// angle to enter maximize mode to prevent rapid toggling when near the angle. |
-const float kExitMaximizeModeAngle = 160.0f; |
+// The angle at which to exit tablet mode, this is specifically less than the |
+// angle to enter tablet mode to prevent rapid toggling when near the angle. |
+const float kExitTabletModeAngle = 160.0f; |
// Defines a range for which accelerometer readings are considered accurate. |
// When the lid is near open (or near closed) the accelerometer readings may be |
@@ -43,7 +43,7 @@ const float kMinStableAngle = 20.0f; |
const float kMaxStableAngle = 340.0f; |
// The time duration to consider the lid to be recently opened. |
-// This is used to prevent entering maximize mode if an erroneous accelerometer |
+// This is used to prevent entering tablet mode if an erroneous accelerometer |
// reading makes the lid appear to be fully open when the user is opening the |
// lid from a closed position. |
const int kLidRecentlyOpenedDurationSeconds = 2; |
@@ -85,25 +85,25 @@ bool IsEnabled() { |
switches::kAshEnableTouchView); |
} |
-// Checks the command line to see which force maximize mode is turned on, if |
+// Checks the command line to see which force tablet mode is turned on, if |
// any. |
-MaximizeModeController::ForceTabletMode GetMaximizeMode() { |
+TabletModeController::ForceTabletMode GetTabletMode() { |
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; |
+ return TabletModeController::ForceTabletMode::CLAMSHELL; |
if (switch_value == switches::kAshForceTabletModeTouchView) |
- return MaximizeModeController::ForceTabletMode::TOUCHVIEW; |
+ return TabletModeController::ForceTabletMode::TOUCHVIEW; |
} |
- return MaximizeModeController::ForceTabletMode::NONE; |
+ return TabletModeController::ForceTabletMode::NONE; |
} |
} // namespace |
-MaximizeModeController::MaximizeModeController() |
+TabletModeController::TabletModeController() |
: have_seen_accelerometer_data_(false), |
can_detect_lid_angle_(false), |
touchview_usage_interval_start_time_(base::Time::Now()), |
@@ -116,9 +116,9 @@ MaximizeModeController::MaximizeModeController() |
ShellPort::Get()->RecordUserMetricsAction( |
UMA_MAXIMIZE_MODE_INITIALLY_DISABLED); |
- // TODO(jonross): Do not create MaximizeModeController if the flag is |
+ // TODO(jonross): Do not create TabletModeController if the flag is |
// unavailable. This will require refactoring |
- // IsMaximizeModeWindowManagerEnabled to check for the existance of the |
+ // IsTabletModeWindowManagerEnabled to check for the existance of the |
// controller. |
if (IsEnabled()) { |
ShellPort::Get()->AddDisplayObserver(this); |
@@ -128,10 +128,10 @@ MaximizeModeController::MaximizeModeController() |
chromeos::DBusThreadManager::Get()->GetPowerManagerClient(); |
power_manager_client->AddObserver(this); |
power_manager_client->GetSwitchStates(base::Bind( |
- &MaximizeModeController::OnGetSwitchStates, weak_factory_.GetWeakPtr())); |
+ &TabletModeController::OnGetSwitchStates, weak_factory_.GetWeakPtr())); |
} |
-MaximizeModeController::~MaximizeModeController() { |
+TabletModeController::~TabletModeController() { |
Shell::Get()->RemoveShellObserver(this); |
if (IsEnabled()) { |
@@ -142,38 +142,37 @@ MaximizeModeController::~MaximizeModeController() { |
this); |
} |
-bool MaximizeModeController::CanEnterMaximizeMode() { |
+bool TabletModeController::CanEnterTabletMode() { |
// If we have ever seen accelerometer data, then HandleHingeRotation may |
- // trigger maximize mode at some point in the future. |
- // All TouchView-enabled devices can enter maximized mode. |
+ // trigger tablet mode at some point in the future. |
+ // All TouchView-enabled devices can enter tablet mode. |
return have_seen_accelerometer_data_ || IsEnabled(); |
} |
-// TODO(jcliang): Hide or remove EnableMaximizeModeWindowManager |
+// TODO(jcliang): Hide or remove EnableTabletModeWindowManager |
// (http://crbug.com/620241). |
-void MaximizeModeController::EnableMaximizeModeWindowManager( |
- bool should_enable) { |
- bool is_enabled = !!maximize_mode_window_manager_.get(); |
+void TabletModeController::EnableTabletModeWindowManager(bool should_enable) { |
+ bool is_enabled = !!tablet_mode_window_manager_.get(); |
if (should_enable == is_enabled) |
return; |
if (should_enable) { |
- maximize_mode_window_manager_.reset(new MaximizeModeWindowManager()); |
- // TODO(jonross): Move the maximize mode notifications from ShellObserver |
- // to MaximizeModeController::Observer |
+ tablet_mode_window_manager_.reset(new TabletModeWindowManager()); |
+ // TODO(jonross): Move the tablet mode notifications from ShellObserver |
+ // to TabletModeController::Observer |
ShellPort::Get()->RecordUserMetricsAction(UMA_MAXIMIZE_MODE_ENABLED); |
- Shell::Get()->NotifyMaximizeModeStarted(); |
+ Shell::Get()->NotifyTabletModeStarted(); |
observers_.ForAllPtrs([](mojom::TouchViewObserver* observer) { |
observer->OnTouchViewToggled(true); |
}); |
} else { |
- maximize_mode_window_manager_->SetIgnoreWmEventsForExit(); |
- Shell::Get()->NotifyMaximizeModeEnding(); |
- maximize_mode_window_manager_.reset(); |
+ tablet_mode_window_manager_->SetIgnoreWmEventsForExit(); |
+ Shell::Get()->NotifyTabletModeEnding(); |
+ tablet_mode_window_manager_.reset(); |
ShellPort::Get()->RecordUserMetricsAction(UMA_MAXIMIZE_MODE_DISABLED); |
- Shell::Get()->NotifyMaximizeModeEnded(); |
+ Shell::Get()->NotifyTabletModeEnded(); |
observers_.ForAllPtrs([](mojom::TouchViewObserver* observer) { |
observer->OnTouchViewToggled(false); |
@@ -181,23 +180,22 @@ void MaximizeModeController::EnableMaximizeModeWindowManager( |
} |
} |
-bool MaximizeModeController::IsMaximizeModeWindowManagerEnabled() const { |
- return maximize_mode_window_manager_.get() != NULL; |
+bool TabletModeController::IsTabletModeWindowManagerEnabled() const { |
+ return tablet_mode_window_manager_.get() != NULL; |
} |
-void MaximizeModeController::AddWindow(aura::Window* window) { |
- if (IsMaximizeModeWindowManagerEnabled()) |
- maximize_mode_window_manager_->AddWindow(window); |
+void TabletModeController::AddWindow(aura::Window* window) { |
+ if (IsTabletModeWindowManagerEnabled()) |
+ tablet_mode_window_manager_->AddWindow(window); |
} |
-void MaximizeModeController::BindRequest( |
- mojom::TouchViewManagerRequest request) { |
+void TabletModeController::BindRequest(mojom::TouchViewManagerRequest request) { |
bindings_.AddBinding(this, std::move(request)); |
} |
-void MaximizeModeController::OnAccelerometerUpdated( |
+void TabletModeController::OnAccelerometerUpdated( |
scoped_refptr<const chromeos::AccelerometerUpdate> update) { |
- if (!AllowEnterExitMaximizeMode()) |
+ if (!AllowEnterExitTabletMode()) |
return; |
have_seen_accelerometer_data_ = true; |
@@ -216,8 +214,8 @@ void MaximizeModeController::OnAccelerometerUpdated( |
return; |
} |
- // Whether or not we enter maximize mode affects whether we handle screen |
- // rotation, so determine whether to enter maximize mode first. |
+ // Whether or not we enter tablet mode affects whether we handle screen |
+ // rotation, so determine whether to enter tablet mode first. |
if (ui::IsAccelerometerReadingStable(*update, |
chromeos::ACCELEROMETER_SOURCE_SCREEN) && |
ui::IsAccelerometerReadingStable( |
@@ -231,23 +229,23 @@ void MaximizeModeController::OnAccelerometerUpdated( |
} |
} |
-void MaximizeModeController::LidEventReceived( |
+void TabletModeController::LidEventReceived( |
chromeos::PowerManagerClient::LidState state, |
const base::TimeTicks& time) { |
- if (!AllowEnterExitMaximizeMode()) |
+ if (!AllowEnterExitTabletMode()) |
return; |
const bool open = state == chromeos::PowerManagerClient::LidState::OPEN; |
if (open) |
last_lid_open_time_ = time; |
lid_is_closed_ = !open; |
- LeaveMaximizeMode(); |
+ LeaveTabletMode(); |
} |
-void MaximizeModeController::TabletModeEventReceived( |
+void TabletModeController::TabletModeEventReceived( |
chromeos::PowerManagerClient::TabletMode mode, |
const base::TimeTicks& time) { |
- if (!AllowEnterExitMaximizeMode()) |
+ if (!AllowEnterExitTabletMode()) |
return; |
const bool on = mode == chromeos::PowerManagerClient::TabletMode::ON; |
@@ -259,29 +257,28 @@ void MaximizeModeController::TabletModeEventReceived( |
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 |
+ // when |on|. However we wish to exit tablet mode at a smaller angle, so |
// when |on| is false we ignore if it is possible to calculate the lid angle. |
- if (on && !IsMaximizeModeWindowManagerEnabled()) { |
- EnterMaximizeMode(); |
- } else if (!on && IsMaximizeModeWindowManagerEnabled() && |
+ if (on && !IsTabletModeWindowManagerEnabled()) { |
+ EnterTabletMode(); |
+ } else if (!on && IsTabletModeWindowManagerEnabled() && |
!can_detect_lid_angle_) { |
- LeaveMaximizeMode(); |
+ LeaveTabletMode(); |
} |
} |
-void MaximizeModeController::SuspendImminent() { |
+void TabletModeController::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) { |
+void TabletModeController::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(); |
} |
-void MaximizeModeController::HandleHingeRotation( |
+void TabletModeController::HandleHingeRotation( |
scoped_refptr<const chromeos::AccelerometerUpdate> update) { |
static const gfx::Vector3dF hinge_vector(1.0f, 0.0f, 0.0f); |
gfx::Vector3dF base_reading(ui::ConvertAccelerometerReadingToVector3dF( |
@@ -338,72 +335,71 @@ void MaximizeModeController::HandleHingeRotation( |
if (is_angle_stable) |
last_lid_open_time_ = base::TimeTicks(); |
- // Toggle maximize mode on or off when corresponding thresholds are passed. |
- if (IsMaximizeModeWindowManagerEnabled() && is_angle_stable && |
- lid_angle <= kExitMaximizeModeAngle) { |
- LeaveMaximizeMode(); |
- } else if (!IsMaximizeModeWindowManagerEnabled() && !lid_is_closed_ && |
- lid_angle >= kEnterMaximizeModeAngle && |
+ // Toggle tablet mode on or off when corresponding thresholds are passed. |
+ if (IsTabletModeWindowManagerEnabled() && is_angle_stable && |
+ lid_angle <= kExitTabletModeAngle) { |
+ LeaveTabletMode(); |
+ } else if (!IsTabletModeWindowManagerEnabled() && !lid_is_closed_ && |
+ lid_angle >= kEnterTabletModeAngle && |
(is_angle_stable || !WasLidOpenedRecently())) { |
- EnterMaximizeMode(); |
+ EnterTabletMode(); |
} |
} |
-void MaximizeModeController::EnterMaximizeMode() { |
+void TabletModeController::EnterTabletMode() { |
// Always reset first to avoid creation before destruction of a previous |
// object. |
event_blocker_ = |
ShellPort::Get()->CreateScopedDisableInternalMouseAndKeyboard(); |
- if (IsMaximizeModeWindowManagerEnabled()) |
+ if (IsTabletModeWindowManagerEnabled()) |
return; |
- EnableMaximizeModeWindowManager(true); |
+ EnableTabletModeWindowManager(true); |
} |
-void MaximizeModeController::LeaveMaximizeMode() { |
+void TabletModeController::LeaveTabletMode() { |
event_blocker_.reset(); |
- if (!IsMaximizeModeWindowManagerEnabled()) |
+ if (!IsTabletModeWindowManagerEnabled()) |
return; |
- EnableMaximizeModeWindowManager(false); |
+ EnableTabletModeWindowManager(false); |
} |
-// Called after maximize mode has started, windows might still animate though. |
-void MaximizeModeController::OnMaximizeModeStarted() { |
+// Called after tablet mode has started, windows might still animate though. |
+void TabletModeController::OnTabletModeStarted() { |
RecordTouchViewUsageInterval(TOUCH_VIEW_INTERVAL_INACTIVE); |
} |
-// Called after maximize mode has ended, windows might still be returning to |
+// Called after tablet mode has ended, windows might still be returning to |
// their original position. |
-void MaximizeModeController::OnMaximizeModeEnded() { |
+void TabletModeController::OnTabletModeEnded() { |
RecordTouchViewUsageInterval(TOUCH_VIEW_INTERVAL_ACTIVE); |
} |
-void MaximizeModeController::OnShellInitialized() { |
- force_tablet_mode_ = GetMaximizeMode(); |
+void TabletModeController::OnShellInitialized() { |
+ force_tablet_mode_ = GetTabletMode(); |
if (force_tablet_mode_ == ForceTabletMode::TOUCHVIEW) |
- EnterMaximizeMode(); |
+ EnterTabletMode(); |
} |
-void MaximizeModeController::OnDisplayConfigurationChanged() { |
+void TabletModeController::OnDisplayConfigurationChanged() { |
if (!display::Display::HasInternalDisplay() || |
!ShellPort::Get()->IsActiveDisplayId( |
display::Display::InternalDisplayId())) { |
- LeaveMaximizeMode(); |
- } else if (tablet_mode_switch_is_on_ && |
- !IsMaximizeModeWindowManagerEnabled()) { |
+ LeaveTabletMode(); |
+ } else if (tablet_mode_switch_is_on_ && !IsTabletModeWindowManagerEnabled()) { |
// The internal display has returned, as we are exiting docked mode. |
- // The device is still in tablet mode, so trigger maximize mode, as this |
+ // The device is still in tablet mode, so trigger tablet mode, as this |
// switch leads to the ignoring of accelerometer events. When the switch is |
// not set the next stable accelerometer readings will trigger maximize |
// mode. |
- EnterMaximizeMode(); |
+ EnterTabletMode(); |
} |
} |
-void MaximizeModeController::RecordTouchViewUsageInterval( |
+void TabletModeController::RecordTouchViewUsageInterval( |
TouchViewIntervalType type) { |
- if (!CanEnterMaximizeMode()) |
+ if (!CanEnterTabletMode()) |
return; |
base::Time current_time = base::Time::Now(); |
@@ -422,28 +418,28 @@ void MaximizeModeController::RecordTouchViewUsageInterval( |
touchview_usage_interval_start_time_ = current_time; |
} |
-MaximizeModeController::TouchViewIntervalType |
-MaximizeModeController::CurrentTouchViewIntervalType() { |
- if (IsMaximizeModeWindowManagerEnabled()) |
+TabletModeController::TouchViewIntervalType |
+TabletModeController::CurrentTouchViewIntervalType() { |
+ if (IsTabletModeWindowManagerEnabled()) |
return TOUCH_VIEW_INTERVAL_ACTIVE; |
return TOUCH_VIEW_INTERVAL_INACTIVE; |
} |
-void MaximizeModeController::AddObserver(mojom::TouchViewObserverPtr observer) { |
- observer->OnTouchViewToggled(IsMaximizeModeWindowManagerEnabled()); |
+void TabletModeController::AddObserver(mojom::TouchViewObserverPtr observer) { |
+ observer->OnTouchViewToggled(IsTabletModeWindowManagerEnabled()); |
observers_.AddPtr(std::move(observer)); |
} |
-bool MaximizeModeController::AllowEnterExitMaximizeMode() const { |
+bool TabletModeController::AllowEnterExitTabletMode() const { |
return force_tablet_mode_ == ForceTabletMode::NONE; |
} |
-void MaximizeModeController::OnChromeTerminating() { |
+void TabletModeController::OnChromeTerminating() { |
// 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()) { |
+ if (CanEnterTabletMode()) { |
UMA_HISTOGRAM_CUSTOM_COUNTS("Ash.TouchView.TouchViewActiveTotal", |
total_touchview_time_.InMinutes(), 1, |
base::TimeDelta::FromDays(7).InMinutes(), 50); |
@@ -460,14 +456,14 @@ void MaximizeModeController::OnChromeTerminating() { |
} |
} |
-void MaximizeModeController::OnGetSwitchStates( |
+void TabletModeController::OnGetSwitchStates( |
chromeos::PowerManagerClient::LidState lid_state, |
chromeos::PowerManagerClient::TabletMode tablet_mode) { |
LidEventReceived(lid_state, base::TimeTicks::Now()); |
TabletModeEventReceived(tablet_mode, base::TimeTicks::Now()); |
} |
-bool MaximizeModeController::WasLidOpenedRecently() const { |
+bool TabletModeController::WasLidOpenedRecently() const { |
if (last_lid_open_time_.is_null()) |
return false; |
@@ -477,7 +473,7 @@ bool MaximizeModeController::WasLidOpenedRecently() const { |
return elapsed_time.InSeconds() <= kLidRecentlyOpenedDurationSeconds; |
} |
-void MaximizeModeController::SetTickClockForTest( |
+void TabletModeController::SetTickClockForTest( |
std::unique_ptr<base::TickClock> tick_clock) { |
DCHECK(tick_clock_); |
tick_clock_ = std::move(tick_clock); |