Explicit container priority

athena/screen/screen_manager_impl.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 "athena/screen/public/screen_manager.h"
 
+#include "athena/common/container_priorities.h"
 #include "athena/common/fill_layout_manager.h"
 #include "athena/input/public/accelerator_manager.h"
 #include "athena/screen/background_controller.h"
 #include "athena/screen/screen_accelerator_handler.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
@@ skipping 103 matching lines @@
 
   scoped_ptr<BackgroundController> background_controller_;
   scoped_ptr<aura::client::WindowTreeClient> window_tree_client_;
   scoped_ptr<AcceleratorHandler> accelerator_handler_;
   scoped_ptr< ::wm::ScopedCaptureClient> capture_client_;
   scoped_ptr<aura::client::ScreenPositionClient> screen_position_client_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenManagerImpl);
 };
 
+ScreenManagerImpl::ScreenManagerImpl(aura::Window* root_window)
+    : root_window_(root_window) {
+  DCHECK(root_window_);
+  DCHECK(!instance);
+  instance = this;
+}
+
+ScreenManagerImpl::~ScreenManagerImpl() {
+  aura::client::SetScreenPositionClient(root_window_, NULL);
+  aura::client::SetWindowTreeClient(root_window_, NULL);
+  instance = NULL;
+}
+
 void ScreenManagerImpl::Init() {
   // TODO(oshima): Move the background out from ScreenManager.
   root_window_->SetLayoutManager(new FillLayoutManager(root_window_));
-  background_window_ = CreateContainer(ContainerParams("AthenaBackground"));
+  background_window_ =
+      CreateContainer(ContainerParams("AthenaBackground", CP_BACKGROUND));
 
   background_window_->SetLayoutManager(
       new FillLayoutManager(background_window_));
   background_controller_.reset(new BackgroundController(background_window_));
 
   capture_client_.reset(new ::wm::ScopedCaptureClient(root_window_));
   accelerator_handler_.reset(new ScreenAcceleratorHandler(root_window_));
 }
 
 aura::Window* ScreenManagerImpl::CreateDefaultContainer(
     const ContainerParams& params) {
   aura::Window* container = CreateContainer(params);
   window_tree_client_.reset(new AthenaWindowTreeClient(container));
   aura::client::SetWindowTreeClient(root_window_, window_tree_client_.get());
 
   screen_position_client_.reset(new AthenaScreenPositionClient());
   aura::client::SetScreenPositionClient(root_window_,
                                         screen_position_client_.get());
 
   return container;
 }
 
+// A functor to find a container that has the higher priority.
+struct HigherPriorityFinder {
+  HigherPriorityFinder(int p) : priority(p) {}
+  bool operator()(aura::Window* window) {
+    return window->GetProperty(kContainerParamsKey)->z_order_priority >
+           priority;
+  }
+  int priority;
+};
+
+#if !defined(NDEBUG)
+struct PriorityMatcher {
+  PriorityMatcher(int p) : priority(p) {}
+  bool operator()(aura::Window* window) {
+    return window->GetProperty(kContainerParamsKey)->z_order_priority ==
+           priority;
+  }
+  int priority;
+};
+#endif
+
 aura::Window* ScreenManagerImpl::CreateContainer(
     const ContainerParams& params) {
   aura::Window* container = new aura::Window(NULL);
+  CHECK_GE(params.z_order_priority, 0);
   container->Init(aura::WINDOW_LAYER_NOT_DRAWN);
   container->SetName(params.name);
+
+  const aura::Window::Windows& children = root_window_->children();
+
+  DCHECK(std::find_if(children.begin(),
+                      children.end(),
+                      PriorityMatcher(params.z_order_priority))
+         == children.end())
+      << "The container with the priority "
+      << params.z_order_priority << " already exists.";

[sadrul, 2014/07/23 18:37:24]

nice

+
+  container->SetProperty(kContainerParamsKey, new ContainerParams(params));
   root_window_->AddChild(container);
+
+  aura::Window::Windows::const_iterator iter =
+      std::find_if(children.begin(),
+                   children.end(),
+                   HigherPriorityFinder(params.z_order_priority));
+  if (iter != children.end())
+    root_window_->StackChildBelow(container, *iter);
+
   container->Show();
-  container->SetProperty(kContainerParamsKey, new ContainerParams(params));
   return container;
 }
 
 void ScreenManagerImpl::SetBackgroundImage(const gfx::ImageSkia& image) {
   background_controller_->SetImage(image);
 }
 
-ScreenManagerImpl::ScreenManagerImpl(aura::Window* root_window)
-    : root_window_(root_window) {
-  DCHECK(root_window_);
-  DCHECK(!instance);
-  instance = this;
-}
-
-ScreenManagerImpl::~ScreenManagerImpl() {
-  aura::client::SetScreenPositionClient(root_window_, NULL);
-  aura::client::SetWindowTreeClient(root_window_, NULL);
-  instance = NULL;
-}
-
 }  // namespace
 
-ScreenManager::ContainerParams::ContainerParams(const std::string& n)
-    : name(n),
-      can_activate_children(false) {
+ScreenManager::ContainerParams::ContainerParams(const std::string& n,
+                                                int priority)
+    : name(n), can_activate_children(false), z_order_priority(priority) {
 }
 
 // static
 ScreenManager* ScreenManager::Create(aura::Window* root_window) {
   (new ScreenManagerImpl(root_window))->Init();
   DCHECK(instance);
   return instance;
 }
 
 // static
 ScreenManager* ScreenManager::Get() {
   DCHECK(instance);
   return instance;
 }
 
 // static
 void ScreenManager::Shutdown() {
   DCHECK(instance);
   delete instance;
   DCHECK(!instance);
 }
 
 // static
 wm::FocusRules* ScreenManager::CreateFocusRules() {
   return new AthenaFocusRules();
 }
 
 }  // namespace athena