Launch panels as popup windows in Aura, and add separate launcher icon logic for panels.

chrome/browser/ui/views/aura/launcher/chrome_launcher_delegate.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/views/aura/launcher/chrome_launcher_delegate.h"
 
 #include "ash/launcher/launcher_model.h"
 #include "ash/launcher/launcher_types.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
@@ skipping 21 matching lines @@
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
 #include "grit/theme_resources.h"
 #include "ui/aura/window.h"
 #include "ui/views/widget/widget.h"
 
 namespace {
 
 // See description in PersistPinnedState().
 const char kAppIDPath[] = "id";
+const char kAppTypePanel[] = "panel";
 const char kAppTypePath[] = "type";
 const char kAppTypeTab[] = "tab";
 const char kAppTypeWindow[] = "window";
 
 }  // namespace
 
 // ChromeLauncherDelegate::Item ------------------------------------------------
 
 ChromeLauncherDelegate::Item::Item()
     : item_type(TYPE_TABBED_BROWSER),
@@ skipping 40 matching lines @@
 void ChromeLauncherDelegate::Init() {
   const base::ListValue* pinned_apps =
       profile_->GetPrefs()->GetList(prefs::kPinnedLauncherApps);
   for (size_t i = 0; i < pinned_apps->GetSize(); ++i) {
     DictionaryValue* app = NULL;
     if (pinned_apps->GetDictionary(i, &app)) {
       std::string app_id, type_string;
       if (app->GetString(kAppIDPath, &app_id) &&
           app->GetString(kAppTypePath, &type_string) &&
           app_icon_loader_->IsValidID(app_id)) {
-        AppType app_type = (type_string == kAppTypeWindow) ?
-            APP_TYPE_WINDOW : APP_TYPE_TAB;
+        AppType app_type;
+        if (type_string == kAppTypeWindow)
+          app_type = APP_TYPE_WINDOW;
+        else if (type_string == kAppTypePanel)
+          app_type = APP_TYPE_PANEL;
+        else
+          app_type = APP_TYPE_TAB;
         CreateAppLauncherItem(NULL, app_id, app_type);
       }
     }
   }
 }
 
 // static
 void ChromeLauncherDelegate::RegisterUserPrefs(PrefService* user_prefs) {
   // TODO: If we want to support multiple profiles this will likely need to be
   // pushed to local state and we'll need to track profile per item.
@@ skipping 54 matching lines @@
           min_tab_index =
               std::min(min_app_index, model_->ItemIndexByID(i->first));
         }
       }
     }
   }
   int insert_index = min_app_index != item_count ?
       min_app_index : std::min(item_count, min_tab_index + 1);
   ash::LauncherID id = model_->next_id();
   ash::LauncherItem item(ash::TYPE_APP);
+  item.image = Extension::GetDefaultIcon(true);
   model_->Add(insert_index, item);
   DCHECK(id_to_item_map_.find(id) == id_to_item_map_.end());
   id_to_item_map_[id].item_type = TYPE_APP;
   id_to_item_map_[id].app_type = app_type;
   id_to_item_map_[id].app_id = app_id;
   id_to_item_map_[id].updater = updater;
   id_to_item_map_[id].pinned = updater == NULL;
 
   app_icon_loader_->FetchImage(app_id);
   return id;
