Draw web content area correctly on a phantom window for window dragging

ash/wm/window_animations.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/window_animations.h"
 
 #include <math.h>
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/ash_switches.h"
 #include "ash/launcher/launcher.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
+#include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/time.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_property.h"
@@ skipping 583 matching lines @@
       return true;
     case WINDOW_VISIBILITY_ANIMATION_TYPE_BRIGHTNESS_GRAYSCALE:
       AnimateHideWindow_BrightnessGrayscale(window);
       return true;
     default:
       NOTREACHED();
       return false;
   }
 }
 
-// Recreates a fresh layer for |window| and all its child windows. Does not
-// recreate shadows or other non-window layers. Returns the old layer and its
-// children, maintaining the hierarchy.
-Layer* RecreateWindowLayers(Window* window) {
-  Layer* old_layer = window->RecreateLayer();
-  DCHECK(old_layer);
-  for (Window::Windows::const_iterator it = window->children().begin();
-       it != window->children().end();
-       ++it) {
-    aura::Window* child = *it;
-    Layer* old_child_layer = RecreateWindowLayers(child);
-    // Maintain the hierarchy of the detached layers.
-    old_layer->Add(old_child_layer);
-  }
-  return old_layer;
-}
-
-// Deletes |layer| and all its child layers.
-void DeepDelete(Layer* layer) {
-  std::vector<Layer*> children = layer->children();
-  for (std::vector<Layer*>::const_iterator it = children.begin();
-       it != children.end();
-       ++it) {
-    Layer* child = *it;
-    DeepDelete(child);
-  }
-  delete layer;
-}
-
 // Observer for a window cross-fade animation. If either the window closes or
 // the layer's animation completes or compositing is aborted due to GPU crash,
 // it deletes the layer and removes itself as an observer.
 class CrossFadeObserver : public ui::CompositorObserver,
                           public aura::WindowObserver,
                           public ui::ImplicitAnimationObserver {
  public:
   // Observes |window| for destruction, but does not take ownership.
   // Takes ownership of |layer| and its child layers.
   CrossFadeObserver(Window* window, Layer* layer)
@@ skipping 45 matching lines @@
  private:
   // Can be called multiple times if the window is closed or the compositor
   // fails in the middle of the animation.
   void Cleanup() {
     if (window_) {
       window_->RemoveObserver(this);
       window_ = NULL;
     }
     if (layer_) {
       layer_->GetCompositor()->RemoveObserver(this);
-      DeepDelete(layer_);
+      wm::DeepDeleteLayers(layer_);
       layer_ = NULL;
     }
   }
 
   Window* window_;  // not owned
   Layer* layer_;  // owned
 
   DISALLOW_COPY_AND_ASSIGN(CrossFadeObserver);
 };
 
@@ skipping 37 matching lines @@
   return new internal::HidingWindowAnimationObserver(window);
 }
 
 void CrossFadeToBounds(aura::Window* window, const gfx::Rect& new_bounds) {
   DCHECK(window->TargetVisibility());
   gfx::Rect old_bounds = window->bounds();
 
   // Create fresh layers for the window and all its children to paint into.
   // Takes ownership of the old layer and all its children, which will be
   // cleaned up after the animation completes.
-  ui::Layer* old_layer = internal::RecreateWindowLayers(window);
+  ui::Layer* old_layer = wm::RecreateWindowLayers(window);
   ui::Layer* new_layer = window->layer();
 
   // Ensure the higher-resolution layer is on top.
   bool old_on_top = (old_bounds.width() > new_bounds.width());
   if (old_on_top)
     old_layer->parent()->StackBelow(new_layer, old_layer);
   else
     old_layer->parent()->StackAbove(new_layer, old_layer);
 
   // Tween types for transform animations must match to keep the window edges
@@ skipping 95 matching lines @@
         AnimateHideWindow(window);
   }
 }
 
 void SetDelayedOldLayerDeletionInCrossFadeForTest(bool value) {
   delayed_old_layer_deletion_in_cross_fade_for_test_ = value;
 }
 
 }  // namespace internal
 }  // namespace ash