Elim ActivateAppListItem, ChromeAppListItem

chrome/browser/ui/app_list/apps_model_builder.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 "chrome/browser/ui/app_list/apps_model_builder.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_sorting.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/install_tracker.h"
 #include "chrome/browser/extensions/install_tracker_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/extension_app_item.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_service.h"
 #include "ui/gfx/image/image_skia.h"
 
 using extensions::Extension;
+using app_list::AppListItemModel;
 
 namespace {
 
 bool AppPrecedes(const ExtensionAppItem* app1, const ExtensionAppItem* app2) {
+  if (!app1)
+    return app2;  // non-ExtensionAppItem follows ExtensionAppItem
+  if (!app2)
+    return true;  // ExtensionAppItem preceeds non-ExtensionAppItem

[jennyz, 2013/10/03 20:45:51]

Do you mean we should pass null for non-ExtensionAppItem for sorting? 

   const syncer::StringOrdinal& page1 = app1->GetPageOrdinal();
   const syncer::StringOrdinal& page2 = app2->GetPageOrdinal();
   if (page1.LessThan(page2))
     return true;
 
   if (page1.Equals(page2))
     return app1->GetAppLaunchOrdinal().LessThan(app2->GetAppLaunchOrdinal());
 
   return false;
 }
@@ skipping 60 matching lines @@
     return;
   model_->DeleteAt(i);
 }
 
 void AppsModelBuilder::OnExtensionLoaded(const Extension* extension) {
   if (!extension->ShouldDisplayInAppLauncher())
     return;
 
   const int existing_index = FindApp(extension->id());
   if (existing_index != -1) {
-    GetAppAt(existing_index)->Reload();
+    GetAppAt(existing_index)->Update();
     return;
   }
 
   InsertApp(new ExtensionAppItem(profile_,
                                  extension->id(),
                                  controller_,
                                  "",
                                  gfx::ImageSkia(),
                                  extension->is_platform_app()));
   UpdateHighlight();
 }
 
 void AppsModelBuilder::OnExtensionUnloaded(const Extension* extension) {
   int index = FindApp(extension->id());
   if (index < 0)
     return;
-  GetAppAt(index)->UpdateIcon();
+  GetAppAt(index)->Update();
 }
 
 void AppsModelBuilder::OnExtensionUninstalled(const Extension* extension) {
   int index = FindApp(extension->id());
   if (index < 0)
     return;
   model_->DeleteAt(index);
 }
 
 void AppsModelBuilder::OnAppsReordered() {
   ResortApps();
 }
 
 void AppsModelBuilder::OnAppInstalledToAppList(
     const std::string& extension_id) {
   SetHighlightedApp(extension_id);
 }
 
 void AppsModelBuilder::OnShutdown() {
   if (tracker_) {
     tracker_->RemoveObserver(this);
     tracker_ = NULL;
   }
 }
 
