chromeos: Rename ash::WmShelf to Shelf

ash/root_window_controller.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 "ash/root_window_controller.h"
 
 #include <algorithm>
 #include <queue>
 #include <vector>
 
 #include "ash/ash_constants.h"
 #include "ash/ash_switches.h"
 #include "ash/ash_touch_exploration_manager_chromeos.h"
 #include "ash/focus_cycler.h"
 #include "ash/high_contrast/high_contrast_controller.h"
 #include "ash/host/ash_window_tree_host.h"
 #include "ash/login_status.h"
 #include "ash/public/cpp/config.h"
 #include "ash/public/cpp/shelf_types.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_settings.h"
 #include "ash/screen_util.h"
 #include "ash/session/session_controller.h"
+#include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shelf/shelf_window_targeter.h"
-#include "ash/shelf/wm_shelf.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_port.h"
 #include "ash/system/status_area_layout_manager.h"
 #include "ash/system/status_area_widget.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "ash/touch/touch_hud_debug.h"
 #include "ash/touch/touch_hud_projection.h"
 #include "ash/touch/touch_observer_hud.h"
 #include "ash/wallpaper/wallpaper_delegate.h"
@@ skipping 309 matching lines @@
 
 wm::WorkspaceWindowState RootWindowController::GetWorkspaceWindowState() {
   return workspace_controller_ ? workspace_controller()->GetWindowState()
                                : wm::WORKSPACE_WINDOW_STATE_DEFAULT;
 }
 
 void RootWindowController::InitializeShelf() {
   if (shelf_initialized_)
     return;
   shelf_initialized_ = true;
-  wm_shelf_->NotifyShelfInitialized();
+  shelf_->NotifyShelfInitialized();
 
-  // TODO(jamescook): Pass |wm_shelf_| into the constructors for these layout
+  // TODO(jamescook): Pass |shelf_| into the constructors for these layout
   // managers.
   if (panel_layout_manager_)
-    panel_layout_manager_->SetShelf(wm_shelf_.get());
+    panel_layout_manager_->SetShelf(shelf_.get());
 
   // TODO(jamescook): Eliminate this. Refactor AttachedPanelWidgetTargeter's
-  // access to WmShelf.
+  // access to Shelf.
   Shell::Get()->NotifyShelfCreatedForRootWindow(WmWindow::Get(GetRootWindow()));
 
-  wm_shelf_->shelf_widget()->PostCreateShelf();
+  shelf_->shelf_widget()->PostCreateShelf();
 }
 
 ShelfLayoutManager* RootWindowController::GetShelfLayoutManager() {
-  return wm_shelf_->shelf_layout_manager();
+  return shelf_->shelf_layout_manager();
 }
 
 SystemModalContainerLayoutManager*
 RootWindowController::GetSystemModalLayoutManager(aura::Window* window) {
   aura::Window* modal_container = nullptr;
   if (window) {
     aura::Window* window_container = wm::GetContainerForWindow(window);
     if (window_container &&
         window_container->id() >= kShellWindowId_LockScreenContainer) {
       modal_container = GetContainer(kShellWindowId_LockSystemModalContainer);
     } else {
       modal_container = GetContainer(kShellWindowId_SystemModalContainer);
     }
   } else {
     int modal_window_id =
         Shell::Get()->session_controller()->IsUserSessionBlocked()
             ? kShellWindowId_LockSystemModalContainer
             : kShellWindowId_SystemModalContainer;
     modal_container = GetContainer(modal_window_id);
   }
   return modal_container ? static_cast<SystemModalContainerLayoutManager*>(
                                modal_container->layout_manager())
                          : nullptr;
 }
 
 StatusAreaWidget* RootWindowController::GetStatusAreaWidget() {
-  ShelfWidget* shelf_widget = wm_shelf_->shelf_widget();
+  ShelfWidget* shelf_widget = shelf_->shelf_widget();
   return shelf_widget ? shelf_widget->status_area_widget() : nullptr;
 }
 
 SystemTray* RootWindowController::GetSystemTray() {
   // We assume in throughout the code that this will not return NULL. If code
   // triggers this for valid reasons, it should test status_area_widget first.
-  CHECK(wm_shelf_->shelf_widget()->status_area_widget());
-  return wm_shelf_->shelf_widget()->status_area_widget()->system_tray();
+  CHECK(shelf_->shelf_widget()->status_area_widget());
+  return shelf_->shelf_widget()->status_area_widget()->system_tray();
 }
 
 bool RootWindowController::CanWindowReceiveEvents(aura::Window* window) {
   if (GetRootWindow() != window->GetRootWindow())
     return false;
 
   // Always allow events to fall through to the virtual keyboard even if
   // displaying a system modal dialog.
   if (IsVirtualKeyboardWindow(window))
     return true;
@@ skipping 132 matching lines @@
   // Deactivate keyboard container before closing child windows and shutting
   // down associated layout managers.
   DeactivateKeyboard(keyboard::KeyboardController::GetInstance());
 
   // |panel_layout_manager_| needs to be shut down before windows are destroyed.
   if (panel_layout_manager_) {
     panel_layout_manager_->Shutdown();
     panel_layout_manager_ = nullptr;
   }
 
-  WmShelf* shelf = GetShelf();
+  Shelf* shelf = GetShelf();
   shelf->ShutdownShelfWidget();
 
   workspace_controller_.reset();
 
   // Explicitly destroy top level windows. We do this because such windows may
   // query the RootWindow for state.
   aura::WindowTracker non_toplevel_windows;
   WmWindow* root = GetWindow();
   non_toplevel_windows.Add(root->aura_window());
   while (!non_toplevel_windows.windows().empty()) {
@@ skipping 25 matching lines @@
   aura::client::SetTooltipClient(GetRootWindow(), nullptr);
 }
 
 void RootWindowController::MoveWindowsTo(aura::Window* dst) {
   // Clear the workspace controller, so it doesn't incorrectly update the shelf.
   workspace_controller_.reset();
   ReparentAllWindows(GetRootWindow(), dst);
 }
 
 void RootWindowController::UpdateShelfVisibility() {
-  wm_shelf_->UpdateVisibilityState();
+  shelf_->UpdateVisibilityState();
 }
 
 void RootWindowController::InitTouchHuds() {
   if (Shell::GetAshConfig() == Config::MASH)
     return;
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kAshTouchHud))
     set_touch_hud_debug(new TouchHudDebug(GetRootWindow()));
   if (Shell::Get()->is_touch_hud_projection_enabled())
