// Copyright (c) 2011 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/jumplist_win.h" #include <windows.h> #include <shobjidl.h> #include <propkey.h> #include <propvarutil.h> #include <string> #include <vector> #include "base/callback.h" #include "base/command_line.h" #include "base/file_util.h" #include "base/path_service.h" #include "base/string_util.h" #include "base/threading/thread.h" #include "base/utf_string_conversions.h" #include "base/win/scoped_comptr.h" #include "base/win/windows_version.h" #include "chrome/browser/favicon_service.h" #include "chrome/browser/history/history.h" #include "chrome/browser/history/page_usage_data.h" #include "chrome/browser/profiles/profile.h" #include "chrome/browser/sessions/session_types.h" #include "chrome/browser/sessions/tab_restore_service.h" #include "chrome/browser/shell_integration.h" #include "chrome/common/chrome_constants.h" #include "chrome/common/chrome_switches.h" #include "chrome/common/url_constants.h" #include "content/browser/browser_thread.h" #include "googleurl/src/gurl.h" #include "grit/chromium_strings.h" #include "grit/generated_resources.h" #include "third_party/skia/include/core/SkBitmap.h" #include "ui/base/l10n/l10n_util.h" #include "ui/gfx/codec/png_codec.h" #include "ui/gfx/icon_util.h" namespace { // COM interfaces used in this file. // These interface declarations are copied from Windows SDK 7.0. // TODO(hbono): Bug 16903: delete them when we use Windows SDK 7.0. #ifndef __IObjectArray_INTERFACE_DEFINED__ #define __IObjectArray_INTERFACE_DEFINED__ MIDL_INTERFACE("92CA9DCD-5622-4bba-A805-5E9F541BD8C9") IObjectArray : public IUnknown { public: virtual HRESULT STDMETHODCALLTYPE GetCount( /* [out] */ __RPC__out UINT *pcObjects) = 0; virtual HRESULT STDMETHODCALLTYPE GetAt( /* [in] */ UINT uiIndex, /* [in] */ __RPC__in REFIID riid, /* [iid_is][out] */ __RPC__deref_out_opt void **ppv) = 0; }; #endif // __IObjectArray_INTERFACE_DEFINED__ #ifndef __IObjectCollection_INTERFACE_DEFINED__ #define __IObjectCollection_INTERFACE_DEFINED__ MIDL_INTERFACE("5632b1a4-e38a-400a-928a-d4cd63230295") IObjectCollection : public IObjectArray { public: virtual HRESULT STDMETHODCALLTYPE AddObject( /* [in] */ __RPC__in_opt IUnknown *punk) = 0; virtual HRESULT STDMETHODCALLTYPE AddFromArray( /* [in] */ __RPC__in_opt IObjectArray *poaSource) = 0; virtual HRESULT STDMETHODCALLTYPE RemoveObjectAt( /* [in] */ UINT uiIndex) = 0; virtual HRESULT STDMETHODCALLTYPE Clear(void) = 0; }; #endif // __IObjectCollection_INTERFACE_DEFINED__ #ifndef __ICustomDestinationList_INTERFACE_DEFINED__ #define __ICustomDestinationList_INTERFACE_DEFINED__ typedef /* [v1_enum] */ enum tagKNOWNDESTCATEGORY { KDC_FREQUENT = 1, KDC_RECENT = (KDC_FREQUENT + 1) } KNOWNDESTCATEGORY; MIDL_INTERFACE("6332debf-87b5-4670-90c0-5e57b408a49e") ICustomDestinationList : public IUnknown { public: virtual HRESULT STDMETHODCALLTYPE SetAppID( /* [string][in] */__RPC__in_string LPCWSTR pszAppID) = 0; virtual HRESULT STDMETHODCALLTYPE BeginList( /* [out] */ __RPC__out UINT *pcMaxSlots, /* [in] */ __RPC__in REFIID riid, /* [iid_is][out] */ __RPC__deref_out_opt void **ppv) = 0; virtual HRESULT STDMETHODCALLTYPE AppendCategory( /* [string][in] */ __RPC__in_string LPCWSTR pszCategory, /* [in] */ __RPC__in_opt IObjectArray *poa) = 0; virtual HRESULT STDMETHODCALLTYPE AppendKnownCategory( /* [in] */ KNOWNDESTCATEGORY category) = 0; virtual HRESULT STDMETHODCALLTYPE AddUserTasks( /* [in] */ __RPC__in_opt IObjectArray *poa) = 0; virtual HRESULT STDMETHODCALLTYPE CommitList(void) = 0; virtual HRESULT STDMETHODCALLTYPE GetRemovedDestinations( /* [in] */ __RPC__in REFIID riid, /* [iid_is][out] */ __RPC__deref_out_opt void **ppv) = 0; virtual HRESULT STDMETHODCALLTYPE DeleteList( /* [string][in] */ __RPC__in_string LPCWSTR pszAppID) = 0; virtual HRESULT STDMETHODCALLTYPE AbortList(void) = 0; }; #endif // __ICustomDestinationList_INTERFACE_DEFINED__ // Class IDs used in this file. // These class IDs must be defined in an anonymous namespace to avoid // conflicts with ones defined in "shell32.lib" of Visual Studio 2008. // TODO(hbono): Bug 16903: delete them when we use Windows SDK 7.0. const CLSID CLSID_DestinationList = { 0x77f10cf0, 0x3db5, 0x4966, {0xb5, 0x20, 0xb7, 0xc5, 0x4f, 0xd3, 0x5e, 0xd6} }; const CLSID CLSID_EnumerableObjectCollection = { 0x2d3468c1, 0x36a7, 0x43b6, {0xac, 0x24, 0xd3, 0xf0, 0x2f, 0xd9, 0x60, 0x7a} }; }; // namespace // END OF WINDOWS 7 SDK DEFINITIONS namespace { // Represents a class which encapsulates a PROPVARIANT object containing a // string for AddShellLink(). // This class automatically deletes all the resources attached to the // PROPVARIANT object in its destructor. class PropVariantString { public: PropVariantString() { property_.vt = VT_EMPTY; } HRESULT Init(const std::wstring& value) { // Call InitPropVariantFromString() to initialize this PROPVARIANT object. // To read <propvarutil.h>, it seems InitPropVariantFromString() is an // inline function that initialize a PROPVARIANT object and calls // SHStrDupW() to set a copy of its input string. // So, we just calls it without creating a copy. return InitPropVariantFromString(value.c_str(), &property_); } ~PropVariantString() { if (property_.vt != VT_EMPTY) PropVariantClear(&property_); } const PROPVARIANT& Get() { return property_; } private: PROPVARIANT property_; DISALLOW_COPY_AND_ASSIGN(PropVariantString); }; // Creates an IShellLink object. // An IShellLink object is almost the same as an application shortcut, and it // requires three items: the absolute path to an application, an argument // string, and a title string. HRESULT AddShellLink(base::win::ScopedComPtr<IObjectCollection> collection, const std::wstring& application, const std::wstring& switches, scoped_refptr<ShellLinkItem> item) { // Create an IShellLink object. base::win::ScopedComPtr<IShellLink> link; HRESULT result = link.CreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER); if (FAILED(result)) return result; // Set the application path. // We should exit this function when this call fails because it doesn't make // any sense to add a shortcut that we cannot execute. result = link->SetPath(application.c_str()); if (FAILED(result)) return result; // Attach the command-line switches of this process before the given // arguments and set it as the arguments of this IShellLink object. // We also exit this function when this call fails because it isn't usuful to // add a shortcut that cannot open the given page. std::wstring arguments(switches); if (!item->arguments().empty()) { arguments.push_back(L' '); arguments += item->arguments(); } result = link->SetArguments(arguments.c_str()); if (FAILED(result)) return result; // Attach the given icon path to this IShellLink object. // Since an icon is an optional item for an IShellLink object, so we don't // have to exit even when it fails. if (!item->icon().empty()) link->SetIconLocation(item->icon().c_str(), item->index()); // Set the title of the IShellLink object. // The IShellLink interface does not have any functions which update its // title because this interface is originally for creating an application // shortcut which doesn't have titles. // So, we should use the IPropertyStore interface to set its title as // listed in the steps below: // 1. Retrieve the IPropertyStore interface from the IShellLink object; // 2. Start a transaction that changes a value of the object with the // IPropertyStore interface; // 3. Create a string PROPVARIANT, and; // 4. Call the IPropertyStore::SetValue() function to Set the title property // of the IShellLink object. // 5. Commit the transaction. base::win::ScopedComPtr<IPropertyStore> property_store; result = link.QueryInterface(property_store.Receive()); if (FAILED(result)) return result; PropVariantString property_title; result = property_title.Init(item->title()); if (FAILED(result)) return result; result = property_store->SetValue(PKEY_Title, property_title.Get()); if (FAILED(result)) return result; result = property_store->Commit(); if (FAILED(result)) return result; // Add this IShellLink object to the given collection. return collection->AddObject(link); } // Creates a temporary icon file to be shown in JumpList. bool CreateIconFile(const SkBitmap& bitmap, const FilePath& icon_dir, FilePath* icon_path) { // Retrieve the path to a temporary file. // We don't have to care about the extension of this temporary file because // JumpList does not care about it. FilePath path; if (!file_util::CreateTemporaryFileInDir(icon_dir, &path)) return false; // Create an icon file from the favicon attached to the given |page|, and // save it as the temporary file. if (!IconUtil::CreateIconFileFromSkBitmap(bitmap, path)) return false; // Add this icon file to the list and return its absolute path. // The IShellLink::SetIcon() function needs the absolute path to an icon. *icon_path = path; return true; } // Updates a specified category of an application JumpList. // This function cannot update registered categories (such as "Tasks") because // special steps are required for updating them. // So, this function can be used only for adding an unregistered category. // Parameters: // * category_id (int) // A string ID which contains the category name. // * application (std::wstring) // An application name to be used for creating JumpList items. // Even though we can add command-line switches to this parameter, it is // better to use the |switches| parameter below. // * switches (std::wstring) // Command-lien switches for the application. This string is to be added // before the arguments of each ShellLinkItem object. If there aren't any // switches, use an empty string. // * data (ShellLinkItemList) // A list of ShellLinkItem objects to be added under the specified category. HRESULT UpdateCategory(base::win::ScopedComPtr<ICustomDestinationList> list, int category_id, const std::wstring& application, const std::wstring& switches, const ShellLinkItemList& data, int max_slots) { // Exit this function when the given vector does not contain any items // because an ICustomDestinationList::AppendCategory() call fails in this // case. if (data.empty() || !max_slots) return S_OK; std::wstring category = UTF16ToWide(l10n_util::GetStringUTF16(category_id)); // Create an EnumerableObjectCollection object. // We once add the given items to this collection object and add this // collection to the JumpList. base::win::ScopedComPtr<IObjectCollection> collection; HRESULT result = collection.CreateInstance(CLSID_EnumerableObjectCollection, NULL, CLSCTX_INPROC_SERVER); if (FAILED(result)) return false; for (ShellLinkItemList::const_iterator item = data.begin(); item != data.end() && max_slots > 0; ++item, --max_slots) { scoped_refptr<ShellLinkItem> link(*item); AddShellLink(collection, application, switches, link); } // We can now add the new list to the JumpList. // The ICustomDestinationList::AppendCategory() function needs the // IObjectArray interface to retrieve each item in the list. So, we retrive // the IObjectArray interface from the IEnumeratableObjectCollection object // and use it. // It seems the ICustomDestinationList::AppendCategory() function just // replaces all items in the given category with the ones in the new list. base::win::ScopedComPtr<IObjectArray> object_array; result = collection.QueryInterface(object_array.Receive()); if (FAILED(result)) return false; return list->AppendCategory(category.c_str(), object_array); } // Updates the "Tasks" category of the JumpList. // Even though this function is almost the same as UpdateCategory(), this // function has the following differences: // * The "Task" category is a registered category. // We should use AddUserTasks() instead of AppendCategory(). // * The items in the "Task" category are static. // We don't have to use a list. HRESULT UpdateTaskCategory(base::win::ScopedComPtr<ICustomDestinationList> list, const std::wstring& chrome_path, const std::wstring& chrome_switches) { // Create an EnumerableObjectCollection object to be added items of the // "Task" category. (We can also use this object for the "Task" category.) base::win::ScopedComPtr<IObjectCollection> collection; HRESULT result = collection.CreateInstance(CLSID_EnumerableObjectCollection, NULL, CLSCTX_INPROC_SERVER); if (FAILED(result)) return result; // Create an IShellLink object which launches Chrome, and add it to the // collection. We use our application icon as the icon for this item. // We remove '&' characters from this string so we can share it with our // system menu. scoped_refptr<ShellLinkItem> chrome(new ShellLinkItem); std::wstring chrome_title = UTF16ToWide(l10n_util::GetStringUTF16(IDS_NEW_WINDOW)); ReplaceSubstringsAfterOffset(&chrome_title, 0, L"&", L""); chrome->SetTitle(chrome_title); chrome->SetIcon(chrome_path, 0, false); AddShellLink(collection, chrome_path, chrome_switches, chrome); // Create an IShellLink object which launches Chrome in incognito mode, and // add it to the collection. We use our application icon as the icon for // this item. scoped_refptr<ShellLinkItem> incognito(new ShellLinkItem); incognito->SetArguments( ASCIIToWide(std::string("--") + switches::kIncognito)); std::wstring incognito_title = UTF16ToWide(l10n_util::GetStringUTF16(IDS_NEW_INCOGNITO_WINDOW)); ReplaceSubstringsAfterOffset(&incognito_title, 0, L"&", L""); incognito->SetTitle(incognito_title); incognito->SetIcon(chrome_path, 0, false); AddShellLink(collection, chrome_path, chrome_switches, incognito); // We can now add the new list to the JumpList. // ICustomDestinationList::AddUserTasks() also uses the IObjectArray // interface to retrieve each item in the list. So, we retrieve the // IObjectArray interface from the EnumerableObjectCollection object. base::win::ScopedComPtr<IObjectArray> object_array; result = collection.QueryInterface(object_array.Receive()); if (FAILED(result)) return result; return list->AddUserTasks(object_array); } // Updates the application JumpList. // This function encapsulates all OS-specific operations required for updating // the Chromium JumpList, such as: // * Creating an ICustomDestinationList instance; // * Updating the categories of the ICustomDestinationList instance, and; // * Sending it to Taskbar of Windows 7. bool UpdateJumpList(const wchar_t* app_id, const ShellLinkItemList& most_visited_pages, const ShellLinkItemList& recently_closed_pages) { // JumpList is implemented only on Windows 7 or later. // So, we should return now when this function is called on earlier versions // of Windows. if (base::win::GetVersion() < base::win::VERSION_WIN7) return true; // Create an ICustomDestinationList object and attach it to our application. base::win::ScopedComPtr<ICustomDestinationList> destination_list; HRESULT result = destination_list.CreateInstance(CLSID_DestinationList, NULL, CLSCTX_INPROC_SERVER); if (FAILED(result)) return false; // Set the App ID for this JumpList. destination_list->SetAppID(app_id); // Start a transaction that updates the JumpList of this application. // This implementation just replaces the all items in this JumpList, so // we don't have to use the IObjectArray object returned from this call. // It seems Windows 7 RC (Build 7100) automatically checks the items in this // removed list and prevent us from adding the same item. UINT max_slots; base::win::ScopedComPtr<IObjectArray> removed; result = destination_list->BeginList(&max_slots, __uuidof(*removed), reinterpret_cast<void**>(&removed)); if (FAILED(result)) return false; // Retrieve the absolute path to "chrome.exe". FilePath chrome_path; if (!PathService::Get(base::FILE_EXE, &chrome_path)) return false; // Retrieve the command-line switches of this process. CommandLine command_line(CommandLine::NO_PROGRAM); FilePath user_data_dir = CommandLine::ForCurrentProcess()-> GetSwitchValuePath(switches::kUserDataDir); if (!user_data_dir.empty()) command_line.AppendSwitchPath(switches::kUserDataDir, user_data_dir); std::wstring chrome_switches = command_line.command_line_string(); // We allocate 60% of the given JumpList slots to "most-visited" items // and 40% to "recently-closed" items, respectively. // Nevertheless, if there are not so many items in |recently_closed_pages|, // we give the remaining slots to "most-visited" items. const int kMostVisited = 60; const int kRecentlyClosed = 40; const int kTotal = kMostVisited + kRecentlyClosed; size_t most_visited_items = MulDiv(max_slots, kMostVisited, kTotal); size_t recently_closed_items = max_slots - most_visited_items; if (recently_closed_pages.size() < recently_closed_items) { most_visited_items += recently_closed_items - recently_closed_pages.size(); recently_closed_items = recently_closed_pages.size(); } // Update the "Most Visited" category of the JumpList. // This update request is applied into the JumpList when we commit this // transaction. result = UpdateCategory(destination_list, IDS_NEW_TAB_MOST_VISITED, chrome_path.value(), chrome_switches, most_visited_pages, most_visited_items); if (FAILED(result)) return false; // Update the "Recently Closed" category of the JumpList. result = UpdateCategory(destination_list, IDS_NEW_TAB_RECENTLY_CLOSED, chrome_path.value(), chrome_switches, recently_closed_pages, recently_closed_items); if (FAILED(result)) return false; // Update the "Tasks" category of the JumpList. result = UpdateTaskCategory(destination_list, chrome_path.value(), chrome_switches); if (FAILED(result)) return false; // Commit this transaction and send the updated JumpList to Windows. result = destination_list->CommitList(); if (FAILED(result)) return false; return true; } // Represents a task which updates an application JumpList. // This task encapsulates all I/O tasks and OS-specific tasks required for // updating a JumpList from Chromium, such as: // * Deleting the directory containing temporary icon files; // * Creating temporary icon files used by the JumpList; // * Creating an ICustomDestinationList instance; // * Adding items in the ICustomDestinationList instance. // To spawn this task, // 1. Prepare objects required by this task: // * a std::wstring that contains a temporary icons; // * a ShellLinkItemList that contains the items of the "Most Visited" // category, and; // * a ShellLinkItemList that contains the items of the "Recently Closed" // category. // 2. Create a JumpListUpdateTask instance, and; // 3. Post this task to the file thread. class JumpListUpdateTask : public Task { public: JumpListUpdateTask(const wchar_t* app_id, const FilePath& icon_dir, const ShellLinkItemList& most_visited_pages, const ShellLinkItemList& recently_closed_pages) : app_id_(app_id), icon_dir_(icon_dir), most_visited_pages_(most_visited_pages), recently_closed_pages_(recently_closed_pages) { } private: // Represents an entry point of this task. // When we post this task to a file thread, the thread calls this function. void Run(); // App id to associate with the jump list. std::wstring app_id_; // The directory which contains JumpList icons. FilePath icon_dir_; // Items in the "Most Visited" category of the application JumpList. ShellLinkItemList most_visited_pages_; // Items in the "Recently Closed" category of the application JumpList. ShellLinkItemList recently_closed_pages_; }; void JumpListUpdateTask::Run() { // Delete the directory which contains old icon files, rename the current // icon directory, and create a new directory which contains new JumpList // icon files. FilePath icon_dir_old(icon_dir_.value() + L"Old"); if (file_util::PathExists(icon_dir_old)) file_util::Delete(icon_dir_old, true); file_util::Move(icon_dir_, icon_dir_old); file_util::CreateDirectory(icon_dir_); // Create temporary icon files for shortcuts in the "Most Visited" category. for (ShellLinkItemList::const_iterator item = most_visited_pages_.begin(); item != most_visited_pages_.end(); ++item) { SkBitmap icon_bitmap; if ((*item)->data().get() && gfx::PNGCodec::Decode((*item)->data()->front(), (*item)->data()->size(), &icon_bitmap)) { FilePath icon_path; if (CreateIconFile(icon_bitmap, icon_dir_, &icon_path)) (*item)->SetIcon(icon_path.value(), 0, true); } } // Create temporary icon files for shortcuts in the "Recently Closed" // category. for (ShellLinkItemList::const_iterator item = recently_closed_pages_.begin(); item != recently_closed_pages_.end(); ++item) { SkBitmap icon_bitmap; if ((*item)->data().get() && gfx::PNGCodec::Decode((*item)->data()->front(), (*item)->data()->size(), &icon_bitmap)) { FilePath icon_path; if (CreateIconFile(icon_bitmap, icon_dir_, &icon_path)) (*item)->SetIcon(icon_path.value(), 0, true); } } // We finished collecting all resources needed for updating an appliation // JumpList. So, create a new JumpList and replace the current JumpList // with it. UpdateJumpList(app_id_.c_str(), most_visited_pages_, recently_closed_pages_); // Delete all items in these lists now since we don't need the ShellLinkItem // objects in these lists. most_visited_pages_.clear(); recently_closed_pages_.clear(); } } // namespace JumpList::JumpList() : profile_(NULL) { } JumpList::~JumpList() { RemoveObserver(); } // static bool JumpList::Enabled() { return (base::win::GetVersion() >= base::win::VERSION_WIN7 && !CommandLine::ForCurrentProcess()->HasSwitch( switches::kDisableCustomJumpList)); } bool JumpList::AddObserver(Profile* profile) { // To update JumpList when a tab is added or removed, we add this object to // the observer list of the TabRestoreService class. // When we add this object to the observer list, we save the pointer to this // TabRestoreService object. This pointer is used when we remove this object // from the observer list. if (base::win::GetVersion() < base::win::VERSION_WIN7 || !profile) return false; TabRestoreService* tab_restore_service = profile->GetTabRestoreService(); if (!tab_restore_service) return false; app_id_ = ShellIntegration::GetChromiumAppId(profile->GetPath()); icon_dir_ = profile->GetPath().Append(chrome::kJumpListIconDirname); profile_ = profile; tab_restore_service->AddObserver(this); return true; } void JumpList::RemoveObserver() { if (profile_ && profile_->GetTabRestoreService()) profile_->GetTabRestoreService()->RemoveObserver(this); profile_ = NULL; } void JumpList::TabRestoreServiceChanged(TabRestoreService* service) { // Added or removed a tab. // Exit if we are updating the application JumpList. if (!icon_urls_.empty()) return; // Send a query to HistoryService and retrieve the "Most Visited" pages. // This code is copied from MostVisitedHandler::HandleGetMostVisited() to // emulate its behaviors. const int kMostVisitedScope = 90; const int kMostVisitedCount = 9; int result_count = kMostVisitedCount; HistoryService* history_service = profile_->GetHistoryService(Profile::EXPLICIT_ACCESS); history_service->QuerySegmentUsageSince( &most_visited_consumer_, base::Time::Now() - base::TimeDelta::FromDays(kMostVisitedScope), result_count, NewCallback(this, &JumpList::OnSegmentUsageAvailable)); } void JumpList::TabRestoreServiceDestroyed(TabRestoreService* service) { } bool JumpList::AddTab(const TabRestoreService::Tab* tab, ShellLinkItemList* list, size_t max_items) { // This code adds the URL and the title strings of the given tab to the // specified list. // This code is copied from RecentlyClosedTabsHandler::TabToValue(). if (tab->navigations.empty() || list->size() >= max_items) return false; const TabNavigation& current_navigation = tab->navigations.at(tab->current_navigation_index); if (current_navigation.virtual_url() == GURL(chrome::kChromeUINewTabURL)) return false; scoped_refptr<ShellLinkItem> link(new ShellLinkItem); std::string url = current_navigation.virtual_url().spec(); link->SetArguments(UTF8ToWide(url)); link->SetTitle(current_navigation.title()); list->push_back(link); icon_urls_.push_back(make_pair(url, link)); return true; } bool JumpList::AddWindow(const TabRestoreService::Window* window, ShellLinkItemList* list, size_t max_items) { // This code enumerates al the tabs in the given window object and add their // URLs and titles to the list. // This code is copied from RecentlyClosedTabsHandler::WindowToValue(). if (window->tabs.empty()) { NOTREACHED(); return false; } for (size_t i = 0; i < window->tabs.size(); ++i) { if (!AddTab(&window->tabs[i], list, max_items)) return false; } return true; } bool JumpList::StartLoadingFavicon() { if (icon_urls_.empty()) return false; // Ask FaviconService if it has a favicon of a URL. // When FaviconService has one, it will call OnFaviconDataAvailable(). GURL url(icon_urls_.front().first); FaviconService* favicon_service = profile_->GetFaviconService(Profile::EXPLICIT_ACCESS); FaviconService::Handle handle = favicon_service->GetFaviconForURL( url, history::FAVICON, &favicon_consumer_, NewCallback(this, &JumpList::OnFaviconDataAvailable)); return true; } void JumpList::OnSegmentUsageAvailable( CancelableRequestProvider::Handle handle, std::vector<PageUsageData*>* data) { // Create a list of ShellLinkItem objects from the given list of // PageUsageData objects. // The command that opens a web page with chrome is: // "chrome.exe <url-to-the-web-page>". // So, we create a ShellLinkItem object with the following parameters. // * arguments // The URL of a PageUsagedata object (converted to std::wstring). // * title // The title of a PageUsageData object. If this string is empty, we use // the URL as our "Most Visited" page does. // * icon // An empty string. This value is to be updated in OnFaviconDataAvailable(). most_visited_pages_.clear(); for (std::vector<PageUsageData*>::const_iterator page = data->begin(); page != data->end(); ++page) { scoped_refptr<ShellLinkItem> link(new ShellLinkItem); std::string url = (*page)->GetURL().spec(); link->SetArguments(UTF8ToWide(url)); link->SetTitle( !(*page)->GetTitle().empty() ? (*page)->GetTitle() : link->arguments()); most_visited_pages_.push_back(link); icon_urls_.push_back(make_pair(url, link)); } // Create a list of ShellLinkItems from the "Recently Closed" pages. // As noted above, we create a ShellLinkItem objects with the following // parameters. // * arguments // The last URL of the tab object. // * title // The title of the last URL. // * icon // An empty string. This value is to be updated in OnFaviconDataAvailable(). // This code is copied from // RecentlyClosedTabsHandler::TabRestoreServiceChanged() to emulate it. const int kRecentlyClosedCount = 4; recently_closed_pages_.clear(); TabRestoreService* tab_restore_service = profile_->GetTabRestoreService(); const TabRestoreService::Entries& entries = tab_restore_service->entries(); for (TabRestoreService::Entries::const_iterator it = entries.begin(); it != entries.end(); ++it) { const TabRestoreService::Entry* entry = *it; if (entry->type == TabRestoreService::TAB) { AddTab(static_cast<const TabRestoreService::Tab*>(entry), &recently_closed_pages_, kRecentlyClosedCount); } else if (entry->type == TabRestoreService::WINDOW) { AddWindow(static_cast<const TabRestoreService::Window*>(entry), &recently_closed_pages_, kRecentlyClosedCount); } } // Send a query that retrieves the first favicon. StartLoadingFavicon(); } void JumpList::OnFaviconDataAvailable( FaviconService::Handle handle, history::FaviconData favicon) { // Attach the received data to the ShellLinkItem object. // This data will be decoded by JumpListUpdateTask. if (favicon.is_valid()) { if (!icon_urls_.empty() && icon_urls_.front().second) icon_urls_.front().second->SetIconData(favicon.image_data); } // if we need to load more favicons, we send another query and exit. if (!icon_urls_.empty()) icon_urls_.pop_front(); if (StartLoadingFavicon()) return; // Finished loading all favicons needed by the application JumpList. // We create a JumpListUpdateTask that creates icon files, and we post it to // the file thread. BrowserThread::PostTask( BrowserThread::FILE, FROM_HERE, new JumpListUpdateTask(app_id_.c_str(), icon_dir_, most_visited_pages_, recently_closed_pages_)); // Delete all items in these lists since we don't need these lists any longer. most_visited_pages_.clear(); recently_closed_pages_.clear(); }