-void AppsModelBuilder::AddApps(const ExtensionSet* extensions, Apps* apps) {
+void AppsModelBuilder::AddApps(const ExtensionSet* extensions,
+                               ExtensionApps* apps) {
   for (ExtensionSet::const_iterator app = extensions->begin();
        app != extensions->end(); ++app) {
     if (ShouldDisplayInAppLauncher(profile_, *app))
       apps->push_back(new ExtensionAppItem(profile_,
                                            (*app)->id(),
                                            controller_,
                                            "",
                                            gfx::ImageSkia(),
                                            (*app)->is_platform_app()));
   }
@@ skipping 18 matching lines @@
   // Start observing after model is built.
   tracker_->AddObserver(this);
 }
 
 void AppsModelBuilder::PopulateApps() {
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   if (!service)
     return;
 
-  Apps apps;
+  ExtensionApps apps;
   AddApps(service->extensions(), &apps);
   AddApps(service->disabled_extensions(), &apps);
   AddApps(service->terminated_extensions(), &apps);
 
   if (apps.empty())
     return;
 
   service->extension_prefs()->extension_sorting()->FixNTPOrdinalCollisions();
   std::sort(apps.begin(), apps.end(), &AppPrecedes);
 
   for (size_t i = 0; i < apps.size(); ++i)
     model_->Add(apps[i]);
 }
 
 void AppsModelBuilder::ResortApps() {
   // Scan app items in |model_| and put the apps that do not have valid ordinals
   // into |invalid_ordinal_apps|. This is needed to handle uninstalling a
   // terminated app case, where there is no unload notification and uninstall
   // notification comes in after the app's ordinals are cleared.
   // See http://crbug.com/256749.
-  Apps apps;
-  Apps invalid_ordinal_apps;
+  ExtensionApps apps;
+  ExtensionApps invalid_ordinal_apps;
   for (size_t i = 0; i < model_->item_count(); ++i) {
-    ExtensionAppItem* app = GetAppAt(i);
+    ExtensionAppItem* app = GetExtensionAppAt(i);
     if (app->GetPageOrdinal().IsValid() && app->GetAppLaunchOrdinal().IsValid())
       apps.push_back(app);
     else
       invalid_ordinal_apps.push_back(app);
   }
 
   std::sort(apps.begin(), apps.end(), &AppPrecedes);
   apps.insert(
       apps.end(), invalid_ordinal_apps.begin(), invalid_ordinal_apps.end());
 
@@ skipping 14 matching lines @@
 }
 
 void AppsModelBuilder::InsertApp(ExtensionAppItem* app) {
   DCHECK(model_);
 
   size_t start = 0;
   size_t end = model_->item_count();
   while (start < end) {
     size_t mid = (start + end) / 2;
 
-    if (AppPrecedes(GetAppAt(mid), app))
+    if (AppPrecedes(GetExtensionAppAt(mid), app))
       start = mid + 1;
     else
       end = mid;
   }
   model_->AddAt(start, app);
 }
 
 int AppsModelBuilder::FindApp(const std::string& app_id) {
   DCHECK(model_);
 
   for (size_t i = 0; i < model_->item_count(); ++i) {
-    if (GetAppAt(i)->extension_id() == app_id)
+    if (GetAppAt(i)->app_id() == app_id)
       return i;
   }
 
   return -1;
 }
 
 void AppsModelBuilder::SetHighlightedApp(const std::string& extension_id) {
   if (extension_id == highlight_app_id_)
     return;
-  ExtensionAppItem* old_app = GetApp(highlight_app_id_);
+  AppListItemModel* old_app = GetApp(highlight_app_id_);
   if (old_app)
     old_app->SetHighlighted(false);
   highlight_app_id_ = extension_id;
-  ExtensionAppItem* new_app = GetApp(highlight_app_id_);
+  AppListItemModel* new_app = GetApp(highlight_app_id_);
   highlighted_app_pending_ = !new_app;
   if (new_app)
     new_app->SetHighlighted(true);
 }
 
-ExtensionAppItem* AppsModelBuilder::GetApp(
+AppListItemModel* AppsModelBuilder::GetApp(
     const std::string& extension_id) {
   DCHECK(model_);
   if (extension_id.empty())
     return NULL;
 
   int index = FindApp(extension_id);
   if (index == -1)
     return NULL;
   return GetAppAt(index);
 }
 
 void AppsModelBuilder::UpdateHighlight() {
   DCHECK(model_);
   if (!highlighted_app_pending_ || highlight_app_id_.empty())
     return;
 
   int index = FindApp(highlight_app_id_);
   if (index == -1)
     return;
 
   model_->GetItemAt(index)->SetHighlighted(true);
   highlighted_app_pending_ = false;
 }
 
-ExtensionAppItem* AppsModelBuilder::GetAppAt(size_t index) {
+AppListItemModel* AppsModelBuilder::GetAppAt(size_t index) {
   DCHECK_LT(index, model_->item_count());
-  ChromeAppListItem* item =
-      static_cast<ChromeAppListItem*>(model_->GetItemAt(index));
-  DCHECK_EQ(item->type(), ChromeAppListItem::TYPE_APP);
+  return model_->GetItemAt(index);
+}
 
-  return static_cast<ExtensionAppItem*>(item);
+ExtensionAppItem* AppsModelBuilder::GetExtensionAppAt(size_t index) {
+  AppListItemModel* app = GetAppAt(index);
+  if (app->AppType() != ExtensionAppItem::ExtensionAppType())
+    return NULL;
+  return static_cast<ExtensionAppItem*>(app);
 }
 
 void AppsModelBuilder::ListItemsAdded(size_t start, size_t count) {
 }
 
 void AppsModelBuilder::ListItemsRemoved(size_t start, size_t count) {
 }
 
 void AppsModelBuilder::ListItemMoved(size_t index, size_t target_index) {
   if (ignore_changes_)
     return;
 
-  ExtensionAppItem* prev = target_index > 0 ? GetAppAt(target_index - 1) : NULL;
+  ExtensionAppItem* prev = target_index > 0 ?
+      GetExtensionAppAt(target_index - 1) : NULL;
   ExtensionAppItem* next = target_index + 1 < model_->item_count() ?
-      GetAppAt(target_index + 1) : NULL;
-  GetAppAt(target_index)->Move(prev, next);
+      GetExtensionAppAt(target_index + 1) : NULL;
+  ExtensionAppItem* target_app = GetExtensionAppAt(target_index);
+  target_app->Move(prev, next);
 }
 
 void AppsModelBuilder::ListItemsChanged(size_t start, size_t count) {
   NOTREACHED();
 }