@@ skipping 47 matching lines @@
 void RootWindowController::SetTouchAccessibilityAnchorPoint(
     const gfx::Point& anchor_point) {
   if (touch_exploration_manager_)
     touch_exploration_manager_->SetTouchAccessibilityAnchorPoint(anchor_point);
 }
 
 void RootWindowController::ShowContextMenu(const gfx::Point& location_in_screen,
                                            ui::MenuSourceType source_type) {
   ShellDelegate* delegate = Shell::Get()->shell_delegate();
   DCHECK(delegate);
-  menu_model_.reset(delegate->CreateContextMenu(wm_shelf_.get(), nullptr));
+  menu_model_.reset(delegate->CreateContextMenu(shelf_.get(), nullptr));
   if (!menu_model_)
     return;
 
   menu_model_adapter_ = base::MakeUnique<views::MenuModelAdapter>(
       menu_model_.get(),
       base::Bind(&RootWindowController::OnMenuClosed, base::Unretained(this)));
 
   // The wallpaper controller may not be set yet if the user clicked on the
   // status area before the initial animation completion. See crbug.com/222218
   if (!wallpaper_widget_controller())
     return;
 
   menu_runner_ = base::MakeUnique<views::MenuRunner>(
       menu_model_adapter_->CreateMenu(), views::MenuRunner::CONTEXT_MENU);
   menu_runner_->RunMenuAt(wallpaper_widget_controller()->widget(), nullptr,
                           gfx::Rect(location_in_screen, gfx::Size()),
                           views::MENU_ANCHOR_TOPLEFT, source_type);
 }
 
 void RootWindowController::UpdateAfterLoginStatusChange(LoginStatus status) {
   StatusAreaWidget* status_area_widget =
-      wm_shelf_->shelf_widget()->status_area_widget();
+      shelf_->shelf_widget()->status_area_widget();
   if (status_area_widget)
     status_area_widget->UpdateAfterLoginStatusChange(status);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindowController, private:
 
 RootWindowController::RootWindowController(
     AshWindowTreeHost* ash_host,
     aura::WindowTreeHost* window_tree_host)
     : ash_host_(ash_host),
       mus_window_tree_host_(window_tree_host),
       window_tree_host_(ash_host ? ash_host->AsWindowTreeHost()
                                  : window_tree_host),
-      wm_shelf_(base::MakeUnique<WmShelf>()) {
+      shelf_(base::MakeUnique<Shelf>()) {
   DCHECK((ash_host && !window_tree_host) || (!ash_host && window_tree_host));
 
   if (!root_window_controllers_)
     root_window_controllers_ = new std::vector<RootWindowController*>;
   root_window_controllers_->push_back(this);
 
   aura::Window* root_window = GetRootWindow();
   GetRootWindowSettings(root_window)->controller = this;
 
   stacking_controller_.reset(new StackingController);
@@ skipping 42 matching lines @@
   // http://crbug.com/679782
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshDisableTouchExplorationMode) &&
       Shell::GetAshConfig() != Config::MASH) {
     touch_exploration_manager_.reset(new AshTouchExplorationManager(this));
   }
 }
 
 void RootWindowController::InitLayoutManagers() {
   // Create the shelf and status area widgets.
-  DCHECK(!wm_shelf_->shelf_widget());
+  DCHECK(!shelf_->shelf_widget());
   GetShelf()->CreateShelfWidget(GetWindow());
 
   aura::Window* root = GetRootWindow();
   root_window_layout_manager_ = new wm::RootWindowLayoutManager(root);
   root->SetLayoutManager(root_window_layout_manager_);
 
   aura::Window* default_container =
       GetContainer(kShellWindowId_DefaultContainer);
   // Installs WorkspaceLayoutManager on |default_container|.
   workspace_controller_.reset(new WorkspaceController(default_container));
@@ skipping 23 matching lines @@
   // Create Panel layout manager
   aura::Window* panel_container = GetContainer(kShellWindowId_PanelContainer);
   panel_layout_manager_ = new PanelLayoutManager(panel_container);
   panel_container->SetLayoutManager(panel_layout_manager_);
 
   wm::WmSnapToPixelLayoutManager::InstallOnContainers(root);
 
   // Make it easier to resize windows that partially overlap the shelf. Must
   // occur after the ShelfLayoutManager is constructed by ShelfWidget.
   aura::Window* shelf_container = GetContainer(kShellWindowId_ShelfContainer);
-  WmWindow* wm_shelf_container = WmWindow::Get(shelf_container);
   shelf_container->SetEventTargeter(base::MakeUnique<ShelfWindowTargeter>(
-      wm_shelf_container, wm_shelf_.get()));
+      WmWindow::Get(shelf_container), shelf_.get()));
   aura::Window* status_container = GetContainer(kShellWindowId_StatusContainer);
