Fork a subset of ash/shelf for use in mash.

mash/shelf/shelf_model.cc

 // Copyright 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/shelf/shelf_model.h"
+#include "mash/shelf/shelf_model.h"
 
 #include <algorithm>
 
-#include "ash/ash_switches.h"
-#include "ash/shelf/shelf_model_observer.h"
+#include "mash/shelf/shelf_model_observer.h"
+#include "mojo/common/common_type_converters.h"
+#include "mojo/shell/public/cpp/application_impl.h"
 
-namespace ash {
+namespace mash {
+namespace shelf {
 
 namespace {
 
 int ShelfItemTypeToWeight(ShelfItemType type) {
   switch (type) {
     case TYPE_APP_LIST:
       // TODO(skuhne): If the app list item becomes movable again, this need
       // to be a fallthrough.
       return 0;
     case TYPE_BROWSER_SHORTCUT:
     case TYPE_APP_SHORTCUT:
       return 1;
     case TYPE_WINDOWED_APP:
     case TYPE_PLATFORM_APP:
+    case TYPE_MOJO_APP:
       return 2;
     case TYPE_DIALOG:
       return 3;
     case TYPE_APP_PANEL:
       return 4;
     case TYPE_UNDEFINED:
       NOTREACHED() << "ShelfItemType must be set";
       return -1;
   }
 
   NOTREACHED() << "Invalid type " << type;
   return 1;
 }
 
 bool CompareByWeight(const ShelfItem& a, const ShelfItem& b) {
   return ShelfItemTypeToWeight(a.type) < ShelfItemTypeToWeight(b.type);
 }
 
 }  // namespace
 
-ShelfModel::ShelfModel() : next_id_(1), status_(STATUS_NORMAL) {
+ShelfModel::ShelfModel(mojo::ApplicationImpl* app)
+    : next_id_(1), status_(STATUS_NORMAL), binding_(this) {
+  app->ConnectToService("mojo:desktop_wm", &user_window_controller_);
+  user_window_controller_->AddUserWindowObserver(
+      binding_.CreateInterfacePtrAndBind());
 }
 
 ShelfModel::~ShelfModel() {
 }
 
 int ShelfModel::Add(const ShelfItem& item) {
-  return AddAt(items_.size(), item);
+  return AddAt(static_cast<int>(items_.size()), item);
 }
 
 int ShelfModel::AddAt(int index, const ShelfItem& item) {
   index = ValidateInsertionIndex(item.type, index);
   items_.insert(items_.begin() + index, item);
   items_[index].id = next_id_++;
   FOR_EACH_OBSERVER(ShelfModelObserver, observers_, ShelfItemAdded(index));
   return index;
 }
 
@@ skipping 46 matching lines @@
 }
 
 int ShelfModel::ItemIndexByID(ShelfID id) const {
   ShelfItems::const_iterator i = ItemByID(id);
   return i == items_.end() ? -1 : static_cast<int>(i - items_.begin());
 }
 
 int ShelfModel::GetItemIndexForType(ShelfItemType type) {
   for (size_t i = 0; i < items_.size(); ++i) {
     if (items_[i].type == type)
-      return i;
+      return static_cast<int>(i);
   }
   return -1;
 }
 
 ShelfItems::const_iterator ShelfModel::ItemByID(int id) const {
   for (ShelfItems::const_iterator i = items_.begin();
        i != items_.end(); ++i) {
     if (i->id == id)
       return i;
   }
@@ skipping 43 matching lines @@
   index = std::max(std::lower_bound(items_.begin(), items_.end(), weight_dummy,
                                     CompareByWeight) - items_.begin(),
                    static_cast<ShelfItems::difference_type>(index));
   index = std::min(std::upper_bound(items_.begin(), items_.end(), weight_dummy,
                                     CompareByWeight) - items_.begin(),
                    static_cast<ShelfItems::difference_type>(index));
 
   return index;
 }
 
-}  // namespace ash
+void ShelfModel::OnUserWindowObserverAdded(
+    mojo::Array<mash::wm::mojom::UserWindowPtr> user_windows) {
+  for (size_t i = 0; i < user_windows.size(); ++i)
+    OnUserWindowAdded(std::move(user_windows[i]));
+}
+
+void ShelfModel::OnUserWindowAdded(mash::wm::mojom::UserWindowPtr user_window) {
+  ShelfItem item;
+  item.type = TYPE_MOJO_APP;
+  item.status = STATUS_RUNNING;
+  item.window_id = user_window->window_id;
+  item.title = user_window->window_title.To<base::string16>();
+  Add(item);
+}
+
+void ShelfModel::OnUserWindowRemoved(uint32_t window_id) {
+  RemoveItemAt(ItemIndexByWindowID(window_id));
+}
+
+void ShelfModel::OnUserWindowTitleChanged(uint32_t window_id,
+                                          const mojo::String& window_title) {
+  const int index = ItemIndexByWindowID(window_id);
+  ShelfItem old_item(items_[index]);
+  items_[index].title = window_title.To<base::string16>();
+  FOR_EACH_OBSERVER(ShelfModelObserver, observers_,
+                    ShelfItemChanged(index, old_item));
+}
+
+int ShelfModel::ItemIndexByWindowID(uint32_t window_id) const {
+  for (size_t i = 0; i < items_.size(); ++i) {
+    if (items_[i].window_id == window_id)
+      return static_cast<int>(i);
+  }
+  return -1;
+}
+
+}  // namespace shelf
+}  // namespace mash