Download large icon if available when creating secondary tiles on Windows 8.

chrome/browser/ui/metro_pin_tab_helper_win.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/ui/metro_pin_tab_helper_win.h"
 
+#include <set>
+
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/metro.h"
 #include "chrome/browser/favicon/favicon_tab_helper.h"
+#include "chrome/browser/favicon/favicon_util.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_paths.h"
+#include "chrome/common/icon_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 #include "crypto/sha2.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/color_analysis.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(MetroPinTabHelper)
 
@@ skipping 27 matching lines @@
                             const string16& tile_id,
                             const FilePath& logo_dir,
                             FilePath* logo_path) {
   const int kLogoWidth = 120;
   const int kLogoHeight = 120;
   const int kBoxWidth = 40;
   const int kBoxHeight = 40;
   const int kCaptionHeight = 20;
   const double kBoxFade = 0.75;
   const int kColorMeanDarknessLimit = 100;
-  const int kColorMeanLightnessLimit = 100;
+  const int kColorMeanLightnessLimit = 650;
 
   if (image.isNull())
     return false;
 
-  *logo_path = logo_dir.Append(tile_id).ReplaceExtension(L".png");
-
-  // Use a canvas to paint the tile logo.
-  gfx::Canvas canvas(gfx::Size(kLogoWidth, kLogoHeight), ui::SCALE_FACTOR_100P,
-                     true);
+  // First paint the image onto an opaque background to get rid of transparency.
+  // White is used as it will be disregarded in the mean calculation because of
+  // lightness limit.
+  SkPaint paint;
+  paint.setColor(SK_ColorWHITE);
+  gfx::Canvas favicon_canvas(gfx::Size(image.width(), image.height()),
+                             ui::SCALE_FACTOR_100P, true);
+  favicon_canvas.DrawRect(gfx::Rect(0, 0, image.width(), image.height()),
+                          paint);
+  favicon_canvas.DrawImageInt(image, 0, 0);
 
   // Fill the tile logo with the average color from bitmap. To do this we need
   // to work out the 'average color' which is calculated using PNG encoded data
   // of the bitmap.
-  SkPaint paint;
   std::vector<unsigned char> icon_png;
-  if (!gfx::PNGCodec::EncodeBGRASkBitmap(*image.bitmap(), true, &icon_png))
+  if (!gfx::PNGCodec::EncodeBGRASkBitmap(
+          favicon_canvas.ExtractImageRep().sk_bitmap(), false, &icon_png)) {
     return false;
+  }
 
   scoped_refptr<base::RefCountedStaticMemory> icon_mem(
       new base::RefCountedStaticMemory(&icon_png.front(), icon_png.size()));
   color_utils::GridSampler sampler;
   SkColor mean_color = color_utils::CalculateKMeanColorOfPNG(
       icon_mem, kColorMeanDarknessLimit, kColorMeanLightnessLimit, sampler);
   paint.setColor(mean_color);
+  gfx::Canvas canvas(gfx::Size(kLogoWidth, kLogoHeight), ui::SCALE_FACTOR_100P,
+                     true);
   canvas.DrawRect(gfx::Rect(0, 0, kLogoWidth, kLogoHeight), paint);
 
   // Now paint a faded square for the favicon to go in.
   color_utils::HSL shift = {-1, -1, kBoxFade};
   paint.setColor(color_utils::HSLShift(mean_color, shift));
   int box_left = (kLogoWidth - kBoxWidth) / 2;
   int box_top = (kLogoHeight - kCaptionHeight - kBoxHeight) / 2;
   canvas.DrawRect(gfx::Rect(box_left, box_top, kBoxWidth, kBoxHeight), paint);
 
   // Now paint the favicon into the tile, leaving some room at the bottom for
   // the caption.
   int left = (kLogoWidth - image.width()) / 2;
   int top = (kLogoHeight - kCaptionHeight - image.height()) / 2;
   canvas.DrawImageInt(image, left, top);
 
   SkBitmap logo_bitmap = canvas.ExtractImageRep().sk_bitmap();
   std::vector<unsigned char> logo_png;
   if (!gfx::PNGCodec::EncodeBGRASkBitmap(logo_bitmap, true, &logo_png))
     return false;
 
+  *logo_path = logo_dir.Append(tile_id).ReplaceExtension(L".png");
   return file_util::WriteFile(*logo_path,
                               reinterpret_cast<char*>(&logo_png[0]),
                               logo_png.size()) > 0;
 }
 
 // Get the path to the backup logo. If the backup logo already exists in
 // |logo_dir|, it will be used, otherwise it will be copied out of the install
 // folder. (The version in the install folder is not used as it may disappear
 // after an upgrade, causing tiles to lose their images if Windows rebuilds
 // its tile image cache.)
 // The path to the logo is returned in |logo_path|, with the return value
 // indicating success.
 bool GetPathToBackupLogo(const FilePath& logo_dir,
                          FilePath* logo_path) {
   const wchar_t kDefaultLogoFileName[] = L"SecondaryTile.png";
   *logo_path = logo_dir.Append(kDefaultLogoFileName);
   if (file_util::PathExists(*logo_path))
     return true;
 
   FilePath default_logo_path;
   DCHECK(PathService::Get(base::DIR_MODULE, &default_logo_path));
   default_logo_path = default_logo_path.Append(kDefaultLogoFileName);
   return file_util::CopyFile(default_logo_path, *logo_path);
 }
 
 }  // namespace
 
