Enable ash window cycle UI by default.

ash/common/wm/window_cycle_list.cc

 // Copyright 2014 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/common/wm/window_cycle_list.h"
 
 #include <list>
 #include <map>
 
 #include "ash/common/ash_switches.h"
@@ skipping 12 matching lines @@
 #include "ui/views/controls/label.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/painter.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/wm/core/visibility_controller.h"
 
 namespace ash {
 
+namespace {
+
+bool g_disable_initial_delay = false;
+
 // Returns the window immediately below |window| in the current container.
 WmWindow* GetWindowBelow(WmWindow* window) {
   WmWindow* parent = window->GetParent();
   if (!parent)
     return nullptr;
   const WmWindow::Windows children = parent->GetChildren();
   auto iter = std::find(children.begin(), children.end(), window);
   CHECK(*iter == window);
   return (iter != children.begin()) ? *(iter - 1) : nullptr;
 }
@@ skipping 11 matching lines @@
     views::Painter::PaintPainterAt(canvas, painter_.get(),
                                    gfx::Rect(view->layer()->size()));
   }
 
  private:
   std::unique_ptr<views::Painter> painter_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerFillBackgroundPainter);
 };
 
+}  // namespace
+
 // This class restores and moves a window to the front of the stacking order for
 // the duration of the class's scope.
 class ScopedShowWindow : public WmWindowObserver {
  public:
   ScopedShowWindow();
   ~ScopedShowWindow() override;
 
   // Show |window| at the top of the stacking order.
   void Show(WmWindow* window);
 
@@ skipping 221 matching lines @@
     AddChildView(highlight_view_);
     AddChildView(mirror_container_);
   }
 
   ~WindowCycleView() override {}
 
   void SetTargetWindow(WmWindow* target) {
     target_window_ = target;
     if (GetWidget()) {
       Layout();
-      DCHECK(Contains(GetFocusManager()->GetFocusedView()));
-      window_view_map_[target_window_]->RequestFocus();
+      if (target_window_) {
+        // In the window destruction case, we may have already removed the
+        // focused view and hence not be the focused window. We should still
+        // always be active, though.
+        DCHECK_EQ(ash::WmShell::Get()->GetActiveWindow()->GetInternalWidget(),
+                  GetWidget());
+        window_view_map_[target_window_]->RequestFocus();
+      }
     }
   }
 
   void HandleWindowDestruction(WmWindow* destroying_window,
                                WmWindow* new_target) {
     auto view_iter = window_view_map_.find(destroying_window);
-    view_iter->second->parent()->RemoveChildView(view_iter->second);
+    views::View* parent = view_iter->second->parent();
+    DCHECK_EQ(mirror_container_, parent);
+    parent->RemoveChildView(view_iter->second);
     window_view_map_.erase(view_iter);
+    // With one of its children now gone, we must re-layout |mirror_container_|.
+    // This must happen before SetTargetWindow() to make sure our own Layout()
+    // works correctly when it's calculating highlight bounds.
+    parent->Layout();
     SetTargetWindow(new_target);
   }
 
   // views::WidgetDelegateView overrides:
   gfx::Size GetPreferredSize() const override {
     return mirror_container_->GetPreferredSize();
   }
 
   void Layout() override {
     if (!target_window_ || bounds().IsEmpty())
@@ skipping 83 matching lines @@
     CancelRestore();
   } else if (params.target == stack_window_above_) {
     // If the window this window was above is removed, use the next window down
     // as the restore marker.
     stack_window_above_ = GetWindowBelow(stack_window_above_);
   }
 }
 
 WindowCycleList::WindowCycleList(const WindowList& windows)
     : windows_(windows), current_index_(0), cycle_view_(nullptr) {
-  WmShell::Get()->mru_window_tracker()->SetIgnoreActivations(true);
+  if (!ShouldShowUi())
+    WmShell::Get()->mru_window_tracker()->SetIgnoreActivations(true);
 
   for (WmWindow* window : windows_)
     window->AddObserver(this);
 
   if (ShouldShowUi()) {
-    show_ui_timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(150),
-                         this, &WindowCycleList::InitWindowCycleView);
+    if (g_disable_initial_delay) {
+      InitWindowCycleView();
+    } else {
+      show_ui_timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(150),
+                           this, &WindowCycleList::InitWindowCycleView);
+    }
   }
 }
 
 WindowCycleList::~WindowCycleList() {
-  WmShell::Get()->mru_window_tracker()->SetIgnoreActivations(false);
+  if (!ShouldShowUi())
+    WmShell::Get()->mru_window_tracker()->SetIgnoreActivations(false);
+
   for (WmWindow* window : windows_)
     window->RemoveObserver(this);
 
   if (showing_window_) {
     showing_window_->CancelRestore();
   } else if (!windows_.empty()) {
     WmWindow* target_window = windows_[current_index_];
     target_window->Show();
     target_window->GetWindowState()->Activate();
   }
@@ skipping 27 matching lines @@
 
     if (cycle_view_)
       cycle_view_->SetTargetWindow(windows_[current_index_]);
   } else {
     // Make sure the next window is visible.
     showing_window_.reset(new ScopedShowWindow);
     showing_window_->Show(windows_[current_index_]);
   }
 }
 
+// static
+void WindowCycleList::DisableInitialDelayForTesting() {
+  g_disable_initial_delay = true;
+}
+
 void WindowCycleList::OnWindowDestroying(WmWindow* window) {
   window->RemoveObserver(this);
 
   WindowList::iterator i = std::find(windows_.begin(), windows_.end(), window);
   // TODO(oshima): Change this back to DCHECK once crbug.com/483491 is fixed.
   CHECK(i != windows_.end());
   int removed_index = static_cast<int>(i - windows_.begin());
   windows_.erase(i);
   if (current_index_ > removed_index ||
       current_index_ == static_cast<int>(windows_.size())) {
     current_index_--;
   }
 
   if (cycle_view_) {
     WmWindow* new_target_window =
         windows_.empty() ? nullptr : windows_[current_index_];
     cycle_view_->HandleWindowDestruction(window, new_target_window);
     if (windows_.empty()) {
       // This deletes us.
       WmShell::Get()->window_cycle_controller()->StopCycling();
       return;
     }
   }
 }
 
 bool WindowCycleList::ShouldShowUi() {
-  return windows_.size() > 1 &&
-         base::CommandLine::ForCurrentProcess()->HasSwitch(
-             switches::kAshEnableWindowCycleUi);
+  return windows_.size() > 1;
 }
 
 void WindowCycleList::InitWindowCycleView() {
   if (cycle_view_)
     return;
 
   cycle_view_ = new WindowCycleView(windows_);
   cycle_view_->SetTargetWindow(windows_[current_index_]);
 
   WmWindow* root_window = WmShell::Get()->GetRootWindowForNewWindows();
@@ skipping 17 matching lines @@
   gfx::Rect widget_rect = widget->GetWorkAreaBoundsInScreen();
   int widget_height = cycle_view_->GetPreferredSize().height();
   widget_rect.set_y((widget_rect.height() - widget_height) / 2);
   widget_rect.set_height(widget_height);
   widget->SetBounds(widget_rect);
   widget->Show();
   cycle_ui_widget_.reset(widget);
 }
 
 }  // namespace ash