-  WmWindow* wm_status_container = WmWindow::Get(status_container);
   status_container->SetEventTargeter(base::MakeUnique<ShelfWindowTargeter>(
-      wm_status_container, wm_shelf_.get()));
+      WmWindow::Get(status_container), shelf_.get()));
 
   panel_container_handler_ = base::MakeUnique<PanelWindowEventHandler>();
   GetContainer(kShellWindowId_PanelContainer)
       ->AddPreTargetHandler(panel_container_handler_.get());
 
   // Install an AttachedPanelWindowTargeter on the panel container to make it
   // easier to correctly target shelf buttons with touch.
   gfx::Insets mouse_extend(-kResizeOutsideBoundsSize, -kResizeOutsideBoundsSize,
                            -kResizeOutsideBoundsSize,
                            -kResizeOutsideBoundsSize);
@@ skipping 231 matching lines @@
     aura::Window* primary_root = Shell::GetPrimaryRootWindow();
     Shell::Get()->set_root_window_for_new_windows(
         primary_root == root ? nullptr : primary_root);
   }
 }
 
 void RootWindowController::OnMenuClosed() {
   menu_runner_.reset();
   menu_model_adapter_.reset();
   menu_model_.reset();
-  wm_shelf_->UpdateVisibilityState();
+  shelf_->UpdateVisibilityState();
 }
 
 void RootWindowController::OnTouchHudProjectionToggled(bool enabled) {
   if (enabled)
     EnableTouchHudProjection();
   else
     DisableTouchHudProjection();
 }
 
 RootWindowController* GetRootWindowController(const aura::Window* root_window) {
   return root_window ? GetRootWindowSettings(root_window)->controller : nullptr;
 }
 
 }  // namespace ash