Layout panels on top of their launcher icons

ash/shell/shell_main.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 <map>
 
 #include "ash/launcher/launcher.h"
 #include "ash/launcher/launcher_delegate.h"
 #include "ash/launcher/launcher_model.h"
 #include "ash/launcher/launcher_types.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_factory.h"
 #include "ash/shell_window_ids.h"
 #include "ash/shell/example_factory.h"
 #include "ash/shell/toplevel_window.h"
 #include "ash/shell/shell_main_parts.h"
 #include "ash/wm/partial_screenshot_view.h"
 #include "ash/wm/window_util.h"
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "grit/ui_resources.h"
 #include "ui/aura/env.h"
+#include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/window_types.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/ui_base_paths.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/compositor/test/compositor_test_support.h"
 #include "ui/views/test/test_views_delegate.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
@@ skipping 17 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ShellViewsDelegate);
 };
 
 // WindowWatcher is responsible for listening for newly created windows and
 // creating items on the Launcher for them.
 class WindowWatcher : public aura::WindowObserver {
  public:
   WindowWatcher()
-      : window_(ash::Shell::GetInstance()->launcher()->window_container()) {
+      : window_(ash::Shell::GetInstance()->launcher()->window_container()),
+        panel_container_(
+            ash::Shell::GetInstance()->GetContainer(
+                ash::internal::kShellWindowId_PanelContainer)) {
     window_->AddObserver(this);
+    panel_container_->AddObserver(this);
   }
 
   virtual ~WindowWatcher() {
     window_->RemoveObserver(this);
+    panel_container_->AddObserver(this);
   }
 
   aura::Window* GetWindowByID(ash::LauncherID id) {
     IDToWindow::const_iterator i = id_to_window_.find(id);
     return i != id_to_window_.end() ? i->second : NULL;
   }
 
   ash::LauncherID GetIDByWindow(aura::Window* window) const {
     for (IDToWindow::const_iterator i = id_to_window_.begin();
          i != id_to_window_.end(); ++i) {
       if (i->second == window)
         return i->first;
     }
     return 0;  // TODO: add a constant for this.
   }
 
   // aura::WindowObserver overrides:
   virtual void OnWindowAdded(aura::Window* new_window) OVERRIDE {
-    if (new_window->type() != aura::client::WINDOW_TYPE_NORMAL)
-      return;
+    //if ((new_window->type() != aura::client::WINDOW_TYPE_NORMAL)

[sky, 2012/03/23 21:41:14]

Keep the old code.

+    //    || (new_window->type() != aura::client::WINDOW_TYPE_PANEL))
+    //  return;
 
     static int image_count = 0;
     ash::LauncherModel* model = ash::Shell::GetInstance()->launcher()->model();
     ash::LauncherItem item;
+    ash::LauncherID id = model->next_id();
     item.type = ash::TYPE_TABBED;
-    id_to_window_[model->next_id()] = new_window;
+    id_to_window_[id] = new_window;
     item.num_tabs = image_count + 1;
     item.image.setConfig(SkBitmap::kARGB_8888_Config, 16, 16);
     item.image.allocPixels();
     item.image.eraseARGB(255,
                          image_count == 0 ? 255 : 0,
                          image_count == 1 ? 255 : 0,
                          image_count == 2 ? 255 : 0);
     image_count = (image_count + 1) % 3;
     model->Add(model->item_count(), item);
+    new_window->SetProperty(aura::client::kLauncherIDKey, id);

[sky, 2012/03/23 21:41:14]

What is this for?

   }
 
   virtual void OnWillRemoveWindow(aura::Window* window) OVERRIDE {
     for (IDToWindow::iterator i = id_to_window_.begin();
          i != id_to_window_.end(); ++i) {
       if (i->second == window) {
         ash::LauncherModel* model =
             ash::Shell::GetInstance()->launcher()->model();
         int index = model->ItemIndexByID(i->first);
         DCHECK_NE(-1, index);
         model->RemoveItemAt(index);
         id_to_window_.erase(i);
         break;
       }
     }
   }
 
  private:
   typedef std::map<ash::LauncherID, aura::Window*> IDToWindow;
 
   // Window watching for newly created windows to be added to.
   aura::Window* window_;
 
+  aura::Window* panel_container_;
+
   // Maps from window to the id we gave it.
   IDToWindow id_to_window_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowWatcher);
 };
 
 class LauncherDelegateImpl : public ash::LauncherDelegate {
  public:
   explicit LauncherDelegateImpl(WindowWatcher* watcher)
       : watcher_(watcher) {
@@ skipping 150 matching lines @@
   window_watcher.reset();
 
   ash::Shell::DeleteInstance();
 
   aura::Env::DeleteInstance();
 
   ui::CompositorTestSupport::Terminate();
 
   return 0;
 }