Revert of Remove remaining window states where window is shown with opacity 0.

ash/wm/panels/panel_layout_manager.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/wm/panels/panel_layout_manager.h"
 
 #include <algorithm>
 #include <map>
 
 #include "ash/screen_util.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_types.h"
-#include "ash/shelf/shelf_util.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "third_party/skia/include/core/SkColor.h"
@@ skipping 332 matching lines @@
     aura::Window* old_parent = child->parent();
     aura::client::ParentWindowWithContext(
         child, child, child->GetRootWindow()->GetBoundsInScreen());
     wm::ReparentTransientChildrenOfChild(child, old_parent, child->parent());
     DCHECK(child->parent()->id() != kShellWindowId_PanelContainer);
     return;
   }
   PanelInfo panel_info;
   panel_info.window = child;
   panel_info.callout_widget = new PanelCalloutWidget(panel_container_);
-  panel_info.slide_in = child != dragged_panel_;
+  if (child != dragged_panel_) {
+    // Set the panel to 0 opacity until it has been positioned to prevent it
+    // from flashing briefly at position (0, 0).
+    child->layer()->SetOpacity(0);
+    panel_info.slide_in = true;
+  }
   panel_windows_.push_back(panel_info);
-  child->AddObserver(this);
   wm::GetWindowState(child)->AddObserver(this);
   Relayout();
 }
 
 void PanelLayoutManager::OnWillRemoveWindowFromLayout(aura::Window* child) {
 }
 
 void PanelLayoutManager::OnWindowRemovedFromLayout(aura::Window* child) {
   if (child->type() == ui::wm::WINDOW_TYPE_POPUP)
     return;
   PanelList::iterator found =
       std::find(panel_windows_.begin(), panel_windows_.end(), child);
   if (found != panel_windows_.end()) {
     delete found->callout_widget;
     panel_windows_.erase(found);
   }
-  if (restore_windows_on_shelf_visible_)
-    restore_windows_on_shelf_visible_->Remove(child);
-  child->RemoveObserver(this);
   wm::GetWindowState(child)->RemoveObserver(this);
 
   if (dragged_panel_ == child)
     dragged_panel_ = NULL;
 
   if (last_active_panel_ == child)
     last_active_panel_ = NULL;
 
   Relayout();
 }
