ash: Replace launcher app type with Extension launch type.

chrome/browser/ui/views/ash/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/ash/launcher/chrome_launcher_delegate.h"
 
 #include "ash/launcher/launcher_model.h"
 #include "ash/launcher/launcher_types.h"
 #include "ash/shell.h"
 #include "ash/wm/window_util.h"
@@ skipping 24 matching lines @@
 #include "content/public/browser/web_contents.h"
 #include "grit/theme_resources.h"
 #include "ui/aura/client/activation_client.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";
 
 // Values used for prefs::kShelfAutoHideBehavior.
 const char kShelfAutoHideBehaviorAlways[] = "Always";
 const char kShelfAutoHideBehaviorDefault[] = "Default";
 const char kShelfAutoHideBehaviorNever[] = "Never";
 
 // App ID of default pinned apps.
 const char* kDefaultPinnedApps[] = {
   "pjkljhegncpnkpknbcohdijeoejaedia",  // Gamil
   "coobgpohoikkiipiblmjeljniedjpjpf",  // Search
   "apdfllckaahabafndbhieahigkjlhalf",  // Doc
   "blpcfgokakmgnkcojhhkbfbldkacnbeo",  // YouTube
 };
 
-base::DictionaryValue* CreateAppDict(
-    const std::string& app_id,
-    ChromeLauncherDelegate::AppType app_type) {
+base::DictionaryValue* CreateAppDict(const std::string& app_id) {
   scoped_ptr<base::DictionaryValue> app_value(new base::DictionaryValue);
   app_value->SetString(kAppIDPath, app_id);
-  const char* app_type_string;
-  if (app_type == ChromeLauncherDelegate::APP_TYPE_WINDOW) {
-    app_type_string = kAppTypeWindow;
-  } else if (app_type == ChromeLauncherDelegate::APP_TYPE_APP_PANEL) {
-    app_type_string = kAppTypePanel;
-  } else if (app_type == ChromeLauncherDelegate::APP_TYPE_TAB) {
-    app_type_string = kAppTypeTab;
-  } else {
-    LOG(ERROR) << "Unsupported pinned type: " << app_type;
-    return NULL;
-  }
-  app_value->SetString(kAppTypePath, app_type_string);
   return app_value.release();
 }
 
 base::ListValue* CreateDefaultPinnedAppsList() {
   scoped_ptr<base::ListValue> apps(new base::ListValue);
-  for (size_t i = 0; i < arraysize(kDefaultPinnedApps); ++i) {
-    apps->Append(CreateAppDict(
-        kDefaultPinnedApps[i],
-        ChromeLauncherDelegate::APP_TYPE_TAB));
-  }
+  for (size_t i = 0; i < arraysize(kDefaultPinnedApps); ++i)
+    apps->Append(CreateAppDict(kDefaultPinnedApps[i]));
+
   return apps.release();
 }
 
 }  // namespace
 
 // ChromeLauncherDelegate::Item ------------------------------------------------
 
 ChromeLauncherDelegate::Item::Item()
     : item_type(TYPE_TABBED_BROWSER),
-      app_type(APP_TYPE_WINDOW),
       updater(NULL) {
 }
 
 ChromeLauncherDelegate::Item::~Item() {
 }
 
 // ChromeLauncherDelegate ------------------------------------------------------
 
 // static
 ChromeLauncherDelegate* ChromeLauncherDelegate::instance_ = NULL;
