Refactor: Shelf Widget

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 <vector>
 
 #include "ash/ash_constants.h"
 #include "ash/ash_switches.h"
 #include "ash/desktop_background/desktop_background_widget_controller.h"
 #include "ash/display/display_controller.h"
 #include "ash/display/display_manager.h"
 #include "ash/focus_cycler.h"
-#include "ash/shelf_types.h"
+#include "ash/shelf/shelf_layout_manager.h"
+#include "ash/shelf/shelf_types.h"
+#include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_factory.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/status_area_widget.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "ash/wm/base_layout_manager.h"
 #include "ash/wm/boot_splash_screen.h"
 #include "ash/wm/panel_layout_manager.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/root_window_layout_manager.h"
 #include "ash/wm/screen_dimmer.h"
-#include "ash/wm/shelf_layout_manager.h"
 #include "ash/wm/stacking_controller.h"
 #include "ash/wm/status_area_layout_manager.h"
 #include "ash/wm/system_background_controller.h"
 #include "ash/wm/system_modal_container_layout_manager.h"
 #include "ash/wm/toplevel_window_event_handler.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/workspace_controller.h"
 #include "base/command_line.h"
 #include "base/time.h"
 #include "ui/aura/client/activation_client.h"
@@ skipping 119 matching lines @@
   container->SetProperty(internal::kUsesScreenCoordinatesKey, true);
 }
 
 }  // namespace
 
 namespace internal {
 
 RootWindowController::RootWindowController(aura::RootWindow* root_window)
     : root_window_(root_window),
       root_window_layout_(NULL),
-      status_area_widget_(NULL),
       shelf_(NULL),
       panel_layout_manager_(NULL) {
   SetRootWindowController(root_window, this);
   screen_dimmer_.reset(new ScreenDimmer(root_window));
 
   stacking_controller_.reset(new ash::StackingController);
   aura::client::SetStackingClient(root_window, stacking_controller_.get());
 }
 
 RootWindowController::~RootWindowController() {
@@ skipping 30 matching lines @@
   SetRootWindowController(root_window_.get(), NULL);
   screen_dimmer_.reset();
   workspace_controller_.reset();
   // Forget with the display ID so that display lookup
   // ends up with invalid display.
   root_window_->ClearProperty(kDisplayIdKey);
   // And this root window should no longer process events.
   root_window_->PrepareForShutdown();
 
   system_background_.reset();
-
-  // Launcher widget has an InputMethodBridge that references to
-  // |input_method_filter_|'s |input_method_|. So explicitly release
-  // |launcher_| before |input_method_filter_|. And this needs to be
-  // after we delete all containers in case there are still live
-  // browser windows which access LauncherModel during close.
-  launcher_.reset();
 }
 
 SystemModalContainerLayoutManager*
 RootWindowController::GetSystemModalLayoutManager(aura::Window* window) {
   aura::Window* container = NULL;
   if (window) {
     if (window->parent() &&
         window->parent()->id() >= kShellWindowId_LockScreenContainer) {
       container = GetContainer(kShellWindowId_LockSystemModalContainer);
     } else {
@@ skipping 29 matching lines @@
       new WorkspaceController(default_container));
 
   aura::Window* always_on_top_container =
       GetContainer(kShellWindowId_AlwaysOnTopContainer);
   always_on_top_container->SetLayoutManager(
       new BaseLayoutManager(
           always_on_top_container->GetRootWindow()));
 }
 
 void RootWindowController::InitForPrimaryDisplay() {
-  DCHECK(!status_area_widget_);
+  DCHECK(!shelf_.get());
+  aura::Window* shelf_container =
+      GetContainer(ash::internal::kShellWindowId_ShelfContainer);
+  // TODO(harrym): Remove when status area is view.
   aura::Window* status_container =
       GetContainer(ash::internal::kShellWindowId_StatusContainer);
-  // Initialize Primary RootWindow specific items.
-  status_area_widget_ = new internal::StatusAreaWidget(status_container);
-  status_area_widget_->CreateTrayViews();
-  // Login screen manages status area visibility by itself.
-  ShellDelegate* shell_delegate = Shell::GetInstance()->delegate();
-  if (shell_delegate->IsSessionStarted())
-    status_area_widget_->Show();
-
-  Shell::GetInstance()->focus_cycler()->AddWidget(status_area_widget_);
-
-  internal::ShelfLayoutManager* shelf_layout_manager =
-      new internal::ShelfLayoutManager(status_area_widget_);
-  GetContainer(internal::kShellWindowId_LauncherContainer)->
-      SetLayoutManager(shelf_layout_manager);
-  shelf_ = shelf_layout_manager;
-
-  internal::StatusAreaLayoutManager* status_area_layout_manager =
-      new internal::StatusAreaLayoutManager(shelf_layout_manager);
-  GetContainer(internal::kShellWindowId_StatusContainer)->
-      SetLayoutManager(status_area_layout_manager);
-
-  shelf_layout_manager->set_workspace_controller(
-      workspace_controller());
-
-  workspace_controller()->SetShelf(shelf_);
+  shelf_.reset(new ash::ShelfWidget(
+      shelf_container, status_container, workspace_controller()));
 
   if (Shell::IsLauncherPerDisplayEnabled() ||
       root_window_ == Shell::GetPrimaryRootWindow()) {
     // Create Panel layout manager
     aura::Window* panel_container = GetContainer(
         internal::kShellWindowId_PanelContainer);
     panel_layout_manager_ =
         new internal::PanelLayoutManager(panel_container);
     panel_container_handler_.reset(
         new ToplevelWindowEventHandler(panel_container));
     panel_container->SetLayoutManager(panel_layout_manager_);
+    if (Shell::GetInstance()->delegate()->IsUserLoggedIn())

[Mr4D (OOO till 08-26), 2013/03/04 19:18:04]

Are you sure that you want to move this into the "if
(IsLauncherPerDisplayEnabled...) "section?

[Harry McCleave, 2013/03/04 20:29:24]

Done.

+      shelf_->CreateLauncher();
   }
-
-  if (shell_delegate->IsUserLoggedIn())
-    CreateLauncher();
 }
 
 void RootWindowController::CreateContainers() {
   CreateContainersInRootWindow(root_window_.get());
 }
 
 void RootWindowController::CreateSystemBackground(
     bool is_first_run_after_boot) {
   SkColor color = SK_ColorBLACK;
 #if defined(OS_CHROMEOS)
   if (is_first_run_after_boot)
     color = kChromeOsBootColor;
 #endif
   system_background_.reset(
       new SystemBackgroundController(root_window_.get(), color));
 
 #if defined(OS_CHROMEOS)
   // Make a copy of the system's boot splash screen so we can composite it
   // onscreen until the desktop background is ready.
   if (is_first_run_after_boot &&
       (CommandLine::ForCurrentProcess()->HasSwitch(
            switches::kAshCopyHostBackgroundAtBoot) ||
        CommandLine::ForCurrentProcess()->HasSwitch(
            switches::kAshAnimateFromBootSplashScreen)))
     boot_splash_screen_.reset(new BootSplashScreen(root_window_.get()));
 #endif
 }
 
-void RootWindowController::CreateLauncher() {
-  if (launcher_.get())
-    return;
-
-  aura::Window* default_container =
-      GetContainer(internal::kShellWindowId_DefaultContainer);
-  // Get the delegate first to make sure the launcher model is created.
-  LauncherDelegate* launcher_delegate =
-      Shell::GetInstance()->GetLauncherDelegate();
-  launcher_.reset(new Launcher(Shell::GetInstance()->launcher_model(),
-                               launcher_delegate,
-                               default_container,
-                               shelf_));
-
-  launcher_->SetFocusCycler(Shell::GetInstance()->focus_cycler());
-  shelf_->SetLauncher(launcher_.get());
-
-  if (panel_layout_manager_)
-    panel_layout_manager_->SetLauncher(launcher_.get());
-
-  ShellDelegate* delegate = Shell::GetInstance()->delegate();
-  if (delegate)
-    launcher_->SetVisible(delegate->IsSessionStarted());
-  launcher_->widget()->Show();
+void RootWindowController::OnLauncherCreated() {
+  panel_layout_manager_->SetLauncher(shelf_->launcher());

[Mr4D (OOO till 08-26), 2013/03/04 19:18:04]

Shouldn't this be: if (panel_layout_manager_) {..} like it was in the old code?

[Harry McCleave, 2013/03/04 20:29:24]

Done.

 }
 
 void RootWindowController::ShowLauncher() {
-  if (!launcher_.get())
+  if (!shelf_->launcher())

[Mr4D (OOO till 08-26), 2013/03/04 19:18:04]

Since shelf_ can also be NULL - shouldn't we test if it is != NULL?

[Harry McCleave, 2013/03/04 20:29:24]

Done.

     return;
-  launcher_->SetVisible(true);
-  status_area_widget_->Show();
+  shelf_->launcher()->SetVisible(true);
+  shelf_->status_area_widget()->Show();
 }
 
 void RootWindowController::OnLoginStateChanged(user::LoginStatus status) {
   // TODO(oshima): remove if when launcher per display is enabled by
   // default.
   if (shelf_)
-    shelf_->UpdateVisibilityState();
+    shelf_->shelf_layout_manager()->UpdateVisibilityState();
 }
 
 void RootWindowController::UpdateAfterLoginStatusChange(
     user::LoginStatus status) {
-  if (status_area_widget_)
-    status_area_widget_->UpdateAfterLoginStatusChange(status);
+  if (shelf_->status_area_widget())

[Mr4D (OOO till 08-26), 2013/03/04 19:18:04]

same here.

[Harry McCleave, 2013/03/04 20:29:24]

Done.

+    shelf_->status_area_widget()->UpdateAfterLoginStatusChange(status);
 }
 
 void RootWindowController::HandleInitialDesktopBackgroundAnimationStarted() {
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshAnimateFromBootSplashScreen) &&
       boot_splash_screen_.get()) {
     // Make the splash screen fade out so it doesn't obscure the desktop
     // wallpaper's brightness/grayscale animation.
     boot_splash_screen_->StartHideAnimation(
         base::TimeDelta::FromMilliseconds(kBootSplashScreenHideDurationMs));
   }
 }
 
 void RootWindowController::HandleDesktopBackgroundVisible() {
   system_background_->SetColor(SK_ColorBLACK);
   boot_splash_screen_.reset();
 }
 
 void RootWindowController::CloseChildWindows() {
-  // The status area needs to be shut down before the windows are destroyed.
-  if (status_area_widget_) {
-    status_area_widget_->Shutdown();
-    status_area_widget_ = NULL;
-  }
-
   // panel_layout_manager_ needs to be shut down before windows are destroyed.
   if (panel_layout_manager_) {
     panel_layout_manager_->Shutdown();
     panel_layout_manager_ = NULL;
   }
 
-  // Closing the windows frees the workspace controller.
-  if (shelf_)
-    shelf_->set_workspace_controller(NULL);
+  // TODO(HarryM): Remove when Status Area Widget is a child view.
+  if (shelf_.get() && shelf_->status_area_widget())
+    shelf_->status_area_widget()->Shutdown();
+
+  if (shelf_.get() && shelf_->shelf_layout_manager())
+    shelf_->shelf_layout_manager()->set_workspace_controller(NULL);
 
   // Close background widget first as it depends on tooltip.
   root_window_->SetProperty(kDesktopController,
       static_cast<DesktopBackgroundWidgetController*>(NULL));
   root_window_->SetProperty(kAnimatingDesktopController,
                             static_cast<AnimatingDesktopController*>(NULL));
 
   workspace_controller_.reset();
   aura::client::SetTooltipClient(root_window_.get(), NULL);
 
   while (!root_window_->children().empty()) {
     aura::Window* child = root_window_->children()[0];
     delete child;
   }
-  launcher_.reset();
-  // All containers are deleted, so reset shelf_.
-  shelf_ = NULL;
+
+  if (shelf_.get())

[Mr4D (OOO till 08-26), 2013/03/04 19:18:04]

You don't need the if (shelf_.get()) here - you can always reset.

[Harry McCleave, 2013/03/04 20:29:24]

Done.

+    shelf_.reset(NULL);
 }
 
 void RootWindowController::MoveWindowsTo(aura::RootWindow* dst) {
   aura::Window* focused = aura::client::GetFocusClient(dst)->GetFocusedWindow();
   aura::WindowTracker tracker;
   if (focused)
     tracker.Add(focused);
   aura::client::ActivationClient* activation_client =
       aura::client::GetActivationClient(dst);
   aura::Window* active = activation_client->GetActiveWindow();
@@ skipping 17 matching lines @@
   ReparentAllWindows(root_window_.get(), dst);
 
   // Restore focused or active window if it's still alive.
   if (focused && tracker.Contains(focused) && dst->Contains(focused)) {
     aura::client::GetFocusClient(dst)->FocusWindow(focused);
   } else if (active && tracker.Contains(active) && dst->Contains(active)) {
     activation_client->ActivateWindow(active);
   }
 }
 
+ShelfLayoutManager* RootWindowController::shelf_layout_manager() const {
+  return shelf_.get() ? shelf_->shelf_layout_manager() : NULL;

[Mr4D (OOO till 08-26), 2013/03/04 19:18:04]

Somehow this makes me worry. It could be that we return NULL here? So there are
a lot of calls which might crash (e.g. line 461). In the mentioned case I can
see that it would not be a new problem since shelf_ didn't get there tested in
the past either, but maybe there are other places where we should be more
careful?

[Harry McCleave, 2013/03/04 20:29:24]

Currently the classes that use this only exist once the shelf (and thus layout
manager) have been created so the assumption of the layout manager existing
was/is ok, however as more functions (eg helper alignment functions) get moved
from the layout manager to the shelf_widget this shortcut will be used less
(read hopefully not at all). 
On 2013/03/04 19:18:04, Mr4D wrote:

[Mr4D (OOO till 08-26), 2013/03/04 22:59:00]

Okay. Sounds good to me then.

+}
+
 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.
-  internal::StatusAreaWidget* status_area = status_area_widget();
-  CHECK(status_area);
-  return status_area->system_tray();
+  CHECK(shelf_.get() && shelf_->status_area_widget());
+  return shelf_->status_area_widget()->system_tray();
 }
 
 void RootWindowController::ShowContextMenu(
     const gfx::Point& location_in_screen) {
   aura::RootWindow* target = Shell::IsLauncherPerDisplayEnabled() ?
       root_window() : Shell::GetPrimaryRootWindow();
   DCHECK(Shell::GetInstance()->delegate());
   scoped_ptr<ui::MenuModel> menu_model(
       Shell::GetInstance()->delegate()->CreateContextMenu(target));
   if (!menu_model.get())
     return;
 
   views::MenuModelAdapter menu_model_adapter(menu_model.get());
   views::MenuRunner menu_runner(menu_model_adapter.CreateMenu());
   views::Widget* widget =
       root_window_->GetProperty(kDesktopController)->widget();
 
   if (menu_runner.RunMenuAt(
           widget, NULL, gfx::Rect(location_in_screen, gfx::Size()),
           views::MenuItemView::TOPLEFT, views::MenuRunner::CONTEXT_MENU) ==
       views::MenuRunner::MENU_DELETED)
     return;
 
   Shell::GetInstance()->UpdateShelfVisibility();
 }
 
 void RootWindowController::UpdateShelfVisibility() {
-  shelf_->UpdateVisibilityState();
-}
-
-void RootWindowController::SetShelfAutoHideBehavior(
-    ShelfAutoHideBehavior behavior) {
-  shelf_->SetAutoHideBehavior(behavior);
-}
-
-ShelfAutoHideBehavior RootWindowController::GetShelfAutoHideBehavior() const {
-  return shelf_->auto_hide_behavior();
-}
-
-bool RootWindowController::SetShelfAlignment(ShelfAlignment alignment) {
-  return shelf_->SetAlignment(alignment);
-}
-
-ShelfAlignment RootWindowController::GetShelfAlignment() {
-  return shelf_->GetAlignment();
+  shelf_->shelf_layout_manager()->UpdateVisibilityState();
 }
 
 bool RootWindowController::IsImmersiveMode() const {
   aura::Window* container = workspace_controller_->GetActiveWorkspaceWindow();
   for (size_t i = 0; i < container->children().size(); ++i) {
     aura::Window* child = container->children()[i];
     if (child->IsVisible() && child->GetProperty(kImmersiveModeKey))
       return true;
   }
   return false;
@@ skipping 63 matching lines @@
       always_on_top_container);
   SetUsesScreenCoordinates(always_on_top_container);
 
   aura::Window* panel_container = CreateContainer(
       kShellWindowId_PanelContainer,
       "PanelContainer",
       non_lock_screen_containers);
   SetUsesScreenCoordinates(panel_container);
 
   aura::Window* launcher_container =
-      CreateContainer(kShellWindowId_LauncherContainer,
+      CreateContainer(kShellWindowId_ShelfContainer,
                       "LauncherContainer",
                       non_lock_screen_containers);
   SetUsesScreenCoordinates(launcher_container);
 
   aura::Window* app_list_container =
       CreateContainer(kShellWindowId_AppListContainer,
                       "AppListContainer",
                       non_lock_screen_containers);
   SetUsesScreenCoordinates(app_list_container);
 
@@ skipping 69 matching lines @@
       "OverlayContainer",
       lock_screen_related_containers);
   SetUsesScreenCoordinates(overlay_container);
 
   CreateContainer(kShellWindowId_PowerButtonAnimationContainer,
                   "PowerButtonAnimationContainer", root_window) ;
 }
 
 }  // namespace internal
 }  // namespace ash