Aura: Rework window mode flags to compact/overlapping/managed

ash/shell.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/shell.h"
 
 #include <algorithm>
 
 #include "ash/accelerators/accelerator_controller.h"
 #include "ash/accelerators/accelerator_filter.h"
@@ skipping 157 matching lines @@
 // static
 Shell* Shell::instance_ = NULL;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, public:
 
 Shell::Shell(ShellDelegate* delegate)
     : ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
       accelerator_controller_(new AcceleratorController),
       delegate_(delegate),
-      window_mode_(NORMAL_MODE),
+      window_mode_(MODE_UNINITIALIZED),
       root_window_layout_(NULL),
       status_widget_(NULL) {
   aura::RootWindow::GetInstance()->SetEventFilter(
       new internal::RootWindowEventFilter);
 }
 
 Shell::~Shell() {
   RemoveRootWindowEventFilter(input_method_filter_.get());
   RemoveRootWindowEventFilter(window_modality_controller_.get());
   RemoveRootWindowEventFilter(accelerator_filter_.get());
 
   // TooltipController needs a valid shell instance. We delete it before
   // deleting the shell |instance_|.
   RemoveRootWindowEventFilter(tooltip_controller_.get());
   aura::client::SetTooltipClient(NULL);
 
   // The LayoutManagers for the default and status containers talk to
   // ShelfLayoutManager (LayoutManager installed on the launcher container).
   // ShelfLayoutManager has a reference to the launcher widget. To avoid any of
   // these trying to reference launcher after it's deleted we delete them all,
   // then the launcher.
-  if (!CommandLine::ForCurrentProcess()->
-      HasSwitch(switches::kAuraWorkspaceManager)) {
+  if (window_mode_ != MODE_MANAGED)
     ResetLayoutManager(internal::kShellWindowId_DefaultContainer);
-  }
   ResetLayoutManager(internal::kShellWindowId_StatusContainer);
   ResetLayoutManager(internal::kShellWindowId_LauncherContainer);
   // Make sure we delete WorkspaceController before launcher is
   // deleted as it has a reference to launcher model.
   workspace_controller_.reset();
   launcher_.reset();
 
   // Delete containers now so that child windows does not access
   // observers when they are destructed. This has to be after launcher
   // is destructed because launcher closes the widget in its destructor.
@@ skipping 70 matching lines @@
 
   if (delegate_.get())
     status_widget_ = delegate_->CreateStatusArea();
   if (!status_widget_)
     status_widget_ = internal::CreateStatusArea();
 
   aura::Window* default_container =
       GetContainer(internal::kShellWindowId_DefaultContainer);
   launcher_.reset(new Launcher(default_container));
 
-  if (IsWindowModeCompact())
+  if (window_mode_ == MODE_COMPACT)
     SetupCompactWindowMode();
   else
-    SetupNormalWindowMode();
+    SetupNonCompactWindowMode(window_mode_ == MODE_MANAGED);
 
   if (!command_line->HasSwitch(switches::kAuraNoShadows))
     shadow_controller_.reset(new internal::ShadowController());
 
   // Force a layout.
   root_window->layout_manager()->OnWindowResized();
 
   window_modality_controller_.reset(new internal::WindowModalityController);
   AddRootWindowEventFilter(window_modality_controller_.get());
 
   visibility_controller_.reset(new internal::VisibilityController);
   aura::client::SetVisibilityClient(visibility_controller_.get());
 
   accelerator_filter_.reset(new internal::AcceleratorFilter);
   AddRootWindowEventFilter(accelerator_filter_.get());
 
   tooltip_controller_.reset(new internal::TooltipController);
   AddRootWindowEventFilter(tooltip_controller_.get());
   aura::client::SetTooltipClient(tooltip_controller_.get());
 
   drag_drop_controller_.reset(new internal::DragDropController);
   power_button_controller_.reset(new PowerButtonController);
   video_detector_.reset(new VideoDetector);
   window_cycle_controller_.reset(new WindowCycleController);
 }
 
 Shell::WindowMode Shell::ComputeWindowMode(const gfx::Size& monitor_size,
                                            CommandLine* command_line) const {
   if (command_line->HasSwitch(switches::kAuraForceCompactWindowMode))
-    return COMPACT_MODE;
+    return MODE_COMPACT;
 
   // If user set the flag, use their desired behavior.
   if (command_line->HasSwitch(switches::kAuraWindowMode)) {
     std::string mode =
         command_line->GetSwitchValueASCII(switches::kAuraWindowMode);
-    if (mode == switches::kAuraWindowModeNormal)
-      return NORMAL_MODE;
     if (mode == switches::kAuraWindowModeCompact)
-      return COMPACT_MODE;
+      return MODE_COMPACT;
+    if (mode == switches::kAuraWindowModeManaged)
+      return MODE_MANAGED;
+    if (mode == switches::kAuraWindowModeOverlapping)
+      return MODE_OVERLAPPING;
   }
 
   // Developers often run the Aura shell in small windows on their desktop.
-  // Prefer normal mode for them.
+  // Prefer overlapping mode for them.
   if (!aura::RootWindow::use_fullscreen_host_window())
-    return NORMAL_MODE;
+    return MODE_OVERLAPPING;
 
   // If the screen is narrow we prefer a single compact window display.
   // We explicitly don't care about height, since users don't generally stack
   // browser windows vertically.
   if (monitor_size.width() <= kCompactWindowModeWidthThreshold)
-    return COMPACT_MODE;
+    return MODE_COMPACT;
 
-  return NORMAL_MODE;
+  return MODE_OVERLAPPING;
 }
 
 aura::Window* Shell::GetContainer(int container_id) {
   return const_cast<aura::Window*>(
       const_cast<const Shell*>(this)->GetContainer(container_id));
 }
 
 const aura::Window* Shell::GetContainer(int container_id) const {
   return aura::RootWindow::GetInstance()->GetChildById(container_id);
 }