-class MetroPinTabHelper::TaskRunner
-    : public base::RefCountedThreadSafe<TaskRunner> {
+class MetroPinTabHelper::PagePinner

[sky, 2012/10/26 20:01:15]

How come this is ref counted?

[benwells, 2012/10/29 06:38:41]

This class is now split into two. One half is not ref counted as it lives
totally on the UI thread. The other half is ref counted as it is created on the
UI thread and then runs tasks on the FILE thread.

+    : public base::RefCountedThreadSafe<PagePinner> {
  public:
-  TaskRunner() {}
+  PagePinner() {}
 
+  // Updated when we have a new set of candidate favicon URLs for the current
+  // page.
+  void SetFaviconCandidates(const std::vector<FaviconURL>& candidates);
+
+  // This will clear any information we have about the current page's favicon,
+  // and also cancel any pin requests that are still having favicons downloaded.
+  void ClearCurrentPageInfo();

[sky, 2012/10/26 20:01:15]

Why do we need this?

[benwells, 2012/10/29 06:38:41]

This still exists, kind of, but is now in
MetroPinTabHelper::DidNavigateMainFrame. I've added a comment there, hopefully
it is clear (and correct).

+
+  // Start downloading favicons from the candidate URLs, and then proceed on
+  // to create a secondary tile. |history_image| is the favicon we get from
+  // the history service. It is too small so we try to get a bigger one
+  // directly.
+  void StartDownloadingFavicons(content::RenderViewHost* host,
+                                const string16& title,
+                                const string16& url,
+                                const gfx::ImageSkia& history_image);
+
+  // Callback for when a favicon has been downloaded. The best bitmap so far
+  // will be stored in best_candidate_. If this is the last URL that was being

[sky, 2012/10/26 20:01:15]

|s around references to parameters and fields.

[benwells, 2012/10/29 06:38:41]

Done.

+  // downloaded, the page is pinned by calling PinPageToStartScreen on the FILE
+  // thread.
+  void OnDidDownloadFavicon(int id,
+                            const GURL& image_url,
+                            bool errored,
+                            int requested_size,
+                            const std::vector<SkBitmap>& bitmaps);
+
+  // We now have found the best favicon we can, so create the tile. This is
+  // executed on the FILE thread.
   void PinPageToStartScreen(const string16& title,
                             const string16& url,
                             const gfx::ImageSkia& image);
 
  private:
-  ~TaskRunner() {}
+  ~PagePinner() {}
 
-  friend class base::RefCountedThreadSafe<TaskRunner>;
-  DISALLOW_COPY_AND_ASSIGN(TaskRunner);
+  // The best candidate we have so far for the current pin operation.
+  gfx::ImageSkia best_candidate_;
+
+  // Title and URL of the page being pinned.
+  string16 title_;
+  string16 url_;
+
+  // Candidate Favicon URLs for the current page.
+  std::vector<FaviconURL> favicon_url_candidates_;
+
+  // Favicon URLs that are being downloaded. While this is not empty there
+  // is a pin request being processed, if any others are started they will
+  // be ignored.
+  std::set<GURL> in_progress_urls_;
+
+  friend class base::RefCountedThreadSafe<PagePinner>;
+  DISALLOW_COPY_AND_ASSIGN(PagePinner);
 };
 
-void MetroPinTabHelper::TaskRunner::PinPageToStartScreen(
+void MetroPinTabHelper::PagePinner::SetFaviconCandidates(
+    const std::vector<FaviconURL>& candidates) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  favicon_url_candidates_ = candidates;
+}
+
+void MetroPinTabHelper::PagePinner::ClearCurrentPageInfo() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  favicon_url_candidates_.clear();
+  in_progress_urls_.clear();
+}
+
+void MetroPinTabHelper::PagePinner::StartDownloadingFavicons(
+    content::RenderViewHost* host,
+    const string16& title,
+    const string16& url,
+    const gfx::ImageSkia& history_image) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  // If the PagePinner is already pinning the current page, ignore any more
+  // requests.
+  if (!in_progress_urls_.empty())

