mash: Support ShelfModel access in Chrome.

ash/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 <algorithm>
 
 #include "ash/public/cpp/shelf_item_delegate.h"
 #include "ash/shelf/shelf_model_observer.h"
+#include "ash/strings/grit/ash_strings.h"
+#include "ui/base/l10n/l10n_util.h"
 
 namespace ash {
 
 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.
@@ skipping 15 matching lines @@
   NOTREACHED() << "Invalid type " << type;
   return 1;
 }
 
 bool CompareByWeight(const ShelfItem& a, const ShelfItem& b) {
   return ShelfItemTypeToWeight(a.type) < ShelfItemTypeToWeight(b.type);
 }
 
 }  // namespace
 
-ShelfModel::ShelfModel() = default;
+const char kAppListId[] = "jlfapfmkapbjlfbpjedlinehodkccjee";
+
+ShelfModel::ShelfModel() {
+  // Add the app list item.
+  ShelfItem item;
+  item.type = TYPE_APP_LIST;
+  item.id = ShelfID(kAppListId);
+  item.title = l10n_util::GetStringUTF16(IDS_ASH_SHELF_APP_LIST_LAUNCHER_TITLE);
+  const int index = Add(item);
+  DCHECK_EQ(0, index);
+}
 
 ShelfModel::~ShelfModel() = default;
 
 void ShelfModel::PinAppWithID(const std::string& app_id) {
   const ShelfID shelf_id(app_id);
 
   // If the app is already pinned, do nothing and return.
   if (IsAppPinned(shelf_id.app_id))
     return;
 
@@ skipping 42 matching lines @@
   // need early cleanup.
   id_to_item_delegate_map_.clear();
 }
 
 int ShelfModel::Add(const ShelfItem& item) {
   return AddAt(items_.size(), item);
 }
 
 int ShelfModel::AddAt(int index, const ShelfItem& item) {
   // Items should have unique non-empty ids to avoid undefined model behavior.
-  DCHECK(!item.id.IsNull());
-  DCHECK_EQ(ItemIndexByID(item.id), -1);
+  DCHECK(!item.id.IsNull()) << " The id is null.";
+  DCHECK_EQ(ItemIndexByID(item.id), -1) << " The id is not unique: " << item.id;
   index = ValidateInsertionIndex(item.type, index);
   items_.insert(items_.begin() + index, item);
   for (auto& observer : observers_)
     observer.ShelfItemAdded(index);
   return index;
 }
 
 void ShelfModel::RemoveItemAt(int index) {
   DCHECK(index >= 0 && index < item_count());
   ShelfItem old_item(items_[index]);
@@ skipping 82 matching lines @@
          items_.begin();
 }
 
 void ShelfModel::SetShelfItemDelegate(
     const ShelfID& shelf_id,
     std::unique_ptr<ShelfItemDelegate> item_delegate) {
   if (item_delegate)
     item_delegate->set_shelf_id(shelf_id);
   // This assignment replaces any ShelfItemDelegate already registered for |id|.
   id_to_item_delegate_map_[shelf_id] = std::move(item_delegate);
+  for (auto& observer : observers_) {
+    observer.ShelfItemDelegateChanged(shelf_id,
+                                      id_to_item_delegate_map_[shelf_id].get());
+  }
 }
 
 ShelfItemDelegate* ShelfModel::GetShelfItemDelegate(const ShelfID& shelf_id) {
   auto it = id_to_item_delegate_map_.find(shelf_id);
   if (it != id_to_item_delegate_map_.end())
     return it->second.get();
   return nullptr;
 }
 
 void ShelfModel::AddObserver(ShelfModelObserver* observer) {
@@ skipping 16 matching lines @@
                    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