@@ skipping 53 matching lines @@
 // PanelLayoutManager, ash::ShellObserver implementation:
 
 void PanelLayoutManager::OnShelfAlignmentChanged(aura::Window* root_window) {
   if (panel_container_->GetRootWindow() == root_window)
     Relayout();
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // PanelLayoutManager, WindowObserver implementation:
 
-void PanelLayoutManager::OnWindowPropertyChanged(aura::Window* window,
-                                                 const void* key,
-                                                 intptr_t old) {
-  // Trigger a relayout to position the panels whenever the panel icon is set
-  // or changes.
-  if (key == kShelfID)
-    Relayout();
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// PanelLayoutManager, WindowStateObserver implementation:
-
 void PanelLayoutManager::OnPostWindowStateTypeChange(
     wm::WindowState* window_state,
     wm::WindowStateType old_type) {
   // If the shelf is currently hidden then windows will not actually be shown
   // but the set to restore when the shelf becomes visible is updated.
   if (restore_windows_on_shelf_visible_) {
     if (window_state->IsMinimized()) {
       MinimizePanel(window_state->window());
       restore_windows_on_shelf_visible_->Remove(window_state->window());
     } else {
@@ skipping 73 matching lines @@
   ui::ScopedLayerAnimationSettings panel_slide_settings(layer->GetAnimator());
   panel_slide_settings.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   panel_slide_settings.SetTransitionDuration(
       base::TimeDelta::FromMilliseconds(kPanelSlideDurationMilliseconds));
   gfx::Rect bounds(panel->bounds());
   bounds.Offset(GetSlideInAnimationOffset(
       shelf_->shelf_widget()->GetAlignment()));
   SetChildBoundsDirect(panel, bounds);
   panel->Hide();
-  layer->SetOpacity(0);
+  PanelList::iterator found =
+      std::find(panel_windows_.begin(), panel_windows_.end(), panel);
+  if (found != panel_windows_.end()) {
+    layer->SetOpacity(0);
+    // The next time the window is visible it should slide into place.
+    found->slide_in = true;
+  }
   if (wm::IsActiveWindow(panel))
     wm::DeactivateWindow(panel);
   Relayout();
 }
 
 void PanelLayoutManager::RestorePanel(aura::Window* panel) {
-  PanelList::iterator found =
-      std::find(panel_windows_.begin(), panel_windows_.end(), panel);
-  DCHECK(found != panel_windows_.end());
-  found->slide_in = true;
+  panel->Show();
   Relayout();
 }
 
 void PanelLayoutManager::Relayout() {
   if (!shelf_ || !shelf_->shelf_widget())
     return;
 
   if (in_layout_)
     return;
   base::AutoReset<bool> auto_reset_in_layout(&in_layout_, true);
 
   ShelfAlignment alignment = shelf_->shelf_widget()->GetAlignment();
   bool horizontal = alignment == SHELF_ALIGNMENT_TOP ||
                     alignment == SHELF_ALIGNMENT_BOTTOM;
   gfx::Rect shelf_bounds = ash::ScreenUtil::ConvertRectFromScreen(
       panel_container_, shelf_->shelf_widget()->GetWindowBoundsInScreen());
   int panel_start_bounds = kPanelIdealSpacing;
   int panel_end_bounds = horizontal ?
       panel_container_->bounds().width() - kPanelIdealSpacing :
       panel_container_->bounds().height() - kPanelIdealSpacing;
   aura::Window* active_panel = NULL;
   std::vector<VisiblePanelPositionInfo> visible_panels;
   for (PanelList::iterator iter = panel_windows_.begin();
        iter != panel_windows_.end(); ++iter) {
     aura::Window* panel = iter->window;
     iter->callout_widget->SetAlignment(alignment);
 
     // Consider the dragged panel as part of the layout as long as it is
     // touching the shelf.
-    if ((!panel->IsVisible() && !iter->slide_in) ||
+    if (!panel->IsVisible() ||
         (panel == dragged_panel_ &&
          !BoundsAdjacent(panel->bounds(), shelf_bounds))) {
       continue;
     }
 
     // If the shelf is currently hidden (full-screen mode), minimize panel until
     // full-screen mode is exited. When a panel is dragged from another display
     // the shelf state does not update before the panel is added so we exclude
     // the dragged panel.
     if (panel != dragged_panel_ && restore_windows_on_shelf_visible_) {
@@ skipping 82 matching lines @@
     if (horizontal) {
       bounds.set_x(visible_panels[i].major_pos -
                    visible_panels[i].major_length / 2);
     } else {
       bounds.set_y(visible_panels[i].major_pos -
                    visible_panels[i].major_length / 2);
     }
 
     ui::Layer* layer = visible_panels[i].window->layer();
     if (slide_in) {
-      // New windows shift up from the shelf into position and fade in.
-      layer->SetOpacity(0);
+      // New windows shift up from the shelf into position.
       gfx::Rect initial_bounds(bounds);
       initial_bounds.Offset(GetSlideInAnimationOffset(alignment));
       SetChildBoundsDirect(visible_panels[i].window, initial_bounds);
       // Set on shelf so that the panel animates into its target position.
       on_shelf = true;
     }
 
     if (on_shelf) {
       ui::ScopedLayerAnimationSettings panel_slide_settings(
           layer->GetAnimator());
       panel_slide_settings.SetPreemptionStrategy(
           ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
       panel_slide_settings.SetTransitionDuration(
           base::TimeDelta::FromMilliseconds(kPanelSlideDurationMilliseconds));
       SetChildBoundsDirect(visible_panels[i].window, bounds);
-      if (slide_in) {
+      if (slide_in)
         layer->SetOpacity(1);
-        visible_panels[i].window->Show();
-      }
     } else {
       // If the shelf moved don't animate, move immediately to the new
       // target location.
       SetChildBoundsDirect(visible_panels[i].window, bounds);
     }
   }
 
   UpdateStacking(active_panel);
   UpdateCallouts();
 }
@@ skipping 149 matching lines @@
 // keyboard::KeyboardControllerObserver implementation:
 
 void PanelLayoutManager::OnKeyboardBoundsChanging(
     const gfx::Rect& keyboard_bounds) {
   // This bounds change will have caused a change to the Shelf which does not
   // propogate automatically to this class, so manually recalculate bounds.
   OnWindowResized();
 }
 
 }  // namespace ash