Only create DockedBackgroundWidget as needed.

ash/wm/dock/docked_window_layout_manager.cc

 // Copyright (c) 2013 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/wm/dock/docked_window_layout_manager.h"
 
 #include "ash/screen_util.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_constants.h"
 #include "ash/shelf/shelf_layout_manager.h"
+#include "ash/shelf/shelf_layout_manager_observer.h"
 #include "ash/shelf/shelf_types.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_resizer.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
@@ skipping 29 matching lines @@
 // static
 const int DockedWindowLayoutManager::kMinDockGap = 2;
 // static
 const int DockedWindowLayoutManager::kIdealWidth = 250;
 const int kMinimumHeight = 250;
 const int kSlideDurationMs = 120;
 const int kFadeDurationMs = 60;
 const int kMinimizeDurationMs = 720;
 
 class DockedBackgroundWidget : public views::Widget,
-                               public BackgroundAnimatorDelegate {
+                               public BackgroundAnimatorDelegate,
+                               public ShelfLayoutManagerObserver {
  public:
-  explicit DockedBackgroundWidget(aura::Window* container)
-      : alignment_(DOCKED_ALIGNMENT_NONE),
+  explicit DockedBackgroundWidget(DockedWindowLayoutManager* manager)
+      : manager_(manager),
+        alignment_(DOCKED_ALIGNMENT_NONE),
         background_animator_(this, 0, kShelfBackgroundAlpha),
         alpha_(0),
         opaque_background_(ui::LAYER_SOLID_COLOR),
-        visible_background_type_(SHELF_BACKGROUND_DEFAULT),
+        visible_background_type_(
+            manager_->shelf()->shelf_widget()->GetBackgroundType()),
         visible_background_change_type_(BACKGROUND_CHANGE_IMMEDIATE) {
-    InitWidget(container);
+    manager_->shelf()->shelf_layout_manager()->AddObserver(this);
+    InitWidget(manager_->dock_container());
+  }
+
+  ~DockedBackgroundWidget() override {
+    manager_->shelf()->shelf_layout_manager()->RemoveObserver(this);

[sky, 2016/04/14 20:55:07]

Are you sure you don't need the conditional tests here that were on 429 old?

[msw, 2016/04/14 21:33:48]

This should be alright; line 443 (new) destroys this object with
background_widget_.reset(), directly before setting |shelf_| to null (no other
place does that). Also, RootWindowController::CloseChildWindows() calls that
Shutdown function before shutting down the shelf and its layout manager:
https://code.google.com/p/chromium/codesearch#chromium/src/ash/root_window_co...

   }
 
   // Sets widget bounds and sizes opaque background layer to fill the widget.
   void SetBackgroundBounds(const gfx::Rect bounds, DockedAlignment alignment) {
     SetBounds(bounds);
     opaque_background_.SetBounds(gfx::Rect(bounds.size()));
     alignment_ = alignment;
   }
 
-  // Sets the background type. Starts an animation to transition to
-  // |background_type| if the widget is visible. If the widget is not visible,
-  // the animation is postponed till the widget becomes visible.
-  void SetBackgroundType(ShelfBackgroundType background_type,
-                         BackgroundAnimatorChangeType change_type) {
-    visible_background_type_ = background_type;
-    visible_background_change_type_ = change_type;
-    if (IsVisible())
-      UpdateBackground();
-  }
-
+ private:
   // views::Widget:
   void OnNativeWidgetVisibilityChanged(bool visible) override {
     views::Widget::OnNativeWidgetVisibilityChanged(visible);
     UpdateBackground();
   }
 
   void OnNativeWidgetPaint(const ui::PaintContext& context) override {
     gfx::Rect local_window_bounds(GetWindowBoundsInScreen().size());
     ui::PaintRecorder recorder(context, local_window_bounds.size());
     const gfx::ImageSkia& shelf_background(
@@ skipping 17 matching lines @@
         local_window_bounds.width() - shelf_background.width(),
         local_window_bounds.height(), false, paint);
   }
 
   // BackgroundAnimatorDelegate:
   void UpdateBackground(int alpha) override {
     alpha_ = alpha;
     SchedulePaintInRect(gfx::Rect(GetWindowBoundsInScreen().size()));
   }
 
- private:
+  // ShelfLayoutManagerObserver:
+  void OnBackgroundUpdated(ShelfBackgroundType background_type,
+                           BackgroundAnimatorChangeType change_type) override {
+    // Sets the background type. Starts an animation to transition to
+    // |background_type| if the widget is visible. If the widget is not visible,
+    // the animation is postponed till the widget becomes visible.
+    visible_background_type_ = background_type;
+    visible_background_change_type_ = change_type;
+    if (IsVisible())
+      UpdateBackground();
+  }
+
   void InitWidget(aura::Window* parent) {
     views::Widget::InitParams params;
     params.type = views::Widget::InitParams::TYPE_POPUP;
     params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
     params.keep_on_top = false;
     params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
     params.parent = parent;
     params.accept_events = false;
     set_focus_on_creation(false);
     Init(params);
     SetVisibilityChangedAnimationsEnabled(false);
     GetNativeWindow()->SetProperty(kStayInSameRootWindowKey, true);
     opaque_background_.SetColor(SK_ColorBLACK);
     opaque_background_.SetBounds(gfx::Rect(GetWindowBoundsInScreen().size()));
     opaque_background_.SetOpacity(0.0f);
     GetNativeWindow()->layer()->Add(&opaque_background_);
-    Hide();
 
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
     gfx::ImageSkia shelf_background =
         *rb.GetImageSkiaNamed(IDR_ASH_SHELF_BACKGROUND);
     shelf_background_left_ = gfx::ImageSkiaOperations::CreateRotatedImage(
         shelf_background, SkBitmapOperations::ROTATION_90_CW);
     shelf_background_right_ = gfx::ImageSkiaOperations::CreateRotatedImage(
         shelf_background, SkBitmapOperations::ROTATION_270_CW);
+
+    // Stack the background below any windows already in the dock container.

[sky, 2016/04/14 20:55:07]

You should document why this is necessary, not what the code does.

[msw, 2016/04/14 21:33:48]

Done; my new comment isn't much different, but I can add something more verbose
if you prefer, maybe something like "This background should be explicitly
stacked below any windows already in the dock, otherwise the z-order is set by
the order in which windows were added to the container, and UpdateStacking only
manages user windows, not the background widget."

[sky, 2016/04/14 23:00:38]

New comment SGTM

+    parent->StackChildAtBottom(GetNativeWindow());
   }
 
   // Transitions to |visible_background_type_| if the widget is visible and to
   // SHELF_BACKGROUND_DEFAULT if it is not.
   void UpdateBackground() {
     ShelfBackgroundType background_type = IsVisible() ?
         visible_background_type_ : SHELF_BACKGROUND_DEFAULT;
     BackgroundAnimatorChangeType change_type = IsVisible() ?
         visible_background_change_type_ : BACKGROUND_CHANGE_IMMEDIATE;
 
@@ skipping 11 matching lines @@
 
     // TODO(varkha): use ui::Layer on both opaque_background and normal
     // background retire background_animator_ at all. It would be simpler.
     // See also ShelfWidget::SetPaintsBackground.
     background_animator_.SetPaintsBackground(
         background_type != SHELF_BACKGROUND_DEFAULT,
         change_type);
     SchedulePaintInRect(gfx::Rect(GetWindowBoundsInScreen().size()));
   }
 
+  DockedWindowLayoutManager* manager_;
+
   DockedAlignment alignment_;
 
   // The animator for the background transitions.
   BackgroundAnimator background_animator_;
 
   // The alpha to use for drawing image assets covering the docked background.
   int alpha_;
 
   // Solid black background that can be made fully opaque.
   ui::Layer opaque_background_;
@@ skipping 200 matching lines @@
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // DockedWindowLayoutManager public implementation:
 DockedWindowLayoutManager::DockedWindowLayoutManager(
     aura::Window* dock_container,
     WorkspaceController* workspace_controller)
     : SnapToPixelLayoutManager(dock_container),
       dock_container_(dock_container),
       in_layout_(false),
-      dragged_window_(NULL),
+      dragged_window_(nullptr),
       is_dragged_window_docked_(false),
       is_dragged_from_dock_(false),
-      shelf_(NULL),
+      shelf_(nullptr),
       workspace_controller_(workspace_controller),
       in_fullscreen_(workspace_controller_->GetWindowState() ==
                      WORKSPACE_WINDOW_STATE_FULL_SCREEN),
       docked_width_(0),
       alignment_(DOCKED_ALIGNMENT_NONE),
       preferred_alignment_(DOCKED_ALIGNMENT_NONE),
       event_source_(DOCKED_ACTION_SOURCE_UNKNOWN),
-      last_active_window_(NULL),
+      last_active_window_(nullptr),
       last_action_time_(base::Time::Now()),
-      background_widget_(new DockedBackgroundWidget(dock_container_)) {
+      background_widget_(nullptr) {
   DCHECK(dock_container);
   aura::client::GetActivationClient(Shell::GetPrimaryRootWindow())->
       AddObserver(this);
   Shell::GetInstance()->AddShellObserver(this);
 }
 
 DockedWindowLayoutManager::~DockedWindowLayoutManager() {
   Shutdown();
 }
 
 void DockedWindowLayoutManager::Shutdown() {
-  if (shelf_ && shelf_->shelf_layout_manager()) {
-    shelf_->shelf_layout_manager()->RemoveObserver(this);
-    shelf_observer_.reset();
-  }
-  shelf_ = NULL;
+  background_widget_.reset();
+  shelf_observer_.reset();
+  shelf_ = nullptr;
   for (size_t i = 0; i < dock_container_->children().size(); ++i) {
     aura::Window* child = dock_container_->children()[i];
     child->RemoveObserver(this);
     wm::GetWindowState(child)->RemoveObserver(this);
   }
   aura::client::GetActivationClient(Shell::GetPrimaryRootWindow())->
       RemoveObserver(this);
   Shell::GetInstance()->RemoveShellObserver(this);
 }
 
@@ skipping 66 matching lines @@
   DCHECK(!IsPopupOrTransient(dragged_window_));
   if (is_dragged_window_docked_)
     OnDraggedWindowUndocked();
   DCHECK (!is_dragged_window_docked_);
   // Stop observing a window unless it is docked container's child in which
   // case it needs to keep being observed after the drag completes.
   if (dragged_window_->parent() != dock_container_) {
     dragged_window_->RemoveObserver(this);
     wm::GetWindowState(dragged_window_)->RemoveObserver(this);
     if (last_active_window_ == dragged_window_)
-      last_active_window_ = NULL;
+      last_active_window_ = nullptr;
   } else {
     // If this is the first window that got docked by a move update alignment.
     if (alignment_ == DOCKED_ALIGNMENT_NONE)
       alignment_ = GetEdgeNearestWindow(dragged_window_);
     // A window is no longer dragged and is a child.
     // When a window becomes a child at drag start this is
     // the only opportunity we will have to enforce a window
     // count limit so do it here.
     MaybeMinimizeChildrenExcept(dragged_window_);
   }
-  dragged_window_ = NULL;
+  dragged_window_ = nullptr;
   dragged_bounds_ = gfx::Rect();
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
   RecordUmaAction(action, source);
 }
 
 void DockedWindowLayoutManager::SetShelf(Shelf* shelf) {
   DCHECK(!shelf_);
   shelf_ = shelf;
-  if (shelf_->shelf_layout_manager()) {
-    shelf_->shelf_layout_manager()->AddObserver(this);
-    shelf_observer_.reset(new ShelfWindowObserver(this));
-  }
+  shelf_observer_.reset(new ShelfWindowObserver(this));
 }
 
 DockedAlignment DockedWindowLayoutManager::GetAlignmentOfWindow(
     const aura::Window* window) const {
   const gfx::Rect& bounds(window->GetBoundsInScreen());
 
   // Test overlap with an existing docked area first.
   if (docked_bounds_.Intersects(bounds) &&
       alignment_ != DOCKED_ALIGNMENT_NONE) {
     // A window is being added to other docked windows (on the same side).
@@ skipping 152 matching lines @@
   // change alignment during the drag. They also cannot be set to be the
   // |last_active_window_|.
   if (child == dragged_window_)
     return;
   // If this is the last window, set alignment and maximize the workspace.
   if (!IsAnyWindowDocked()) {
     alignment_ = DOCKED_ALIGNMENT_NONE;
     UpdateDockedWidth(0);
   }
   if (last_active_window_ == child)
-    last_active_window_ = NULL;
+    last_active_window_ = nullptr;
   child->RemoveObserver(this);
   wm::GetWindowState(child)->RemoveObserver(this);
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
 }
 
 void DockedWindowLayoutManager::OnChildWindowVisibilityChanged(
     aura::Window* child,
     bool visible) {
   if (IsPopupOrTransient(child))
@@ skipping 86 matching lines @@
     alignment_ = DOCKED_ALIGNMENT_RIGHT;
   } else if (alignment_ == DOCKED_ALIGNMENT_RIGHT &&
              shelf_alignment == SHELF_ALIGNMENT_RIGHT) {
     alignment_ = DOCKED_ALIGNMENT_LEFT;
   }
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::SHELF_ALIGNMENT_CHANGED);
 }
 
 /////////////////////////////////////////////////////////////////////////////
-// DockedWindowLayoutManager, ShelfLayoutManagerObserver implementation:
-void DockedWindowLayoutManager::OnBackgroundUpdated(
-    ShelfBackgroundType background_type,
-    BackgroundAnimatorChangeType change_type) {
-  background_widget_->SetBackgroundType(background_type, change_type);
-}
-
-/////////////////////////////////////////////////////////////////////////////
 // DockedWindowLayoutManager, WindowStateObserver implementation:
 
 void DockedWindowLayoutManager::OnPreWindowStateTypeChange(
     wm::WindowState* window_state,
     wm::WindowStateType old_type) {
   aura::Window* window = window_state->window();
   if (IsPopupOrTransient(window))
     return;
   // The window property will still be set, but no actual change will occur
   // until OnFullscreenStateChange is called when exiting fullscreen.
@@ skipping 43 matching lines @@
   ::wm::SetWindowVisibilityAnimationType(window, animation_type);
 }
 
 void DockedWindowLayoutManager::OnWindowDestroying(aura::Window* window) {
   if (dragged_window_ == window) {
     FinishDragging(DOCKED_ACTION_NONE, DOCKED_ACTION_SOURCE_UNKNOWN);
     DCHECK(!dragged_window_);
     DCHECK(!is_dragged_window_docked_);
   }
   if (window == last_active_window_)
-    last_active_window_ = NULL;
+    last_active_window_ = nullptr;
   RecordUmaAction(DOCKED_ACTION_CLOSE, event_source_);
 }
 
-
 ////////////////////////////////////////////////////////////////////////////////
 // DockedWindowLayoutManager, aura::client::ActivationChangeObserver
 // implementation:
 
 void DockedWindowLayoutManager::OnWindowActivated(
     aura::client::ActivationChangeObserver::ActivationReason reason,
     aura::Window* gained_active,
     aura::Window* lost_active) {
   if (gained_active && IsPopupOrTransient(gained_active))
     return;
   // Ignore if the window that is not managed by this was activated.
-  aura::Window* ancestor = NULL;
+  aura::Window* ancestor = nullptr;
   for (aura::Window* parent = gained_active;
        parent; parent = parent->parent()) {
     if (parent->parent() == dock_container_) {
       ancestor = parent;
       break;
     }
   }
   if (ancestor)
     UpdateStacking(ancestor);
 }
@@ skipping 146 matching lines @@
 }
 
 void DockedWindowLayoutManager::Relayout() {
   if (in_layout_)
     return;
   if (alignment_ == DOCKED_ALIGNMENT_NONE && !is_dragged_window_docked_)
     return;
   base::AutoReset<bool> auto_reset_in_layout(&in_layout_, true);
 
   gfx::Rect dock_bounds = dock_container_->GetBoundsInScreen();
-  aura::Window* active_window = NULL;
+  aura::Window* active_window = nullptr;
   std::vector<WindowWithHeight> visible_windows;
   for (size_t i = 0; i < dock_container_->children().size(); ++i) {
     aura::Window* window(dock_container_->children()[i]);
 
     if (!IsWindowDocked(window) || window == dragged_window_)
       continue;
 
     // If the shelf is currently hidden (full-screen mode), hide window until
     // full-screen mode is exited.
     if (in_fullscreen_) {
@@ skipping 110 matching lines @@
   int new_width = ideal_docked_width;
   if (visible_windows->empty() ||
       (visible_windows->size() == 1 &&
           (*visible_windows)[0].window() == dragged_window_)) {
     new_width = 0;
   }
   UpdateDockedWidth(new_width);
   // Sort windows by their center positions and fan out overlapping
   // windows.
   std::sort(visible_windows->begin(), visible_windows->end(),
-            CompareWindowPos(is_dragged_from_dock_ ? dragged_window_ : NULL,
-                             dock_container_,
-                             delta));
+            CompareWindowPos(is_dragged_from_dock_ ? dragged_window_ : nullptr,
+                             dock_container_, delta));
   for (std::vector<WindowWithHeight>::iterator iter = visible_windows->begin();
        iter != visible_windows->end(); ++iter) {
     aura::Window* window = iter->window();
     gfx::Rect bounds = ScreenUtil::ConvertRectToScreen(
         dock_container_, window->GetTargetBounds());
     // A window is extended or shrunk to be as close as possible to the ideal
     // docked area width. Windows that were resized by a user are kept at their
     // existing size.
     // This also enforces the min / max restrictions on the docked area width.
     bounds.set_width(GetWindowWidthCloseTo(
@@ skipping 63 matching lines @@
   docked_bounds_ = bounds +
       dock_container_->GetBoundsInScreen().OffsetFromOrigin();
   FOR_EACH_OBSERVER(
       DockedWindowLayoutManagerObserver,
       observer_list_,
       OnDockBoundsChanging(bounds, reason));
   // Show or hide background for docked area.
   gfx::Rect background_bounds(docked_bounds_);
   if (shelf_observer_)
     background_bounds.Subtract(shelf_observer_->shelf_bounds_in_screen());
-  background_widget_->SetBackgroundBounds(background_bounds, alignment_);
-  if (docked_width_ > 0)
+  if (docked_width_ > 0) {
+    if (!background_widget_)
+      background_widget_.reset(new DockedBackgroundWidget(this));
+    background_widget_->SetBackgroundBounds(background_bounds, alignment_);
     background_widget_->Show();
-  else
+  } else if (background_widget_) {
     background_widget_->Hide();
+  }
 }
 
 void DockedWindowLayoutManager::UpdateStacking(aura::Window* active_window) {
   if (!active_window) {
     if (!last_active_window_)
       return;
     active_window = last_active_window_;
   }
 
   // Windows are stacked like a deck of cards:
@@ skipping 15 matching lines @@
     if (!IsWindowDocked(*it) ||
         ((*it) == dragged_window_ && !is_dragged_window_docked_)) {
       continue;
     }
     gfx::Rect bounds = (*it)->bounds();
     window_ordering.insert(std::make_pair(bounds.y() + bounds.height() / 2,
                                           *it));
   }
   int active_center_y = active_window->bounds().CenterPoint().y();
 
-  aura::Window* previous_window = NULL;
+  aura::Window* previous_window = nullptr;
   for (std::map<int, aura::Window*>::const_iterator it =
        window_ordering.begin();
        it != window_ordering.end() && it->first < active_center_y; ++it) {
     if (previous_window)
       dock_container_->StackChildAbove(it->second, previous_window);
     previous_window = it->second;
   }
   for (std::map<int, aura::Window*>::const_reverse_iterator it =
        window_ordering.rbegin();
        it != window_ordering.rend() && it->first > active_center_y; ++it) {
@@ skipping 13 matching lines @@
 
 void DockedWindowLayoutManager::OnKeyboardBoundsChanging(
     const gfx::Rect& keyboard_bounds) {
   // This bounds change will have caused a change to the Shelf which does not
   // propagate automatically to this class, so manually recalculate bounds.
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::KEYBOARD_BOUNDS_CHANGING);
 }
 
 }  // namespace ash