Rename MaximizeMode to TabletMode

chrome/browser/chromeos/display/display_preferences_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/chromeos/display/display_preferences.h"
 
 #include <stdint.h>
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "ash/display/display_util.h"
 #include "ash/display/resolution_notification_controller.h"
 #include "ash/display/screen_orientation_controller_chromeos.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
-#include "ash/wm/maximize_mode/maximize_mode_controller.h"
+#include "ash/wm/tablet_mode/tablet_mode_controller.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/display/display_configuration_observer.h"
 #include "chrome/browser/chromeos/login/users/mock_user_manager.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_browser_process.h"
@@ skipping 773 matching lines @@
   EXPECT_EQ("internal_off_external_on",
             local_state()->GetString(prefs::kDisplayPowerState));
 
   // Don't try to load
   local_state()->SetString(prefs::kDisplayPowerState, "all_off");
   LoadDisplayPreferences(false);
   EXPECT_EQ(chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON,
             shell->display_configurator()->requested_power_state());
 }
 
-// Tests that display configuration changes caused by MaximizeModeController
+// Tests that display configuration changes caused by TabletModeController
 // are not saved.
-TEST_F(DisplayPreferencesTest, DontSaveMaximizeModeControllerRotations) {
+TEST_F(DisplayPreferencesTest, DontSaveTabletModeControllerRotations) {
   ash::Shell* shell = ash::Shell::Get();
   display::Display::SetInternalDisplayId(
       display::Screen::GetScreen()->GetPrimaryDisplay().id());
   LoggedInAsUser();
   // Populate the properties.
   display_manager()->SetDisplayRotation(display::Display::InternalDisplayId(),
                                         display::Display::ROTATE_180,
                                         display::Display::ROTATION_SOURCE_USER);
   // Reset property to avoid rotation lock
   display_manager()->SetDisplayRotation(display::Display::InternalDisplayId(),
                                         display::Display::ROTATE_0,
                                         display::Display::ROTATION_SOURCE_USER);
 
-  // Open up 270 degrees to trigger maximize mode
+  // Open up 270 degrees to trigger tablet mode
   scoped_refptr<chromeos::AccelerometerUpdate> update(
       new chromeos::AccelerometerUpdate());
   update->Set(chromeos::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD, 0.0f, 0.0f,
              kMeanGravity);
   update->Set(chromeos::ACCELEROMETER_SOURCE_SCREEN, 0.0f, -kMeanGravity, 0.0f);
-  ash::MaximizeModeController* controller =
-      ash::Shell::Get()->maximize_mode_controller();
+  ash::TabletModeController* controller =
+      ash::Shell::Get()->tablet_mode_controller();
   controller->OnAccelerometerUpdated(update);
-  EXPECT_TRUE(controller->IsMaximizeModeWindowManagerEnabled());
+  EXPECT_TRUE(controller->IsTabletModeWindowManagerEnabled());
 
   // Trigger 90 degree rotation
   update->Set(chromeos::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD, -kMeanGravity,
              0.0f, 0.0f);
   update->Set(chromeos::ACCELEROMETER_SOURCE_SCREEN, -kMeanGravity, 0.0f, 0.0f);
   controller->OnAccelerometerUpdated(update);
   shell->screen_orientation_controller()->OnAccelerometerUpdated(update);
   EXPECT_EQ(display::Display::ROTATE_90, GetCurrentInternalDisplayRotation());
 
   const base::DictionaryValue* properties =
@@ skipping 82 matching lines @@
   EXPECT_EQ(current_rotation_lock, rotation_lock);
 
   int orientation;
   display::Display::Rotation current_rotation =
       GetCurrentInternalDisplayRotation();
   EXPECT_TRUE(properties->GetInteger("orientation", &orientation));
   EXPECT_EQ(current_rotation, orientation);
 }
 
 // Tests that rotation state is loaded without a user being logged in, and that
-// entering maximize mode applies the state.
+// entering tablet mode applies the state.
 TEST_F(DisplayPreferencesTest, LoadRotationNoLogin) {
   display::Display::SetInternalDisplayId(
       display::Screen::GetScreen()->GetPrimaryDisplay().id());
   ASSERT_FALSE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
 
   bool initial_rotation_lock = IsRotationLocked();
   ASSERT_FALSE(initial_rotation_lock);
   display::Display::Rotation initial_rotation =
       GetCurrentInternalDisplayRotation();
   ASSERT_EQ(display::Display::ROTATE_0, initial_rotation);
 
   StoreDisplayRotationPrefs(initial_rotation_lock);
   ASSERT_TRUE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
 
   StoreDisplayRotationPrefsForTest(true, display::Display::ROTATE_90);
   LoadDisplayPreferences(false);
 
   bool display_rotation_lock =
       display_manager()->registered_internal_display_rotation_lock();
   bool display_rotation =
       display_manager()->registered_internal_display_rotation();
   EXPECT_TRUE(display_rotation_lock);
   EXPECT_EQ(display::Display::ROTATE_90, display_rotation);
 
   bool rotation_lock = IsRotationLocked();
-  display::Display::Rotation before_maximize_mode_rotation =
+  display::Display::Rotation before_tablet_mode_rotation =
       GetCurrentInternalDisplayRotation();
 
-  // Settings should not be applied until maximize mode activates
+  // Settings should not be applied until tablet mode activates
   EXPECT_FALSE(rotation_lock);
-  EXPECT_EQ(display::Display::ROTATE_0, before_maximize_mode_rotation);
+  EXPECT_EQ(display::Display::ROTATE_0, before_tablet_mode_rotation);
 
-  // Open up 270 degrees to trigger maximize mode
+  // Open up 270 degrees to trigger tablet mode
   scoped_refptr<chromeos::AccelerometerUpdate> update(
       new chromeos::AccelerometerUpdate());
   update->Set(chromeos::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD, 0.0f, 0.0f,
              kMeanGravity);
   update->Set(chromeos::ACCELEROMETER_SOURCE_SCREEN, 0.0f, -kMeanGravity, 0.0f);
-  ash::MaximizeModeController* maximize_mode_controller =
-      ash::Shell::Get()->maximize_mode_controller();
-  maximize_mode_controller->OnAccelerometerUpdated(update);
-  EXPECT_TRUE(maximize_mode_controller->IsMaximizeModeWindowManagerEnabled());
+  ash::TabletModeController* tablet_mode_controller =
+      ash::Shell::Get()->tablet_mode_controller();
+  tablet_mode_controller->OnAccelerometerUpdated(update);
+  EXPECT_TRUE(tablet_mode_controller->IsTabletModeWindowManagerEnabled());
   bool screen_orientation_rotation_lock = IsRotationLocked();
-  display::Display::Rotation maximize_mode_rotation =
+  display::Display::Rotation tablet_mode_rotation =
       GetCurrentInternalDisplayRotation();
   EXPECT_TRUE(screen_orientation_rotation_lock);
-  EXPECT_EQ(display::Display::ROTATE_90, maximize_mode_rotation);
+  EXPECT_EQ(display::Display::ROTATE_90, tablet_mode_rotation);
 }
 
 // Tests that rotation lock being set causes the rotation state to be saved.
 TEST_F(DisplayPreferencesTest, RotationLockTriggersStore) {
   display::Display::SetInternalDisplayId(
       display::Screen::GetScreen()->GetPrimaryDisplay().id());
   ASSERT_FALSE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
 
   ash::Shell::Get()->screen_orientation_controller()->ToggleUserRotationLock();
 
@@ skipping 150 matching lines @@
 
   EXPECT_EQ(gfx::Rect(0, 0, 200, 200),
             display_manager()->GetDisplayForId(list[0]).bounds());
   EXPECT_EQ(gfx::Rect(-200, 0, 200, 200),
             display_manager()->GetDisplayForId(list[1]).bounds());
   EXPECT_EQ(gfx::Rect(-100, 200, 300, 300),
             display_manager()->GetDisplayForId(list[2]).bounds());
 }
 
 }  // namespace chromeos