okashii

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 51 matching lines @@
 
 // ChromeLauncherDelegate ------------------------------------------------------
 
 // static
 ChromeLauncherDelegate* ChromeLauncherDelegate::instance_ = NULL;
 
 ChromeLauncherDelegate::ChromeLauncherDelegate(Profile* profile,
                                                ash::LauncherModel* model)
     : model_(model),
       profile_(profile) {
-  if (!profile_) {
-    // Use the original profile as on chromeos we may get a temporary off the
-    // record profile.
-    profile_ = ProfileManager::GetDefaultProfile()->GetOriginalProfile();
-  }
   instance_ = this;
   model_->AddObserver(this);
-  app_icon_loader_.reset(new LauncherAppIconLoader(profile_, this));
-  registrar_.Add(this,
-                 chrome::NOTIFICATION_EXTENSION_UNLOADED,
-                 content::Source<Profile>(profile_));
+
+  if (profile) {
+    PostProfileInit();
+  } else {
+    registrar_.Add(this,
+                   chrome::NOTIFICATION_PROFILE_CREATED,
+                   content::NotificationService::AllSources());
+  }
 }
 
 ChromeLauncherDelegate::~ChromeLauncherDelegate() {
   model_->RemoveObserver(this);
   for (IDToItemMap::iterator i = id_to_item_map_.begin();
        i != id_to_item_map_.end(); ++i) {
     model_->RemoveItemAt(model_->ItemIndexByID(i->first));
   }
   if (instance_ == this)
     instance_ = NULL;
 }
 