[sky, 2012/10/26 20:01:15]

Should we create a pinner per url? Seems like it would simplify things in so far
as not having to worry about a new request coming in while processing one.

[benwells, 2012/10/29 06:38:41]

I've separated out the logic into a MetroPinTabHelper::FaviconDownloader class,
which is created as needed. There is still only one active but the
responsibilities are better encapsulated now, with nice clear roles.

+    return;
+
+  // If there are no candidate URLs, progress straight to pinning.
+  if (favicon_url_candidates_.empty()) {
+    content::BrowserThread::PostTask(
+        content::BrowserThread::FILE,
+        FROM_HERE,
+        base::Bind(&PagePinner::PinPageToStartScreen,
+                   this,
+                   title,
+                   url,
+                   history_image));
+    return;
+  }
+
+  best_candidate_ = history_image;
+  title_ = title;
+  url_ = url;
+
+  // Request all the candidates.
+  int image_size = 0; // Request the full sized image.
+  for (std::vector<FaviconURL>::const_iterator iter =
+           favicon_url_candidates_.begin();
+       iter != favicon_url_candidates_.end();
+       ++iter) {
+    // Ignore any duplicate URLs in the candidates.
+    if (in_progress_urls_.find(iter->icon_url) != in_progress_urls_.end())
+      continue;
+
+    in_progress_urls_.insert(iter->icon_url);
+    FaviconUtil::DownloadFavicon(host, iter->icon_url, image_size);

[sky, 2012/10/26 20:01:15]

You need to cache the return value and compare that in the IPC messages you get.

[benwells, 2012/10/29 06:38:41]

Done. Yeah I was checking the URLs when they come back but that's not totally
robust - some other thing might be downloading the same URL but with a different
size.

+  }
+}
+
+void MetroPinTabHelper::PagePinner::OnDidDownloadFavicon(
+    int id,
+    const GURL& image_url,
+    bool errored,
+    int requested_size,
+    const std::vector<SkBitmap>& bitmaps) {
+  const int kMaxIconSize = 32;
+
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  std::set<GURL>::iterator iter = in_progress_urls_.find(image_url);
+  // If this URL isn't in the in progress list, the page must have been
+  // navigated since the request started, cancelling this request.
+  if (iter == in_progress_urls_.end())
+    return;
+
+  in_progress_urls_.erase(iter);
+
+  // Process the bitmaps, keeping the one that is best so far.
+   if (!errored) {
+    for (std::vector<SkBitmap>::const_iterator iter = bitmaps.begin();
+         iter != bitmaps.end();
+         ++iter) {
+
+      // If we don't have a best candidate yet, this is better so just grab it.
+      if (best_candidate_.isNull()) {
+        best_candidate_ = gfx::ImageSkia(*iter).DeepCopy();
+        continue;
+      }
+      // If the new bitmap is bigger than the best candidate, and not greater
+      // than the max size, grab it.
+      if (iter->height() > kMaxIconSize || iter->width() > kMaxIconSize)
+        continue;
+
+      if (iter->height() <= best_candidate_.height() ||
+          iter->width() <= best_candidate_.width()) {
+        continue;
+      }
+
+      best_candidate_ = gfx::ImageSkia(*iter).DeepCopy();
+    }
+   }
+
+  // If there are no more URLs to download, pin the page on the FILE thread.
+  if (in_progress_urls_.empty()) {
+    content::BrowserThread::PostTask(
+        content::BrowserThread::FILE,
+        FROM_HERE,
+        base::Bind(&PagePinner::PinPageToStartScreen,
+                   this,
+                   title_,
+                   url_,
+                   best_candidate_));
+    return;
+  }
+}
+
+void MetroPinTabHelper::PagePinner::PinPageToStartScreen(
     const string16& title,
     const string16& url,
     const gfx::ImageSkia& image) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
 
   string16 tile_id = GenerateTileId(url);
   FilePath logo_dir = GetTileImagesDir();
   if (logo_dir.empty()) {
     LOG(ERROR) << "Could not create directory to store tile image.";
     return;
@@ skipping 21 matching lines @@
   }
 
   VLOG(1) << __FUNCTION__ << " calling pin with title: " << title
           << " and url: " << url;
   metro_pin_to_start_screen(tile_id, title, url, logo_path);
 }
 
 MetroPinTabHelper::MetroPinTabHelper(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       is_pinned_(false),
-      task_runner_(new TaskRunner) {}
+      page_pinner_(new PagePinner) {}
 
 MetroPinTabHelper::~MetroPinTabHelper() {}
 
 void MetroPinTabHelper::TogglePinnedToStartScreen() {
   UpdatePinnedStateForCurrentURL();
   bool was_pinned = is_pinned_;
 
   // TODO(benwells): This will update the state incorrectly if the user
   // cancels. To fix this some sort of callback needs to be introduced as
   // the pinning happens on another thread.
   is_pinned_ = !is_pinned_;
 
   if (was_pinned) {
     UnPinPageFromStartScreen();
     return;
   }
 
-  // TODO(benwells): Handle downloading a larger favicon if there is one.
   GURL url = web_contents()->GetURL();
   string16 url_str = UTF8ToUTF16(url.spec());
   string16 title = web_contents()->GetTitle();
-  TabContents* tab_contents = TabContents::FromWebContents(web_contents());
-  DCHECK(tab_contents);
   FaviconTabHelper* favicon_tab_helper = FaviconTabHelper::FromWebContents(
-      tab_contents->web_contents());
+      web_contents());
   if (favicon_tab_helper->FaviconIsValid()) {
     gfx::Image favicon = favicon_tab_helper->GetFavicon();
     gfx::ImageSkia favicon_skia = favicon.AsImageSkia().DeepCopy();
-    content::BrowserThread::PostTask(
-        content::BrowserThread::FILE,
-        FROM_HERE,
-        base::Bind(&TaskRunner::PinPageToStartScreen,
-                   task_runner_,
-                   title,
-                   url_str,
-                   favicon_skia));
+    page_pinner_->StartDownloadingFavicons(web_contents()->GetRenderViewHost(),
+                                           title,
+                                           url_str,
+                                           favicon_skia);
     return;
   }
 
-  content::BrowserThread::PostTask(
-      content::BrowserThread::FILE,
-      FROM_HERE,
-      base::Bind(&TaskRunner::PinPageToStartScreen,
-                 task_runner_,
-                 title,
-                 url_str,
-                 gfx::ImageSkia()));
+  page_pinner_->StartDownloadingFavicons(web_contents()->GetRenderViewHost(),
+                                         title,
+                                         url_str,
+                                         gfx::ImageSkia());
 }
 
 void MetroPinTabHelper::DidNavigateMainFrame(
     const content::LoadCommittedDetails& /*details*/,
     const content::FrameNavigateParams& /*params*/) {
   UpdatePinnedStateForCurrentURL();
+  page_pinner_->ClearCurrentPageInfo();
+}
+
+bool MetroPinTabHelper::OnMessageReceived(const IPC::Message& message) {
+  bool message_handled = false;   // Allow other handlers to receive these.
+  IPC_BEGIN_MESSAGE_MAP(MetroPinTabHelper, message)
+    IPC_MESSAGE_HANDLER(IconHostMsg_UpdateFaviconURL, OnUpdateFaviconURL)
+    IPC_MESSAGE_HANDLER(IconHostMsg_DidDownloadFavicon, OnDidDownloadFavicon)
+    IPC_MESSAGE_UNHANDLED(message_handled = false)
+  IPC_END_MESSAGE_MAP()
+  return message_handled;
+}
+
+void MetroPinTabHelper::OnUpdateFaviconURL(
+    int32 page_id,
+    const std::vector<FaviconURL>& candidates) {
+  page_pinner_->SetFaviconCandidates(candidates);
+}
+
+void MetroPinTabHelper::OnDidDownloadFavicon(
+    int id,
+    const GURL& image_url,
+    bool errored,
+    int requested_size,
+    const std::vector<SkBitmap>& bitmaps) {
+  page_pinner_->OnDidDownloadFavicon(id, image_url, errored, requested_size,
+                                     bitmaps);
 }
 
 void MetroPinTabHelper::UpdatePinnedStateForCurrentURL() {
   HMODULE metro_module = base::win::GetMetroModule();
   if (!metro_module)
     return;
 
   typedef BOOL (*MetroIsPinnedToStartScreen)(const string16&);
   MetroIsPinnedToStartScreen metro_is_pinned_to_start_screen =
       reinterpret_cast<MetroIsPinnedToStartScreen>(
@@ skipping 23 matching lines @@
     NOTREACHED();
     return;
   }
 
   GURL url = web_contents()->GetURL();
   VLOG(1) << __FUNCTION__ << " calling unpin with url: "
           << UTF8ToUTF16(url.spec());
   string16 tile_id = GenerateTileId(UTF8ToUTF16(url.spec()));
   metro_un_pin_from_start_screen(tile_id);
 }