@@ skipping 97 matching lines @@
   if (updater) {
     updater->window()->Show();
     ash::wm::ActivateWindow(updater->window());
     TabContentsWrapper* tab = updater->GetTab(id);
     if (tab) {
       updater->tab_model()->ActivateTabAt(
           updater->tab_model()->GetIndexOfTabContents(tab), true);
     }
   } else {
     DCHECK_EQ(TYPE_APP, id_to_item_map_[id].item_type);
-    if (id_to_item_map_[id].app_type == APP_TYPE_TAB) {
+    AppType app_type = id_to_item_map_[id].app_type;
+    if (app_type == APP_TYPE_TAB) {
       const Extension* extension =
           profile_->GetExtensionService()->GetInstalledExtension(
               id_to_item_map_[id].app_id);
       DCHECK(extension);
       Browser::OpenApplicationTab(GetProfileForNewWindows(), extension, GURL(),
                                   NEW_FOREGROUND_TAB);
       if (id_to_item_map_[id].updater)
         id_to_item_map_[id].updater->window()->Show();
     } else {
       std::string app_name = web_app::GenerateApplicationNameFromExtensionId(
           id_to_item_map_[id].app_id);
+      Browser::Type browser_type = (app_type == APP_TYPE_PANEL) ?
+          Browser::TYPE_PANEL : Browser::TYPE_POPUP;
       Browser* browser = Browser::CreateForApp(
-          Browser::TYPE_POPUP, app_name, gfx::Rect(),
-          GetProfileForNewWindows());
+          browser_type, app_name, gfx::Rect(), GetProfileForNewWindows());
       browser->window()->Show();
     }
   }
 }
 
 void ChromeLauncherDelegate::Close(ash::LauncherID id) {
   if (id_to_item_map_.find(id) == id_to_item_map_.end())
     return;  // May happen if menu closed.
 
   if (!id_to_item_map_[id].updater)
@@ skipping 25 matching lines @@
   DCHECK(id_to_item_map_.find(id) != id_to_item_map_.end());
   return id_to_item_map_[id].app_type;
 }
 
 std::string ChromeLauncherDelegate::GetAppID(TabContentsWrapper* tab) {
   return app_icon_loader_->GetAppID(tab);
 }
 
 void ChromeLauncherDelegate::SetAppImage(const std::string& id,
                                          SkBitmap* image) {
+  if (!image)
+    return;
   for (IDToItemMap::const_iterator i = id_to_item_map_.begin();
        i != id_to_item_map_.end(); ++i) {
-    if (i->second.app_id == id) {
+    if (i->second.app_id == id &&
+        (!i->second.updater ||
+         i->second.updater->type() != LauncherUpdater::TYPE_PANEL)) {

[sky, 2012/03/05 15:20:25]

Rather than this if, could you avoid asking for the image for type panels?

[stevenjb, 2012/03/05 19:50:06]

Looking through the code again (with a bit more familiarity now), I see that I
can avoid calling app_icon_loader_->FetchImage() in
ChromeLauncherDelegate::CreateAppLauncherItem(), and will add that.

However, we could still have an app, a panel it created, and a popup window it
created all in the launcher, all with the same app_id, so we need a way of
preventing updates with the same app_id from overriding icons set by the panel.
We may need an explicit way of doing this, but for now skipping panels (which
will always set their icon from LauncherUpdater::UpdateLauncher()) seems
easiest.

I did realize that we store item.app_type (not to be confused with
item.item_type), which does differentiate between PANEL and APP, so I will use
that instead of looking at the updater type.

       int index = model_->ItemIndexByID(i->first);
       ash::LauncherItem item = model_->items()[index];
-      item.image = image ? *image : Extension::GetDefaultIcon(true);
+      item.image = *image;
       model_->Set(index, item);
       // It's possible we're waiting on more than one item, so don't break.
     }
   }
 }
 
 void ChromeLauncherDelegate::CreateNewWindow() {
   Browser::OpenEmptyWindow(GetProfileForNewWindows());
 }
 
@@ skipping 65 matching lines @@
 void ChromeLauncherDelegate::PersistPinnedState() {
   ListPrefUpdate updater(profile_->GetPrefs(), prefs::kPinnedLauncherApps);
   updater.Get()->Clear();
   for (size_t i = 0; i < model_->items().size(); ++i) {
     if (model_->items()[i].type == ash::TYPE_APP) {
       ash::LauncherID id = model_->items()[i].id;
       if (id_to_item_map_.find(id) != id_to_item_map_.end() &&
           id_to_item_map_[id].pinned) {
         base::DictionaryValue* app_value = new base::DictionaryValue;
         app_value->SetString(kAppIDPath, id_to_item_map_[id].app_id);
-        const char* app_type_string =
-            id_to_item_map_[id].app_type == APP_TYPE_WINDOW ?
-            kAppTypeWindow : kAppTypeTab;
+        const char* app_type_string;
+        if (id_to_item_map_[id].app_type == APP_TYPE_WINDOW)
+          app_type_string = kAppTypeWindow;
+        else if (id_to_item_map_[id].app_type == APP_TYPE_PANEL)
+          app_type_string = kAppTypePanel;
+        else
+          app_type_string = kAppTypeTab;
         app_value->SetString(kAppTypePath, app_type_string);
         updater.Get()->Append(app_value);
       }
     }
   }
 }
 
 void ChromeLauncherDelegate::UnpinAppsWithID(const std::string& app_id) {
   for (IDToItemMap::iterator i = id_to_item_map_.begin();
        i != id_to_item_map_.end(); ) {
@@ skipping 11 matching lines @@
 Profile* ChromeLauncherDelegate::GetProfileForNewWindows() {
   Profile* profile = ProfileManager::GetDefaultProfile();
   if (browser_defaults::kAlwaysOpenIncognitoWindow &&
       IncognitoModePrefs::ShouldLaunchIncognito(
           *CommandLine::ForCurrentProcess(),
           profile->GetPrefs())) {
     profile = profile->GetOffTheRecordProfile();
   }
   return profile;
 }