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"
@@ skipping 123 matching lines @@
     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);
+
+    parent->StackChildAtBottom(GetNativeWindow());
+    Show();
   }
 
   // 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 244 matching lines @@
       shelf_(NULL),
       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_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();
 }
 
@@ skipping 390 matching lines @@
   }
   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);
+  if (background_widget_)
+    background_widget_->SetBackgroundType(background_type, change_type);

[sky, 2016/04/13 21:45:42]

If you lazily create background_widget_ after this is called won't the
background type be out of sync? In other words does this need to cache the
background_type/change_type and supply it to background_widget_ on creation?

[msw, 2016/04/13 23:07:04]

Good point; I made DockedBackgroundWidget init the background type in it's ctor;
it's also now the ShelfLayoutManagerObserver. On ToT, afaict, the initial
background is always shown immediately, it's not animated, so change_type is
okay to init as BACKGROUND_CHANGE_IMMEDIATE.

 }
 
 /////////////////////////////////////////////////////////////////////////////
 // DockedWindowLayoutManager, WindowStateObserver implementation:
 
 void DockedWindowLayoutManager::OnPreWindowStateTypeChange(
     wm::WindowState* window_state,
     wm::WindowStateType old_type) {
   aura::Window* window = window_state->window();
   if (IsPopupOrTransient(window))
@@ skipping 446 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)
-    background_widget_->Show();
-  else
-    background_widget_->Hide();
+  if (docked_width_ > 0) {
+    if (!background_widget_)
+      background_widget_.reset(new DockedBackgroundWidget(dock_container_));
+    background_widget_->SetBackgroundBounds(background_bounds, alignment_);
+  } else if (background_widget_) {
+    background_widget_.reset();
+  }
 }
 
 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 49 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