@@ skipping 23 matching lines @@
   if (!app_list_.get())
     app_list_.reset(new internal::AppList);
   app_list_->SetVisible(!app_list_->IsVisible());
 }
 
 void Shell::ChangeWindowMode(WindowMode mode) {
   if (mode == window_mode_)
     return;
   // Window mode must be set before we resize/layout the windows.
   window_mode_ = mode;
-  if (window_mode_ == COMPACT_MODE)
+  if (window_mode_ == MODE_COMPACT)
     SetupCompactWindowMode();
   else
-    SetupNormalWindowMode();
+    SetupNonCompactWindowMode(window_mode_ == MODE_MANAGED);
   // Force a layout.
   aura::RootWindow::GetInstance()->layout_manager()->OnWindowResized();
 }
 
 bool Shell::IsScreenLocked() const {
   const aura::Window* lock_screen_container = GetContainer(
       internal::kShellWindowId_LockScreenContainer);
   return lock_screen_container->StopsEventPropagation();
 }
 
 bool Shell::IsModalWindowOpen() const {
   aura::Window* modal_container =
       ash::Shell::GetInstance()->GetContainer(
           internal::kShellWindowId_SystemModalContainer);
   return !modal_container->children().empty();
 }
 
+bool Shell::IsWindowModeCompact() const {
+  // Ensure we don't ask about the mode until we finish initialization.
+  DCHECK(window_mode_ != MODE_UNINITIALIZED);
+  return window_mode_ == MODE_COMPACT;
+}
+
 views::NonClientFrameView* Shell::CreateDefaultNonClientFrameView(
     views::Widget* widget) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kAuraGoogleDialogFrames)) {
     return new internal::DialogFrameView;
   }
   return NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 31 matching lines @@
   // maximizing the windows so the work area is the right size.
   launcher_->widget()->Hide();
 
   // Maximize all the windows, using the new layout manager.
   MaximizeWindows(default_container);
 
   // Eliminate the background widget.
   root_window_layout_->SetBackgroundWidget(NULL);
 }
 
-void Shell::SetupNormalWindowMode() {
+void Shell::SetupNonCompactWindowMode(bool managed_mode) {
   DCHECK(root_window_layout_);
   DCHECK(status_widget_);
 
   // Clean out the old layout managers before we start.
   ResetLayoutManager(internal::kShellWindowId_DefaultContainer);
   ResetLayoutManager(internal::kShellWindowId_LauncherContainer);
   ResetLayoutManager(internal::kShellWindowId_StatusContainer);
 
   internal::ShelfLayoutManager* shelf_layout_manager =
       new internal::ShelfLayoutManager(launcher_->widget(), status_widget_);
   GetContainer(internal::kShellWindowId_LauncherContainer)->
       SetLayoutManager(shelf_layout_manager);
 
   internal::StatusAreaLayoutManager* status_area_layout_manager =
       new internal::StatusAreaLayoutManager(shelf_layout_manager);
   GetContainer(internal::kShellWindowId_StatusContainer)->
       SetLayoutManager(status_area_layout_manager);
 
   aura::Window* default_container =
       GetContainer(internal::kShellWindowId_DefaultContainer);
-  if (CommandLine::ForCurrentProcess()->
-          HasSwitch(switches::kAuraWorkspaceManager)) {
+  if (managed_mode) {

[sky, 2012/01/31 21:44:54]

Can we look at window_mode_ rather than having a mysterious boolean param to
this function?

[James Cook, 2012/01/31 22:26:28]

Good idea.  Done.

     // Workspace manager has its own layout managers.
     workspace_controller_.reset(
         new internal::WorkspaceController(default_container));
   } else {
     // Default layout manager.
     internal::ToplevelLayoutManager* toplevel_layout_manager =
         new internal::ToplevelLayoutManager();
     toplevel_layout_manager->set_shelf(shelf_layout_manager);
     default_container->SetLayoutManager(toplevel_layout_manager);
     default_container->SetEventFilter(
         new ToplevelWindowEventFilter(default_container));
   }
   // Ensure launcher is visible.
   launcher_->widget()->Show();
 
   // Restore all maximized windows.  Don't change full screen windows, as we
   // don't want to disrupt a user trying to plug in an external monitor to
   // give a presentation.
   RestoreMaximizedWindows(default_container);
 
   // Create the desktop background image.
   root_window_layout_->SetBackgroundWidget(internal::CreateDesktopBackground());
 }
 
 void Shell::ResetLayoutManager(int container_id) {
   GetContainer(container_id)->SetLayoutManager(NULL);
 }
 
 }  // namespace ash