Rename MaximizeMode to TabletMode

components/exo/keyboard.cc

 // Copyright 2015 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 "components/exo/keyboard.h"
 
 #include "components/exo/keyboard_delegate.h"
 #include "components/exo/keyboard_device_configuration_delegate.h"
 #include "components/exo/shell_surface.h"
 #include "components/exo/surface.h"
@@ skipping 57 matching lines @@
     if (event->key_code() == ui::VKEY_RETURN ||
         event->key_code() == ui::VKEY_BACK) {
       return true;
     }
   }
 
   return false;
 }
 
 bool IsPhysicalKeyboardEnabled() {
-  // The internal keyboard is enabled if maximize mode is not enabled.
-  if (!WMHelper::GetInstance()->IsMaximizeModeWindowManagerEnabled())
+  // The internal keyboard is enabled if tablet mode is not enabled.
+  if (!WMHelper::GetInstance()->IsTabletModeWindowManagerEnabled())
     return true;
 
   for (auto& keyboard :
        ui::InputDeviceManager::GetInstance()->GetKeyboardDevices()) {
     if (keyboard.type != ui::InputDeviceType::INPUT_DEVICE_INTERNAL)
       return true;
   }
   return false;
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // Keyboard, public:
 
 Keyboard::Keyboard(KeyboardDelegate* delegate) : delegate_(delegate) {
   auto* helper = WMHelper::GetInstance();
   helper->AddPostTargetHandler(this);
   helper->AddFocusObserver(this);
-  helper->AddMaximizeModeObserver(this);
+  helper->AddTabletModeObserver(this);
   helper->AddInputDeviceEventObserver(this);
   OnWindowFocused(helper->GetFocusedWindow(), nullptr);
 }
 
 Keyboard::~Keyboard() {
   delegate_->OnKeyboardDestroying(this);
   if (device_configuration_delegate_)
     device_configuration_delegate_->OnKeyboardDestroying(this);
   if (focus_)
     focus_->RemoveSurfaceObserver(this);
   auto* helper = WMHelper::GetInstance();
   helper->RemoveFocusObserver(this);
   helper->RemovePostTargetHandler(this);
-  helper->RemoveMaximizeModeObserver(this);
+  helper->RemoveTabletModeObserver(this);
   helper->RemoveInputDeviceEventObserver(this);
 }
 
 bool Keyboard::HasDeviceConfigurationDelegate() const {
   return !!device_configuration_delegate_;
 }
 
 void Keyboard::SetDeviceConfigurationDelegate(
     KeyboardDeviceConfigurationDelegate* delegate) {
   device_configuration_delegate_ = delegate;
@@ skipping 84 matching lines @@
 // ui::InputDeviceEventObserver overrides:
 
 void Keyboard::OnKeyboardDeviceConfigurationChanged() {
   if (device_configuration_delegate_) {
     device_configuration_delegate_->OnKeyboardTypeChanged(
         IsPhysicalKeyboardEnabled());
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// WMHelper::MaximizeModeObserver overrides:
+// WMHelper::TabletModeObserver overrides:
 
-void Keyboard::OnMaximizeModeStarted() {
+void Keyboard::OnTabletModeStarted() {
   OnKeyboardDeviceConfigurationChanged();
 }
 
-void Keyboard::OnMaximizeModeEnding() {}
+void Keyboard::OnTabletModeEnding() {}
 
-void Keyboard::OnMaximizeModeEnded() {
+void Keyboard::OnTabletModeEnded() {
   OnKeyboardDeviceConfigurationChanged();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Keyboard, private:
 
 Surface* Keyboard::GetEffectiveFocus(aura::Window* window) const {
   // Use window surface as effective focus.
   Surface* focus = Surface::AsSurface(window);
   if (!focus) {
     // Fallback to main surface.
     aura::Window* top_level_window = window->GetToplevelWindow();
     if (top_level_window)
       focus = ShellSurface::GetMainSurface(top_level_window);
   }
 
   return focus && delegate_->CanAcceptKeyboardEventsForSurface(focus) ? focus
                                                                       : nullptr;
 }
 
 }  // namespace exo