@@ skipping 51 matching lines @@
       !profile_->GetPrefs()->GetBoolean(prefs::kUseDefaultPinnedApps)) {
     ListPrefUpdate updater(profile_->GetPrefs(), prefs::kPinnedLauncherApps);
     updater.Get()->Clear();
   }
 
   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)) {
-        AppType app_type;
-        if (type_string == kAppTypeWindow)
-          app_type = APP_TYPE_WINDOW;
-        else if (type_string == kAppTypePanel)
-          app_type = APP_TYPE_APP_PANEL;
-        else
-          app_type = APP_TYPE_TAB;
-
+      std::string app_id;
+      if (app->GetString(kAppIDPath, &app_id)) {
         if (app_icon_loader_->IsValidID(app_id)) {
-          CreateAppLauncherItem(NULL, app_id, app_type, ash::STATUS_CLOSED);
+          CreateAppLauncherItem(NULL, app_id, ash::STATUS_CLOSED);
         } else {
           Item pending_item;
           pending_item.item_type = TYPE_APP;
-          pending_item.app_type = app_type;
           pending_item.app_id = app_id;
           pending_pinned_apps_.push(pending_item);
         }
       }
     }
   }
   // TODO(sky): update unit test so that this test isn't necessary.
   if (ash::Shell::HasInstance()) {
     std::string behavior_value(
         profile_->GetPrefs()->GetString(prefs::kShelfAutoHideBehavior));
@@ skipping 34 matching lines @@
   model_->Add(item);
   DCHECK(id_to_item_map_.find(id) == id_to_item_map_.end());
   id_to_item_map_[id].item_type = TYPE_TABBED_BROWSER;
   id_to_item_map_[id].updater = updater;
   return id;
 }
 
 ash::LauncherID ChromeLauncherDelegate::CreateAppLauncherItem(
     LauncherUpdater* updater,
     const std::string& app_id,
-    AppType app_type,
     ash::LauncherItemStatus status) {
   ash::LauncherID id = model_->next_id();
   ash::LauncherItem item;
   if (!updater) {
     item.type = ash::TYPE_APP_SHORTCUT;
-  } else if (app_type == APP_TYPE_APP_PANEL ||
-             app_type == APP_TYPE_EXTENSION_PANEL) {
+  } else if (updater->type() == LauncherUpdater::TYPE_APP_PANEL ||
+             updater->type() == LauncherUpdater::TYPE_EXTENSION_PANEL) {
     item.type = ash::TYPE_APP_PANEL;
   } else {
     item.type = ash::TYPE_TABBED;
   }
   item.is_incognito = false;
   item.image = Extension::GetDefaultIcon(true);
   item.status = status;
   model_->Add(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;
 
-  if (app_type != APP_TYPE_EXTENSION_PANEL)
+  if (!updater || updater->type() != LauncherUpdater::TYPE_EXTENSION_PANEL)
     app_icon_loader_->FetchImage(app_id);
   return id;
 }
 
 void ChromeLauncherDelegate::SetItemStatus(ash::LauncherID id,
                                            ash::LauncherItemStatus status) {
   int index = model_->ItemIndexByID(id);
   DCHECK_GE(index, 0);
   ash::LauncherItem item = model_->items()[index];
   item.status = status;
@@ skipping 35 matching lines @@
 void ChromeLauncherDelegate::Open(ash::LauncherID id) {
   if (id_to_item_map_.find(id) == id_to_item_map_.end())
     return;  // In case invoked from menu and item closed while menu up.
 
   LauncherUpdater* updater = id_to_item_map_[id].updater;
   if (updater) {
     updater->window()->Show();
     ash::wm::ActivateWindow(updater->window());
   } else {
     DCHECK_EQ(TYPE_APP, id_to_item_map_[id].item_type);
-    AppType app_type = id_to_item_map_[id].app_type;
-    extension_misc::LaunchContainer launch_container;
-    if (app_type == APP_TYPE_TAB) {
-      launch_container = extension_misc::LAUNCH_TAB;
-    } else if (app_type == APP_TYPE_APP_PANEL) {
-      launch_container = extension_misc::LAUNCH_PANEL;
-    } else if (app_type == APP_TYPE_WINDOW) {
-      launch_container = extension_misc::LAUNCH_WINDOW;
-    } else {
-      LOG(ERROR) << "Unsupported launcher item type: " << app_type;
-      return;
-    }
+
     const Extension* extension =
         profile_->GetExtensionService()->GetInstalledExtension(
             id_to_item_map_[id].app_id);
     DCHECK(extension);
+
+    extension_misc::LaunchContainer launch_container =
+        profile_->GetExtensionService()->extension_prefs()->GetLaunchContainer(
+            extension, ExtensionPrefs::LAUNCH_DEFAULT);
+
     Browser::OpenApplication(GetProfileForNewWindows(),
                              extension,
                              launch_container,
                              GURL(),
                              NEW_FOREGROUND_TAB);
   }
 }
 
 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)
     return;  // TODO: maybe should treat as unpin?
 
   views::Widget* widget = views::Widget::GetWidgetForNativeView(
       id_to_item_map_[id].updater->window());
   if (widget)
     widget->Close();
 }
 
 bool ChromeLauncherDelegate::IsOpen(ash::LauncherID id) {
   return id_to_item_map_.find(id) != id_to_item_map_.end() &&
       id_to_item_map_[id].updater != NULL;
 }
 
