Aura: Remove overlapping window mode

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/app_list/app_list.h"
 #include "ash/ash_switches.h"
@@ skipping 230 matching lines @@
   SkBitmap null_image_;
 
   DISALLOW_COPY_AND_ASSIGN(DummySystemTrayDelegate);
 };
 
 }  // namespace
 
 // static
 Shell* Shell::instance_ = NULL;
 // static
-bool Shell::compact_window_mode_for_test_ = false;
-// static
 bool Shell::initially_hide_cursor_ = false;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell::TestApi
 
 Shell::TestApi::TestApi(Shell* shell) : shell_(shell) {}
 
 Shell::WindowMode Shell::TestApi::ComputeWindowMode(CommandLine* cmd) const {
   return shell_->ComputeWindowMode(cmd);
 }
@@ skipping 182 matching lines @@
   if (!status_widget_)
     status_widget_ = internal::CreateStatusArea(tray_.get());
 
   aura::Window* default_container =
       GetContainer(internal::kShellWindowId_DefaultContainer);
   launcher_.reset(new Launcher(default_container));
 
   if (window_mode_ == MODE_COMPACT)
     SetupCompactWindowMode();
   else
-    SetupNonCompactWindowMode();
+    SetupManagedWindowMode();
 
   if (!command_line->HasSwitch(switches::kAuraNoShadows))
     shadow_controller_.reset(new internal::ShadowController());
 
   focus_cycler_.reset(new internal::FocusCycler());
   focus_cycler_->AddWidget(status_widget_);
   focus_cycler_->AddWidget(launcher_->widget());
   launcher_->SetFocusCycler(focus_cycler_.get());
 
   // 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);
 
   tooltip_controller_.reset(new internal::TooltipController);
   AddRootWindowEventFilter(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(CommandLine* command_line) const {
-  if (compact_window_mode_for_test_)
-    return MODE_COMPACT;
-
   // Some devices don't perform well with overlapping windows.
   if (command_line->HasSwitch(switches::kAuraForceCompactWindowMode))
     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::kAuraWindowModeCompact)
       return MODE_COMPACT;
     if (mode == switches::kAuraWindowModeManaged)
       return MODE_MANAGED;
-    if (mode == switches::kAuraWindowModeOverlapping)
-      return MODE_OVERLAPPING;
   }
 
   // Managed is the default.
   return Shell::MODE_MANAGED;
 }
 
 aura::Window* Shell::GetContainer(int container_id) {
   return const_cast<aura::Window*>(
       const_cast<const Shell*>(this)->GetContainer(container_id));
 }
@@ skipping 116 matching lines @@
   default_container->SetLayoutManager(compact_layout_manager);
 
   // Keep the launcher for its data model, but hide it.  Do this before
   // maximizing the windows so the work area is the right size.
   launcher_->widget()->Hide();
 
   // Set a solid black background.
   SetDesktopBackgroundMode(BACKGROUND_SOLID_COLOR);
 }
 
-void Shell::SetupNonCompactWindowMode() {
+void Shell::SetupManagedWindowMode() {
   DCHECK(root_window_layout_);
   DCHECK(status_widget_);
 
   internal::ShelfLayoutManager* shelf_layout_manager =
       new internal::ShelfLayoutManager(launcher_->widget(), status_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);
 
   aura::Window* default_container =
       GetContainer(internal::kShellWindowId_DefaultContainer);
-  if (window_mode_ == MODE_MANAGED) {
-    // Workspace manager has its own layout managers.
-    workspace_controller_.reset(
-        new internal::WorkspaceController(default_container));
-    workspace_controller_->workspace_manager()->set_shelf(shelf_layout_manager);
-  } 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));
-  }
+  // Workspace manager has its own layout managers.
+  workspace_controller_.reset(
+      new internal::WorkspaceController(default_container));
+  workspace_controller_->workspace_manager()->set_shelf(shelf_layout_manager);
+
   // Ensure launcher is visible.
   launcher_->widget()->Show();
 
   // Create the desktop background image.
   SetDesktopBackgroundMode(BACKGROUND_IMAGE);
 }
 
 void Shell::ResetLayoutManager(int container_id) {
   GetContainer(container_id)->SetLayoutManager(NULL);
 }
 
 void Shell::DisableWorkspaceGridLayout() {
   if (workspace_controller_.get())
     workspace_controller_->workspace_manager()->set_grid_size(0);
 }
 
 }  // namespace ash