(fix landed) Reland of name MaximizeMode to TabletMode

chrome/browser/ui/ash/multi_user/multi_user_window_manager_chromeos_unittest.cc

 // Copyright 2013 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 <stddef.h>
 
 #include "ash/content/shell_content_state.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/ash_test_environment_content.h"
 #include "ash/test/ash_test_helper.h"
 #include "ash/test/test_shell_delegate.h"
-#include "ash/wm/maximize_mode/maximize_mode_controller.h"
-#include "ash/wm/maximize_mode/maximize_mode_window_manager.h"
 #include "ash/wm/mru_window_tracker.h"
+#include "ash/wm/tablet_mode/tablet_mode_controller.h"
+#include "ash/wm/tablet_mode/tablet_mode_window_manager.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/wm_event.h"
 #include "ash/wm_window.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
@@ skipping 234 matching lines @@
   // Return the user id of the wallpaper which is currently set.
   const std::string& GetWallpaperUserIdForTest() {
     return multi_user_window_manager_->animation_->wallpaper_user_id_for_test();
   }
 
   // Returns true if the given window covers the screen.
   bool CoversScreen(aura::Window* window) {
     return chrome::UserSwitchAnimatorChromeOS::CoversScreen(window);
   }
 
-  // Create a maximize mode window manager.
-  MaximizeModeWindowManager* CreateMaximizeModeWindowManager() {
-    EXPECT_FALSE(maximize_mode_window_manager());
-    Shell::Get()->maximize_mode_controller()->EnableMaximizeModeWindowManager(
-        true);
-    return maximize_mode_window_manager();
+  // Create a tablet mode window manager.
+  TabletModeWindowManager* CreateTabletModeWindowManager() {
+    EXPECT_FALSE(tablet_mode_window_manager());
+    Shell::Get()->tablet_mode_controller()->EnableTabletModeWindowManager(true);
+    return tablet_mode_window_manager();
   }
 
-  MaximizeModeWindowManager* maximize_mode_window_manager() {
+  TabletModeWindowManager* tablet_mode_window_manager() {
     return Shell::Get()
-        ->maximize_mode_controller()
-        ->maximize_mode_window_manager_.get();
+        ->tablet_mode_controller()
+        ->tablet_mode_window_manager_.get();
   }
 
  private:
   // These get created for each session.
   aura::Window::Windows windows_;
 
   // The instance of the MultiUserWindowManager.
   chrome::MultiUserWindowManagerChromeOS* multi_user_window_manager_;
 
   // Owned by |user_manager_enabler_|.
   chromeos::FakeChromeUserManager* fake_user_manager_ = nullptr;
 
   std::unique_ptr<TestingProfileManager> profile_manager_;
 
   chromeos::ScopedUserManagerEnabler user_manager_enabler_;
 
   // The maximized window manager (if enabled).
-  std::unique_ptr<MaximizeModeWindowManager> maximize_mode_window_manager_;
+  std::unique_ptr<TabletModeWindowManager> tablet_mode_window_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(MultiUserWindowManagerChromeOSTest);
 };
 
 void MultiUserWindowManagerChromeOSTest::SetUp() {
   ash_test_helper()->set_test_shell_delegate(new TestShellDelegateChromeOS);
   ash::test::AshTestEnvironmentContent* test_environment =
       static_cast<ash::test::AshTestEnvironmentContent*>(
           ash_test_helper()->ash_test_environment());
   test_environment->set_content_state(new ::TestShellContentState);
@@ skipping 535 matching lines @@
   ShowWindowForUserNoUserTransition(window(1), account_id_B);
   ShowWindowForUserNoUserTransition(window(2), account_id_A);
   ShowWindowForUserNoUserTransition(window(3), account_id_A);
   EXPECT_EQ("H[A,B], H[A,B], S[B,A], H[B,A]", GetStatus());
   StartUserTransitionAnimation(account_id_B);
   EXPECT_EQ("S[A,B], H[A,B], H[B,A], H[B,A]", GetStatus());
   StartUserTransitionAnimation(account_id_A);
   EXPECT_EQ("H[A,B], H[A,B], S[B,A], H[B,A]", GetStatus());
 }
 
-// Test that in case of an activated maximize mode, windows from other users get
+// Test that in case of an activated tablet mode, windows from other users get
 // maximized after a user switch.
-TEST_F(MultiUserWindowManagerChromeOSTest, MaximizeModeInteraction) {
+TEST_F(MultiUserWindowManagerChromeOSTest, TabletModeInteraction) {
   SetUpForThisManyWindows(2);
 
   const AccountId account_id_A(AccountId::FromUserEmail("A"));
   const AccountId account_id_B(AccountId::FromUserEmail("B"));
 
   multi_user_window_manager()->SetWindowOwner(window(0), account_id_A);
   multi_user_window_manager()->SetWindowOwner(window(1), account_id_B);
 
   EXPECT_FALSE(wm::GetWindowState(window(0))->IsMaximized());
   EXPECT_FALSE(wm::GetWindowState(window(1))->IsMaximized());
 
-  MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
+  TabletModeWindowManager* manager = CreateTabletModeWindowManager();
   ASSERT_TRUE(manager);
 
   EXPECT_TRUE(wm::GetWindowState(window(0))->IsMaximized());
   EXPECT_FALSE(wm::GetWindowState(window(1))->IsMaximized());
 
   // After we start switching to B, the windows of user B should maximize.
   StartUserTransitionAnimation(account_id_B);
 
   EXPECT_TRUE(wm::GetWindowState(window(0))->IsMaximized());
   EXPECT_TRUE(wm::GetWindowState(window(1))->IsMaximized());
@@ skipping 695 matching lines @@
   user_manager()->SwitchActiveUser(account_id_B);
   multi_user_window_manager()->ActiveUserChanged(
       user_manager()->FindUser(account_id_B));
   EXPECT_EQ(browser.get(), BrowserList::GetInstance()->GetLastActive());
   EXPECT_EQ(nullptr, wm::GetActiveWindow());
   EXPECT_EQ(nullptr, ChromeNewWindowClient::GetActiveBrowser());
 }
 
 }  // namespace test
 }  // namespace ash