• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #ifndef CHROME_BROWSER_JUMPLIST_WIN_H_
6 #define CHROME_BROWSER_JUMPLIST_WIN_H_
7 #pragma once
8 
9 #include <list>
10 #include <string>
11 #include <utility>
12 #include <vector>
13 
14 #include "base/memory/ref_counted.h"
15 #include "chrome/browser/history/history.h"
16 #include "chrome/browser/sessions/tab_restore_service.h"
17 #include "chrome/browser/sessions/tab_restore_service_observer.h"
18 #include "content/browser/cancelable_request.h"
19 
20 class FilePath;
21 class Profile;
22 class PageUsageData;
23 
24 // Represents a class used for creating an IShellLink object by the utility
25 // functions in this file.
26 // This class consists of three strings and a integer.
27 // * arguments (std::wstring)
28 //   The arguments for the application.
29 // * title (std::wstring)
30 //   The string to be displayed in a JumpList.
31 // * icon (std::wstring)
32 //   The absolute path to an icon to be displayed in a JumpList.
33 // * index (int)
34 //   The icon index in the icon file. If an icon file consists of two or more
35 //   icons, set this value to identify the icon. If an icon file consists of
36 // one icon, this value is 0.
37 // Even though an IShellLink also needs the absolute path to an application to
38 // be executed, this class does not have any variables for it because our
39 // utility functions always use "chrome.exe" as the application and we don't
40 // need it.
41 class ShellLinkItem : public base::RefCountedThreadSafe<ShellLinkItem> {
42  public:
ShellLinkItem()43   ShellLinkItem() : index_(0), favicon_(false) {
44   }
45 
arguments()46   const std::wstring& arguments() const { return arguments_; }
title()47   const std::wstring& title() const { return title_; }
icon()48   const std::wstring& icon() const { return icon_; }
index()49   int index() const { return index_; }
data()50   scoped_refptr<RefCountedMemory> data() const { return data_; }
51 
SetArguments(const std::wstring & arguments)52   void SetArguments(const std::wstring& arguments) {
53     arguments_ = arguments;
54   }
55 
SetTitle(const std::wstring & title)56   void SetTitle(const std::wstring& title) {
57     title_ = title;
58   }
59 
SetIcon(const std::wstring & icon,int index,bool favicon)60   void SetIcon(const std::wstring& icon, int index, bool favicon) {
61     icon_ = icon;
62     index_ = index;
63     favicon_ = favicon;
64   }
65 
SetIconData(scoped_refptr<RefCountedMemory> data)66   void SetIconData(scoped_refptr<RefCountedMemory> data) {
67     data_ = data;
68   }
69 
70  private:
71   friend class base::RefCountedThreadSafe<ShellLinkItem>;
72 
~ShellLinkItem()73   ~ShellLinkItem() {}
74 
75   std::wstring arguments_;
76   std::wstring title_;
77   std::wstring icon_;
78   scoped_refptr<RefCountedMemory> data_;
79   int index_;
80   bool favicon_;
81 
82   DISALLOW_COPY_AND_ASSIGN(ShellLinkItem);
83 };
84 
85 typedef std::vector<scoped_refptr<ShellLinkItem> > ShellLinkItemList;
86 
87 // A class which implements an application JumpList.
88 // This class encapsulates operations required for updating an application
89 // JumpList:
90 // * Retrieving "Most Visited" pages from HistoryService;
91 // * Retrieving strings from the application resource;
92 // * Creatng COM objects used by JumpList from PageUsageData objects;
93 // * Adding COM objects to JumpList, etc.
94 //
95 // This class also implements TabRestoreServiceObserver. So, once we call
96 // AddObserver() and register this class as an observer, it automatically
97 // updates a JumpList when a tab is added or removed.
98 //
99 // Updating a JumpList requires some file operations and it is not good to
100 // update it in a UI thread. To solve this problem, this class posts a
101 // task when it actually updates a JumpList. (This task is implemented in an
102 // anomynous namespace in "jumplist_win.cc".)
103 class JumpList : public TabRestoreServiceObserver {
104  public:
105   JumpList();
106   ~JumpList();
107 
108   // Registers (or unregisters) this object as an observer.
109   // When the TabRestoreService object notifies the tab status is changed, this
110   // class automatically updates an application JumpList.
111   bool AddObserver(Profile* profile);
112   void RemoveObserver();
113 
114   // Observer callback for TabRestoreService::Observer to notify when a tab is
115   // added or removed.
116   // This function sends a query that retrieves "Most Visited" pages to
117   // HistoryService. When the query finishes successfully, HistoryService call
118   // OnSegmentUsageAvailable().
119   virtual void TabRestoreServiceChanged(TabRestoreService* service);
120 
121   // Observer callback to notice when our associated TabRestoreService
122   // is destroyed.
123   virtual void TabRestoreServiceDestroyed(TabRestoreService* service);
124 
125   // Returns true if the custom JumpList is enabled.
126   // We use the custom JumpList when we satisfy the following conditions:
127   // * Chromium is running on Windows 7 and;
128   // * Chromium is lauched without a "--disable-custom-jumplist" option.
129   // TODO(hbono): to be enabled by default when we finalize the categories and
130   // items of our JumpList.
131   static bool Enabled();
132 
133  protected:
134   // Creates a ShellLinkItem object from a tab (or a window) and add it to the
135   // given list.
136   // These functions are copied from the RecentlyClosedTabsHandler class for
137   // compatibility with the new-tab page.
138   bool AddTab(const TabRestoreService::Tab* tab,
139               ShellLinkItemList* list,
140               size_t max_items);
141   bool AddWindow(const TabRestoreService::Window* window,
142                  ShellLinkItemList* list,
143                  size_t max_items);
144 
145   // Starts loading a favicon for each URL in |icon_urls_|.
146   // This function just sends a query to HistoryService.
147   bool StartLoadingFavicon();
148 
149   // A callback function for HistoryService that notify when the "Most Visited"
150   // list is available.
151   // This function updates the ShellLinkItemList objects and send another query
152   // that retrieves a favicon for each URL in the list.
153   void OnSegmentUsageAvailable(CancelableRequestProvider::Handle handle,
154                                std::vector<PageUsageData*>* data);
155 
156   // A callback function for HistoryService that notify when a requested favicon
157   // is available.
158   // To avoid file operations, this function just attaches the given data to
159   // a ShellLinkItem object.
160   // When finishing loading all favicons, this function posts a task that
161   // decompresses collected favicons and updates a JumpList.
162   void OnFaviconDataAvailable(HistoryService::Handle handle,
163                               history::FaviconData favicon);
164 
165  private:
166   // Our consumers for HistoryService.
167   CancelableRequestConsumer most_visited_consumer_;
168   CancelableRequestConsumer favicon_consumer_;
169 
170   // The Profile object used for listening its events.
171   Profile* profile_;
172 
173   // App id to associate with the jump list.
174   std::wstring app_id_;
175 
176   // The directory which contains JumpList icons.
177   FilePath icon_dir_;
178 
179   // Items in the "Most Visited" category of the application JumpList.
180   ShellLinkItemList most_visited_pages_;
181 
182   // Items in the "Recently Closed" category of the application JumpList.
183   ShellLinkItemList recently_closed_pages_;
184 
185   // A list of URLs we need to retrieve their favicons.
186   typedef std::pair<std::string, scoped_refptr<ShellLinkItem> > URLPair;
187   std::list<URLPair> icon_urls_;
188 };
189 
190 #endif  // CHROME_BROWSER_JUMPLIST_WIN_H_
191