Move shelf/launcher/status_area_widget/panel_layout_manager to RootWindowController

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/desktop_background/desktop_background_widget_controller.h"
 #include "ash/display/display_controller.h"
 #include "ash/display/multi_display_manager.h"
+#include "ash/focus_cycler.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/wm/base_layout_manager.h"
+#include "ash/wm/panel_layout_manager.h"
+#include "ash/wm/panel_window_event_filter.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/shelf_types.h"
+#include "ash/wm/status_area_layout_manager.h"
 #include "ash/wm/system_modal_container_layout_manager.h"
 #include "ash/wm/toplevel_window_event_handler.h"
 #include "ash/wm/visibility_controller.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/workspace/colored_window_controller.h"
 #include "ash/wm/workspace_controller.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/tooltip_client.h"
@@ skipping 105 matching lines @@
 // use the virtual screeen coordinates instead of parent.
 void SetUsesScreenCoordinates(aura::Window* container) {
   container->SetProperty(internal::kUsesScreenCoordinatesKey, true);
 }
 
 }  // namespace
 
 namespace internal {
 
 RootWindowController::RootWindowController(aura::RootWindow* root_window)
-    : root_window_(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));
 }
 
 RootWindowController::~RootWindowController() {
   Shutdown();
   root_window_.reset();
 }
 
 void RootWindowController::Shutdown() {
   CloseChildWindows();
   if (Shell::GetActiveRootWindow() == root_window_.get()) {
     Shell::GetInstance()->set_active_root_window(
         Shell::GetPrimaryRootWindow() == root_window_.get() ?
         NULL : Shell::GetPrimaryRootWindow());
   }
   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();
+
+  // 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() {
   return static_cast<SystemModalContainerLayoutManager*>(
       GetContainer(kShellWindowId_SystemModalContainer)->layout_manager());
 }
 
 aura::Window* RootWindowController::GetContainer(int container_id) {
   return root_window_->GetChildById(container_id);
@@ skipping 10 matching lines @@
   workspace_controller_.reset(
       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_);
+  ShellDelegate* delegate = Shell::GetInstance()->delegate();
+
+  // Initialize Primary RootWindow specific items.
+  status_area_widget_ = new internal::StatusAreaWidget();
+  status_area_widget_->CreateTrayViews(delegate);
+  // Login screen manages status area visibility by itself.
+  if (delegate && 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_);
+
+  // Create Panel layout manager
+  aura::Window* panel_container = GetContainer(
+      internal::kShellWindowId_PanelContainer);
+  panel_layout_manager_ =
+      new internal::PanelLayoutManager(panel_container);
+  panel_container->SetEventFilter(
+      new internal::PanelWindowEventFilter(
+          panel_container, panel_layout_manager_));
+  panel_container->SetLayoutManager(panel_layout_manager_);
+
+  if (!delegate || 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 = kBootSystemBackgroundColor;
 #endif
   background_.reset(new ColoredWindowController(
       root_window_->GetChildById(kShellWindowId_SystemBackgroundContainer),
       "SystemBackground"));
   background_->SetColor(color);
   background_->GetWidget()->Show();
 }
 
+void RootWindowController::CreateLauncher() {
+  if (launcher_.get())
+    return;
+
+  aura::Window* default_container =
+      GetContainer(internal::kShellWindowId_DefaultContainer);
+  launcher_.reset(new Launcher(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::ShowLauncher() {
+  if (!launcher_.get())
+    return;
+  launcher_->SetVisible(true);
+}
+
 void RootWindowController::HandleDesktopBackgroundVisible() {
   if (background_.get())
     background_->SetColor(SK_ColorBLACK);
 }
 
 void RootWindowController::CloseChildWindows() {
+  // The status area needs to be shut down before the windows are destroyed.
+  if (status_area_widget_)
+    status_area_widget_->Shutdown();
+
+  // Closing the windows frees the workspace controller.
+  if (shelf_)
+    shelf_->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;
   }
+  // TODO(oshima): Closing window triggers access to status area widget
+  // in ShelfLayoutManager. We probably should disalb/remove shelf layout
+  // manager before destorying windows?
+  status_area_widget_ = NULL;
+
+  // All containers are deleted, so reset shelf_.
+  shelf_ = NULL;
 }
 
 bool RootWindowController::IsInMaximizedMode() const {
   return workspace_controller_->IsInMaximizedMode();
 }
 
 void RootWindowController::MoveWindowsTo(aura::RootWindow* dst) {
   aura::Window* focused = dst->GetFocusManager()->GetFocusedWindow();
   aura::WindowTracker tracker;
   if (focused)
@@ 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)) {
     dst->GetFocusManager()->SetFocusedWindow(focused, NULL);
   } else if (active && tracker.Contains(active) && dst->Contains(active)) {
     activation_client->ActivateWindow(active);
   }
 }
 
+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_->alignment();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindowController, private:
 
 void RootWindowController::CreateContainersInRootWindow(
     aura::RootWindow* root_window) {
   // These containers are just used by PowerButtonController to animate groups
   // of containers simultaneously without messing up the current transformations
   // on those containers. These are direct children of the root window; all of
   // the other containers are their children.
   // Desktop and lock screen background containers are not part of the
@@ skipping 141 matching lines @@
 
   aura::Window* overlay_container = CreateContainer(
       kShellWindowId_OverlayContainer,
       "OverlayContainer",
       lock_screen_related_containers);
   SetUsesScreenCoordinates(overlay_container);
 }
 
 }  // namespace internal
 }  // namespace ash