-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;
-        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;
-        CreateAppLauncherItem(NULL, app_id, app_type, ash::STATUS_CLOSED);
-      }
-    }
-  }
-}
-
 // 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.
   user_prefs->RegisterListPref(prefs::kPinnedLauncherApps,
                                PrefService::SYNCABLE_PREF);
 }
 
 ash::LauncherID ChromeLauncherDelegate::CreateTabbedLauncherItem(
     LauncherUpdater* updater,
@@ skipping 18 matching lines @@
   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) {
+  DCHECK(profile_);
   // See if we have a closed item that matches the app.
   if (updater) {
     for (IDToItemMap::iterator i = id_to_item_map_.begin();
          i != id_to_item_map_.end(); ++i) {
       if (i->second.updater == NULL && i->second.app_id == app_id &&
           i->second.app_type == app_type) {
         i->second.updater = updater;
         SetItemStatus(i->first, status);
         return i->first;
       }
@@ skipping 56 matching lines @@
   id_to_item_map_[id].item_type = TYPE_TABBED_BROWSER;
   id_to_item_map_[id].app_id.clear();
 }
 
 void ChromeLauncherDelegate::ConvertTabbedToApp(ash::LauncherID id,
                                                 const std::string& app_id,
                                                 AppType app_type) {
   DCHECK(id_to_item_map_.find(id) != id_to_item_map_.end());
   DCHECK_EQ(TYPE_TABBED_BROWSER, id_to_item_map_[id].item_type);
   DCHECK(!id_to_item_map_[id].pinned);
+  DCHECK(profile_);
   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;
 
   ash::LauncherItem item;
   item.type = ash::TYPE_APP;
   item.is_incognito = false;
   item.id = id;
   model_->Set(model_->ItemIndexByID(id), item);
 
   app_icon_loader_->FetchImage(app_id);
 }
 
 void ChromeLauncherDelegate::LauncherItemClosed(ash::LauncherID id) {
   DCHECK(id_to_item_map_.find(id) != id_to_item_map_.end());
   if (id_to_item_map_[id].pinned) {
     // The item is pinned, leave it in the launcher.
     id_to_item_map_[id].updater = NULL;
     SetItemStatus(id, ash::STATUS_CLOSED);
   } else {
     id_to_item_map_.erase(id);
     model_->RemoveItemAt(model_->ItemIndexByID(id));
   }
 }
 
 void ChromeLauncherDelegate::AppIDChanged(ash::LauncherID id,
                                           const std::string& app_id) {
   DCHECK(id_to_item_map_.find(id) != id_to_item_map_.end());
+  DCHECK(profile_);
   id_to_item_map_[id].app_id = app_id;
   PersistPinnedState();
 
   app_icon_loader_->FetchImage(app_id);
 }
 
 bool ChromeLauncherDelegate::HasClosedAppItem(const std::string& app_id,
                                               AppType app_type) {
   for (IDToItemMap::const_iterator i = id_to_item_map_.begin();
        i != id_to_item_map_.end(); ++i) {
@@ skipping 35 matching lines @@
 
 bool ChromeLauncherDelegate::IsPinnable(ash::LauncherID id) {
   // Only app windows and app panel windows can properly restore themselves;
   // exptension panels can not so should not be pinnable.
   return 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_EXTENSION_PANEL;
 }
 
 void ChromeLauncherDelegate::Open(ash::LauncherID id) {
+  DCHECK(profile_);
+
   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());
     TabContentsWrapper* tab = updater->GetTab(id);
     if (tab) {
       updater->tab_model()->ActivateTabAt(
@@ skipping 55 matching lines @@
       id_to_item_map_[id].updater != NULL;
 }
 
 ChromeLauncherDelegate::AppType ChromeLauncherDelegate::GetAppType(
     ash::LauncherID id) {
   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) {
+  DCHECK(profile_);
   return app_icon_loader_->GetAppID(tab);
 }
 
 void ChromeLauncherDelegate::SetAppImage(const std::string& id,
                                          const SkBitmap* image) {
   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,
@@ skipping 17 matching lines @@
   DCHECK(id_to_item_map_.find(item.id) != id_to_item_map_.end());
   Open(item.id);
 }
 
 int ChromeLauncherDelegate::GetBrowserShortcutResourceId() {
   return IDR_PRODUCT_LOGO_32;
 }
 
 string16 ChromeLauncherDelegate::GetTitle(const ash::LauncherItem& item) {
   DCHECK(id_to_item_map_.find(item.id) != id_to_item_map_.end());
+  DCHECK(profile_);
   LauncherUpdater* updater = id_to_item_map_[item.id].updater;
   if (updater) {
     if (id_to_item_map_[item.id].item_type == TYPE_TABBED_BROWSER) {
       return updater->tab_model()->GetActiveTabContents() ?
           updater->tab_model()->GetActiveTabContents()->web_contents()->
           GetTitle() : string16();
     }
     // Fall through to get title from extension.
   }
   const Extension* extension = profile_->GetExtensionService()->
@@ skipping 49 matching lines @@
   }
 }
 
 void ChromeLauncherDelegate::LauncherItemWillChange(int index) {
 }
 
 void ChromeLauncherDelegate::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  DCHECK_EQ(type, chrome::NOTIFICATION_EXTENSION_UNLOADED);
-  const Extension* extension =
-      content::Details<UnloadedExtensionInfo>(details)->extension;
-  UnpinAppsWithID(extension->id());
+  switch (type) {
+    case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
+      const Extension* extension =
+          content::Details<UnloadedExtensionInfo>(details)->extension;
+      UnpinAppsWithID(extension->id());
+      break;
+    }
+    case chrome::NOTIFICATION_PROFILE_CREATED: {
+      profile_ = content::Source<Profile>(source)->GetOriginalProfile();
+      PostProfileInit();
+
+      registrar_.Remove(this,
+                        chrome::NOTIFICATION_PROFILE_CREATED,
+                        content::NotificationService::AllSources());
+      break;
+    }
+    default:
+      NOTREACHED();
+  }
+}
+
+void ChromeLauncherDelegate::PostProfileInit() {
+  DCHECK(profile_);
+  SetAppIconLoader(new LauncherAppIconLoader(profile_, this));
+
+  registrar_.Add(this,
+                 chrome::NOTIFICATION_EXTENSION_UNLOADED,
+                 content::Source<Profile>(profile_));
 }
 
 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) {
@@ skipping 21 matching lines @@
 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 && current->second.pinned)
       Unpin(current->first);
   }
 }
 
-void ChromeLauncherDelegate::SetAppIconLoaderForTest(AppIconLoader* loader) {
+void ChromeLauncherDelegate::SetAppIconLoader(AppIconLoader* loader) {
+  DCHECK(profile_);
   app_icon_loader_.reset(loader);
+
+  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;
+        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;
+        CreateAppLauncherItem(NULL, app_id, app_type, ash::STATUS_CLOSED);
+      }
+    }
+  }
 }
 
 Profile* ChromeLauncherDelegate::GetProfileForNewWindows() {
   return ProfileManager::GetDefaultProfileOrOffTheRecord();
 }