Adds support for saving favicon size into history database.

chrome/browser/favicon/favicon_service.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/favicon/favicon_service.h"
 
 #include "chrome/browser/favicon/select_favicon_frames.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/history/history_backend.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/ui/webui/chrome_web_ui_controller_factory.h"
 #include "chrome/common/url_constants.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/png_codec.h"
+#include "ui/gfx/favicon_size.h"
 #include "ui/gfx/image/image_skia.h"
 
 FaviconService::FaviconService(HistoryService* history_service)
     : history_service_(history_service) {
 }
 
 FaviconService::Handle FaviconService::GetFaviconImage(
     const GURL& icon_url,
     history::IconType icon_type,
     int desired_size_in_dip,
     CancelableRequestConsumerBase* consumer,
     const FaviconImageCallback& callback) {
   GetFaviconRequest* request = new GetFaviconRequest(base::Bind(
       &FaviconService::GetFaviconImageCallback,
       base::Unretained(this),
       desired_size_in_dip,
       callback));
   AddRequest(request, consumer);
-  // TODO(pkotwicz): Pass in desired size and scale factors.
-  if (history_service_)
-    history_service_->GetFavicon(request, icon_url, icon_type);
-  else
+  if (history_service_) {
+    std::vector<GURL> icon_urls;
+    icon_urls.push_back(icon_url);
+    history_service_->GetFavicons(request, icon_urls, icon_type,
+        desired_size_in_dip, ui::GetSupportedScaleFactors());
+  } else {
     ForwardEmptyResultAsync(request);
+  }
   return request->handle();
 }
 
 FaviconService::Handle FaviconService::GetRawFavicon(
     const GURL& icon_url,
     history::IconType icon_type,
     int desired_size_in_dip,
     ui::ScaleFactor desired_scale_factor,
     CancelableRequestConsumerBase* consumer,
     const FaviconRawCallback& callback) {
   GetFaviconRequest* request = new GetFaviconRequest(base::Bind(
       &FaviconService::GetRawFaviconCallback,
       base::Unretained(this),
       desired_size_in_dip,
       desired_scale_factor,
       callback));
   AddRequest(request, consumer);
-  // TODO(pkotwicz): Pass in desired size and scale factor.
-  if (history_service_)
-    history_service_->GetFavicon(request, icon_url, icon_type);
-  else
+  if (history_service_) {
+    std::vector<GURL> icon_urls;
+    icon_urls.push_back(icon_url);
+    std::vector<ui::ScaleFactor> desired_scale_factors;
+    desired_scale_factors.push_back(desired_scale_factor);
+    history_service_->GetFavicons(request, icon_urls, icon_type,
+        desired_size_in_dip, desired_scale_factors);
+  } else {
     ForwardEmptyResultAsync(request);
+  }
   return request->handle();
 }
 
 FaviconService::Handle FaviconService::GetFavicon(
     const GURL& icon_url,
     history::IconType icon_type,
     int desired_size_in_dip,
     const std::vector<ui::ScaleFactor>& desired_scale_factors,
     CancelableRequestConsumerBase* consumer,
     const FaviconResultsCallback& callback) {
   GetFaviconRequest* request = new GetFaviconRequest(callback);
   AddRequest(request, consumer);
-  if (history_service_)
-    history_service_->GetFavicon(request, icon_url, icon_type);
-  else
+  if (history_service_) {
+    std::vector<GURL> icon_urls;
+    icon_urls.push_back(icon_url);
+    history_service_->GetFavicons(request, icon_urls, icon_type,
+        desired_size_in_dip, desired_scale_factors);
+  } else {
     ForwardEmptyResultAsync(request);
+  }
   return request->handle();
 }
 
 FaviconService::Handle FaviconService::UpdateFaviconMappingAndFetch(
     const GURL& page_url,
     const GURL& icon_url,
     history::IconType icon_type,
     CancelableRequestConsumerBase* consumer,
     const FaviconResultsCallback& callback) {
   GetFaviconRequest* request = new GetFaviconRequest(callback);
   AddRequest(request, consumer);
-  if (history_service_)
-    history_service_->UpdateFaviconMappingAndFetch(request, page_url,
-                                                   icon_url, icon_type);
-  else
+  if (history_service_) {
+    std::vector<GURL> icon_urls;
+    icon_urls.push_back(icon_url);
+    // TODO(pkotwicz): Pass in |desired_size_in_dip| and |desired_scale_factors|
+    // from FaviconHandler.
+    history_service_->UpdateFaviconMappingsAndFetch(request, page_url,
+        icon_urls, icon_type, gfx::kFaviconSize, ui::GetSupportedScaleFactors());
+  } else {
     ForwardEmptyResultAsync(request);
+  }
   return request->handle();
 }
 
 FaviconService::Handle FaviconService::GetFaviconImageForURL(
     Profile* profile,
     const GURL& page_url,
     int icon_types,
     int desired_size_in_dip,
     CancelableRequestConsumerBase* consumer,
     const FaviconImageCallback& callback) {
@@ skipping 51 matching lines @@
     const FaviconRawCallback& callback) {
   GetFaviconRequest* request = new GetFaviconRequest(base::Bind(
       &FaviconService::GetRawFaviconCallback,
       base::Unretained(this),
       desired_size_in_dip,
       desired_scale_factor,
       callback));
 
   AddRequest(request, consumer);
   FaviconService::Handle handle = request->handle();
-  // TODO(pkotwicz): Pass in desired size and scale factor.
-  if (history_service_)
-    history_service_->GetFaviconForID(request, favicon_id);
-  else
+  if (history_service_) {
+    history_service_->GetFaviconForID(request, favicon_id, desired_size_in_dip,
+                                      desired_scale_factor);
+  } else {
     ForwardEmptyResultAsync(request);
-
+  }
   return handle;
 }
 
 
 void FaviconService::SetFaviconOutOfDateForPage(const GURL& page_url) {
   if (history_service_)
-    history_service_->SetFaviconOutOfDateForPage(page_url);
+    history_service_->SetFaviconsOutOfDateForPage(page_url);
 }
 
 void FaviconService::CloneFavicon(const GURL& old_page_url,
                                   const GURL& new_page_url) {
   if (history_service_)
-    history_service_->CloneFavicon(old_page_url, new_page_url);
+    history_service_->CloneFavicons(old_page_url, new_page_url);
 }
 
 void FaviconService::SetImportedFavicons(
     const std::vector<history::ImportedFaviconUsage>& favicon_usage) {
   if (history_service_)
     history_service_->SetImportedFavicons(favicon_usage);
 }
 
 void FaviconService::SetFavicon(const GURL& page_url,
                                 const GURL& icon_url,
                                 const std::vector<unsigned char>& image_data,
                                 history::IconType icon_type) {
-  if (history_service_)
-    history_service_->SetFavicon(page_url, icon_url, image_data, icon_type);
+  if (history_service_) {
+    // TODO(pkotwicz): Pass in real pixel size to SetFavicons.

[michaelbai, 2012/09/04 21:18:53]

Not sure what did you mean pass in real pixel size?

Will you add 'pixel_size' parameter? If so, will this method requires the client
parse the images before set the favicon?

[pkotwicz, 2012/09/04 22:40:54]

I am unsure as to whether the client should parse the images before calling
SetFavicons.
Practically it does so today.
Realistically, we may use the HTML5 sizes parameter if it is available, and
otherwise create a mock list of pixel sizes based on the bitmap data which was
downloaded.

+    history::FaviconBitmapData bitmap_data_element;
+    bitmap_data_element.bitmap_data = scoped_refptr<base::RefCountedMemory>(
+        new base::RefCountedBytes(image_data));
+    bitmap_data_element.pixel_size = gfx::Size();
+    bitmap_data_element.icon_url = icon_url;
+    std::vector<history::FaviconBitmapData> favicon_bitmap_data;
+    favicon_bitmap_data.push_back(bitmap_data_element);
+    history::IconURLSizesMap icon_url_sizes;
+    icon_url_sizes[icon_url] = history::GetDefaultFaviconSizes();
+    history_service_->SetFavicons(page_url, icon_type,
+        favicon_bitmap_data, icon_url_sizes);
+  }
 }
 
 FaviconService::~FaviconService() {
 }
 
 FaviconService::Handle FaviconService::GetFaviconForURLImpl(
     Profile* profile,
     const GURL& page_url,
     int icon_types,
     int desired_size_in_dip,
     const std::vector<ui::ScaleFactor>& desired_scale_factors,
     CancelableRequestConsumerBase* consumer,
     GetFaviconRequest* request) {
   AddRequest(request, consumer);
   FaviconService::Handle handle = request->handle();
   if (page_url.SchemeIs(chrome::kChromeUIScheme) ||
       page_url.SchemeIs(chrome::kExtensionScheme)) {
     // TODO(pkotwicz): Pass in desired size and desired scale factors.
     ChromeWebUIControllerFactory::GetInstance()->GetFaviconForURL(
         profile, request, page_url);
   } else {
-    // TODO(pkotwicz): Pass in desired size and desired scale factors.
-    if (history_service_)
-      history_service_->GetFaviconForURL(request, page_url, icon_types);
-    else
+    if (history_service_) {
+      history_service_->GetFaviconsForURL(request, page_url, icon_types,
+          desired_size_in_dip, desired_scale_factors);
+    } else {
       ForwardEmptyResultAsync(request);
+    }
   }
   return handle;
 }
 
 void FaviconService::GetFaviconImageCallback(
     int desired_size_in_dip,
     FaviconImageCallback callback,
     Handle handle,
     std::vector<history::FaviconBitmapResult> favicon_bitmap_results,
     history::IconURLSizesMap icon_url_sizes_map) {
@@ skipping 71 matching lines @@
   bitmap_result.bitmap_data = base::RefCountedBytes::TakeVector(
       &resized_bitmap_data);
   callback.Run(handle, bitmap_result);
 }
 
 void FaviconService::ForwardEmptyResultAsync(GetFaviconRequest* request) {
   request->ForwardResultAsync(request->handle(),
                               std::vector<history::FaviconBitmapResult>(),
                               history::IconURLSizesMap());
 }