Adds support for saving favicon size into history database.

chrome/browser/history/history.h

 // 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.
 
 #ifndef CHROME_BROWSER_HISTORY_HISTORY_H_
 #define CHROME_BROWSER_HISTORY_HISTORY_H_
 
 #include <set>
 #include <vector>
 
@@ skipping 671 matching lines @@
 
   // Favicon -------------------------------------------------------------------
 
   // These favicon methods are exposed to the FaviconService. Instead of calling
   // these methods directly you should call the respective method on the
   // FaviconService.
 
   // Used by the FaviconService to get a favicon from the history backend.
   void GetFavicon(FaviconService::GetFaviconRequest* request,
                   const GURL& icon_url,
+                  const gfx::Size& pixel_size,
                   history::IconType icon_type);
 
   // Used by the FaviconService to update the favicon mappings on the history
   // backend.
   void UpdateFaviconMappingAndFetch(FaviconService::GetFaviconRequest* request,
                                     const GURL& page_url,
                                     const GURL& icon_url,
+                                    const gfx::Size& pixel_size,
                                     history::IconType icon_type);
 
   // Used by the FaviconService to get a favicon from the history backend.
   void GetFaviconForURL(FaviconService::GetFaviconRequest* request,
                         const GURL& page_url,
+                        const gfx::Size& pixel_size,
                         int icon_types);
 
   // Used by the FaviconService to get a favicon from the history backend.
   void GetFaviconForID(FaviconService::GetFaviconRequest* request,
                        history::FaviconID id);
 
   // Used by the FaviconService to mark the favicon for the page as being out
   // of date.
   void SetFaviconOutOfDateForPage(const GURL& page_url);
 
   // Used by the FaviconService to clone favicons from one page to another,
   // provided that other page does not already have favicons.
   void CloneFavicon(const GURL& old_page_url, const GURL& new_page_url);
 
   // Used by the FaviconService for importing many favicons for many pages at
   // once. The pages must exist, any favicon sets for unknown pages will be
   // discarded. Existing favicons will not be overwritten.
   void SetImportedFavicons(
       const std::vector<history::ImportedFaviconUsage>& favicon_usage);
 
   // Used by the FaviconService to set the favicon for a page on the history
   // backend.
+  // |requested size| is the size which was used to search for |image_data|
+  // for which |image_data| is the best match from |page_url|'s favicons.
+  // This does not necessarily correspond to the favicon's pixel size.
+  // For instance, if the ideal favicon size is 16x16 but the best match is
+  // a 10x16 favicon, |requested_size| is 16x16.
+  // TODO(pkotwicz): Add a parameter for the favicon's pixel size.
   void SetFavicon(const GURL& page_url,
                   const GURL& icon_url,
                   const std::vector<unsigned char>& image_data,
+                  const gfx::Size& requested_size,
                   history::IconType icon_type);
 
-
   // Sets the in-memory URL database. This is called by the backend once the
   // database is loaded to make it available.
   void SetInMemoryBackend(int backend_id,
                           history::InMemoryHistoryBackend* mem_backend);
 
   // Called by our BackendDelegate when there is a problem reading the database.
   void NotifyProfileError(int backend_id, sql::InitStatus init_status);
 
   // Call to schedule a given task for running on the history thread with the
   // specified priority. The task will have ownership taken.
@@ skipping 96 matching lines @@
     LoadBackendIfNecessary();
     if (consumer)
       AddRequest(request, consumer);
     ScheduleTask(priority,
                  base::Bind(func, history_backend_.get(),
                                    scoped_refptr<RequestType>(request),
                                    a, b, c, d));
     return request->handle();
   }
 
+  template<typename BackendFunc,
+           class RequestType,  // Descendant of CancelableRequstBase.
+           typename ArgA,
+           typename ArgB,
+           typename ArgC,
+           typename ArgD,
+           typename ArgE>
+  Handle Schedule(SchedulePriority priority,
+                  BackendFunc func,  // Function to call on the HistoryBackend.
+                  CancelableRequestConsumerBase* consumer,
+                  RequestType* request,
+                  const ArgA& a,
+                  const ArgB& b,
+                  const ArgC& c,
+                  const ArgD& d,
+                  const ArgE& e) {
+    DCHECK(thread_) << "History service being called after cleanup";
+    LoadBackendIfNecessary();
+    if (consumer)
+      AddRequest(request, consumer);
+    ScheduleTask(priority,
+                 base::Bind(func, history_backend_.get(),
+                                   scoped_refptr<RequestType>(request),
+                                   a, b, c, d, e));
+    return request->handle();
+  }
+
   // ScheduleAndForget ---------------------------------------------------------
   //
   // Functions for scheduling operations on the history thread that do not need
   // any callbacks and are not cancelable.
 
   template<typename BackendFunc>
   void ScheduleAndForget(SchedulePriority priority,
                          BackendFunc func) {  // Function to call on backend.
     DCHECK(thread_) << "History service being called after cleanup";
     LoadBackendIfNecessary();
@@ skipping 40 matching lines @@
                          const ArgA& a,
                          const ArgB& b,
                          const ArgC& c,
                          const ArgD& d) {
     DCHECK(thread_) << "History service being called after cleanup";
     LoadBackendIfNecessary();
     ScheduleTask(priority, base::Bind(func, history_backend_.get(),
                                       a, b, c, d));
   }
 
+  template<typename BackendFunc,
+           typename ArgA,
+           typename ArgB,
+           typename ArgC,
+           typename ArgD,
+           typename ArgE>
+  void ScheduleAndForget(SchedulePriority priority,
+                         BackendFunc func,  // Function to call on backend.
+                         const ArgA& a,
+                         const ArgB& b,
+                         const ArgC& c,
+                         const ArgD& d,
+                         const ArgE& e) {
+    DCHECK(thread_) << "History service being called after cleanup";
+    LoadBackendIfNecessary();
+    ScheduleTask(priority, base::Bind(func, history_backend_.get(),
+                                      a, b, c, d, e));
+  }
+
   content::NotificationRegistrar registrar_;
 
   // Some void primitives require some internal processing in the main thread
   // when done. We use this internal consumer for this purpose.
   CancelableRequestConsumer internal_consumer_;
 
   // The thread used by the history service to run complicated operations.
   // |thread_| is NULL once |Cleanup| is NULL.
   base::Thread* thread_;
 
@@ skipping 32 matching lines @@
   // The index used for quick history lookups.
   scoped_ptr<history::InMemoryURLIndex> in_memory_url_index_;
 
   scoped_refptr<ObserverListThreadSafe<history::VisitDatabaseObserver> >
       visit_database_observers_;
 
   DISALLOW_COPY_AND_ASSIGN(HistoryService);
 };
 
 #endif  // CHROME_BROWSER_HISTORY_HISTORY_H_