-ChromeLauncherDelegate::AppType ChromeLauncherDelegate::GetAppType(
+ExtensionPrefs::LaunchType ChromeLauncherDelegate::GetLaunchType(
     ash::LauncherID id) {
   DCHECK(id_to_item_map_.find(id) != id_to_item_map_.end());
-  return id_to_item_map_[id].app_type;
+
+  return profile_->GetExtensionService()->extension_prefs()->GetLaunchType(
+      id_to_item_map_[id].app_id, ExtensionPrefs::LAUNCH_DEFAULT);
 }
 
 std::string ChromeLauncherDelegate::GetAppID(TabContentsWrapper* tab) {
   return app_icon_loader_->GetAppID(tab);
 }
 
 void ChromeLauncherDelegate::SetAppImage(const std::string& id,
                                          const SkBitmap* image) {
   // TODO: need to get this working for shortcuts.
 
   for (IDToItemMap::const_iterator i = id_to_item_map_.begin();
        i != id_to_item_map_.end(); ++i) {
     if (i->second.app_id != id)
       continue;
+
     // Panel items may share the same app_id as the app that created them,
     // but they set their icon image in LauncherUpdater::UpdateLauncher(),
     // so do not set panel images here.
-    if (i->second.app_type == APP_TYPE_EXTENSION_PANEL)
+    if (i->second.updater &&
+        i->second.updater->type() == LauncherUpdater::TYPE_EXTENSION_PANEL) {
       continue;
+    }
+
     int index = model_->ItemIndexByID(i->first);
     ash::LauncherItem item = model_->items()[index];
     item.image = image ? *image : Extension::GetDefaultIcon(true);
     model_->Set(index, item);
     // It's possible we're waiting on more than one item, so don't break.
   }
 }
 
 bool ChromeLauncherDelegate::IsAppPinned(const std::string& app_id) {
   for (IDToItemMap::const_iterator i = id_to_item_map_.begin();
        i != id_to_item_map_.end(); ++i) {
     if (IsPinned(i->first) && i->second.app_id == app_id)
       return true;
   }
   return false;
 }
 
-void ChromeLauncherDelegate::PinAppWithID(const std::string& app_id,
-                                          AppType app_type) {
-  // If there is an item, update the app_type and return.
-  for (IDToItemMap::iterator i = id_to_item_map_.begin();
-       i != id_to_item_map_.end(); ++i) {
-    if (i->second.app_id == app_id && IsPinned(i->first)) {
-      DCHECK_EQ(ash::TYPE_APP_SHORTCUT,
-                model_->ItemByID(i->first)->type);
-      i->second.app_type = app_type;
-      return;
-    }
-  }
+void ChromeLauncherDelegate::PinAppWithID(const std::string& app_id) {
+  // If there is an item, do nothing and return.
+  if (IsAppPinned(app_id))
+    return;
 
   // Otherwise, create an item for it.
-  CreateAppLauncherItem(NULL, app_id, app_type, ash::STATUS_CLOSED);
+  CreateAppLauncherItem(NULL, app_id, ash::STATUS_CLOSED);
   PersistPinnedState();
 }
 
-void ChromeLauncherDelegate::SetAppType(ash::LauncherID id, AppType app_type) {
+void ChromeLauncherDelegate::SetLaunchType(
+    ash::LauncherID id,
+    ExtensionPrefs::LaunchType launch_type) {
   if (id_to_item_map_.find(id) == id_to_item_map_.end())
     return;
 
-  id_to_item_map_[id].app_type = app_type;
+  return profile_->GetExtensionService()->extension_prefs()->SetLaunchType(
+      id_to_item_map_[id].app_id, launch_type);
 }
 
 void ChromeLauncherDelegate::UnpinAppsWithID(const std::string& app_id) {
   for (IDToItemMap::iterator i = id_to_item_map_.begin();
        i != id_to_item_map_.end(); ) {
     IDToItemMap::iterator current(i);
     ++i;
     if (current->second.app_id == app_id && IsPinned(current->first))
       Unpin(current->first);
   }
@@ skipping 150 matching lines @@
   profile_->GetPrefs()->SetBoolean(prefs::kUseDefaultPinnedApps, false);
 
   ListPrefUpdate updater(profile_->GetPrefs(), prefs::kPinnedLauncherApps);
   updater->Clear();
   for (size_t i = 0; i < model_->items().size(); ++i) {
     if (model_->items()[i].type == ash::TYPE_APP_SHORTCUT) {
       ash::LauncherID id = model_->items()[i].id;
       if (id_to_item_map_.find(id) != id_to_item_map_.end() &&
           IsPinned(id)) {
         base::DictionaryValue* app_value = CreateAppDict(
-            id_to_item_map_[id].app_id,
-            id_to_item_map_[id].app_type);
+            id_to_item_map_[id].app_id);
         if (app_value)
           updater->Append(app_value);
       }
     }
   }
 }
 
 void ChromeLauncherDelegate::SetAppIconLoaderForTest(AppIconLoader* loader) {
   app_icon_loader_.reset(loader);
 }
 
 Profile* ChromeLauncherDelegate::GetProfileForNewWindows() {
   return ProfileManager::GetDefaultProfileOrOffTheRecord();
 }
 
 void ChromeLauncherDelegate::ProcessPendingPinnedApps() {
   while (!pending_pinned_apps_.empty()) {
     const Item& item = pending_pinned_apps_.front();
 
     if (!app_icon_loader_->IsValidID(item.app_id))
       return;
 
-    PinAppWithID(item.app_id, item.app_type);
+    PinAppWithID(item.app_id);
     pending_pinned_apps_.pop();
   }
 }