Jumplist Bug

chrome/browser/jumplist_win.h

 // 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.
 
 #ifndef CHROME_BROWSER_JUMPLIST_WIN_H_
 #define CHROME_BROWSER_JUMPLIST_WIN_H_
 #pragma once
 
 #include <list>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
+#include "base/synchronization/lock.h"
 #include "chrome/browser/history/history.h"
+#include "chrome/browser/history/history_types.h"
 #include "chrome/browser/sessions/tab_restore_service.h"
 #include "chrome/browser/sessions/tab_restore_service_observer.h"
 #include "content/browser/cancelable_request.h"
 
 class FilePath;
 class Profile;
 class PageUsageData;
 
 // Represents a class used for creating an IShellLink object by the utility
 // functions in this file.
@@ skipping 64 matching lines @@
 // * Retrieving "Most Visited" pages from HistoryService;
 // * Retrieving strings from the application resource;
 // * Creatng COM objects used by JumpList from PageUsageData objects;
 // * Adding COM objects to JumpList, etc.
 //
 // This class also implements TabRestoreServiceObserver. So, once we call
 // AddObserver() and register this class as an observer, it automatically
 // updates a JumpList when a tab is added or removed.
 //
 // Updating a JumpList requires some file operations and it is not good to
-// update it in a UI thread. To solve this problem, this class posts a
-// task when it actually updates a JumpList. (This task is implemented in an
-// anomynous namespace in "jumplist_win.cc".)
-class JumpList : public TabRestoreServiceObserver {
+// update it in a UI thread. To solve this problem, this class posts to a
+// runnable method when it actually updates a JumpList.
+class JumpList : public TabRestoreServiceObserver,
+                 public NotificationObserver,
+                 public base::RefCountedThreadSafe<JumpList> {
  public:
   JumpList();
-  ~JumpList();
+
+  // NotificationObserver implementation.
+  virtual void Observe(int type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details);
 
   // Registers (or unregisters) this object as an observer.
   // When the TabRestoreService object notifies the tab status is changed, this
   // class automatically updates an application JumpList.
   bool AddObserver(Profile* profile);
   void RemoveObserver();
 
   // Observer callback for TabRestoreService::Observer to notify when a tab is
   // added or removed.
   // This function sends a query that retrieves "Most Visited" pages to
   // HistoryService. When the query finishes successfully, HistoryService call
   // OnSegmentUsageAvailable().
   virtual void TabRestoreServiceChanged(TabRestoreService* service);
 
   // Observer callback to notice when our associated TabRestoreService
   // is destroyed.
   virtual void TabRestoreServiceDestroyed(TabRestoreService* service);
 
+  // Cancel a pending jumplist update.
+  void CancelPendingUpdate();
+
+  // Terminate the jumplist: cancel any pending updates and remove observer
+  // from TabRestoreService. This must be called before the profile provided
+  // in the AddObserver method is destroyed.
+  void Terminate();
+
   // Returns true if the custom JumpList is enabled.
   // We use the custom JumpList when we satisfy the following conditions:
   // * Chromium is running on Windows 7 and;
   // * Chromium is lauched without a "--disable-custom-jumplist" option.
   // TODO(hbono): to be enabled by default when we finalize the categories and
   // items of our JumpList.
   static bool Enabled();
 
  protected:
   // Creates a ShellLinkItem object from a tab (or a window) and add it to the
@@ skipping 20 matching lines @@
 
   // A callback function for HistoryService that notify when a requested favicon
   // is available.
   // To avoid file operations, this function just attaches the given data to
   // a ShellLinkItem object.
   // When finishing loading all favicons, this function posts a task that
   // decompresses collected favicons and updates a JumpList.
   void OnFaviconDataAvailable(HistoryService::Handle handle,
                               history::FaviconData favicon);
 
+  // Callback for TopSites that notifies when the "Most
+  // Visited" list is available. This function updates the ShellLinkItemList
+  // objects and send another query that retrieves a favicon for each URL in
+  // the list.
+  void OnMostVisitedURLsAvailable(
+      const history::MostVisitedURLList& data);
+
+  // Runnable method that updates the jumplist, once all the data
+  // has been fetched.
+  void RunUpdate();
+
+  // Helper method for RunUpdate to decode the data about the asynchrounously
+  // loaded icons.
+  void DecodeIconData(const ShellLinkItemList& item_list);
+
  private:
+  friend class base::RefCountedThreadSafe<JumpList>;
+  ~JumpList();
+
   // Our consumers for HistoryService.
   CancelableRequestConsumer most_visited_consumer_;
   CancelableRequestConsumer favicon_consumer_;
+  CancelableRequestConsumer topsites_consumer_;
 
-  // The Profile object used for listening its events.
+  // The Profile object is used to listen for events
   Profile* profile_;
 
+  NotificationRegistrar registrar_;
+
   // 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.
+  // Items in the "Most Visited" category of the application JumpList,
+  // protected by the list_lock_.
   ShellLinkItemList most_visited_pages_;
 
-  // Items in the "Recently Closed" category of the application JumpList.
+  // Items in the "Recently Closed" category of the application JumpList,
+  // protected by the list_lock_.
   ShellLinkItemList recently_closed_pages_;
 
-  // A list of URLs we need to retrieve their favicons.
+  // A list of URLs we need to retrieve their favicons,
+  // protected by the list_lock_.
   typedef std::pair<std::string, scoped_refptr<ShellLinkItem> > URLPair;
   std::list<URLPair> icon_urls_;
+
+  // Handle of last favicon request used to cancel if a new request
+  // comes in before the current one returns.
+  FaviconService::Handle handle_;
+
+  // Lock for most_visited_pages_, recently_closed_pages_, icon_urls_
+  // as they may be used by up to 3 threads.
+  base::Lock list_lock_;
 };
 
 #endif  // CHROME_BROWSER_JUMPLIST_WIN_H_