Moves knowledge of Profile out of FaviconHandler, into FaviconTabHelper.

chrome/browser/favicon/favicon_handler.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_handler.h"
 
 #include "build/build_config.h"
 
 #include <algorithm>
 #include <vector>
@@ skipping 192 matching lines @@
     : url(url),
       image_url(image_url),
       image(image),
       score(score),
       icon_type(icon_type) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 FaviconHandler::FaviconHandler(Profile* profile,
+                               FaviconClient* client,
                                FaviconHandlerDelegate* delegate,
                                Type icon_type)
     : got_favicon_from_history_(false),
       favicon_expired_or_incomplete_(false),
-      icon_types_(icon_type == FAVICON ? chrome::FAVICON :
-          chrome::TOUCH_ICON | chrome::TOUCH_PRECOMPOSED_ICON),
+      icon_types_(icon_type == FAVICON
+                      ? chrome::FAVICON
+                      : chrome::TOUCH_ICON | chrome::TOUCH_PRECOMPOSED_ICON),
       profile_(profile),
+      client_(client),
       delegate_(delegate) {
   DCHECK(profile_);
   DCHECK(delegate_);
 }
 
 FaviconHandler::~FaviconHandler() {
 }
 
 void FaviconHandler::FetchFavicon(const GURL& url) {
   cancelable_task_tracker_.TryCancelAll();
 
   url_ = url;
 
   favicon_expired_or_incomplete_ = got_favicon_from_history_ = false;
   image_urls_.clear();
 
   // Request the favicon from the history service. In parallel to this the
   // renderer is going to notify us (well WebContents) when the favicon url is
   // available.
-  if (GetFaviconService()) {
+  if (client_->GetFaviconService()) {
     GetFaviconForURLFromFaviconService(
         url_,
         icon_types_,
         base::Bind(
             &FaviconHandler::OnFaviconDataForInitialURLFromFaviconService,
             base::Unretained(this)),
         &cancelable_task_tracker_);
   }
 }
 
-FaviconService* FaviconHandler::GetFaviconService() {
-  return FaviconServiceFactory::GetForProfile(
-      profile_, Profile::EXPLICIT_ACCESS);
-}
-
 bool FaviconHandler::UpdateFaviconCandidate(const GURL& url,
                                             const GURL& image_url,
                                             const gfx::Image& image,
                                             float score,
                                             chrome::IconType icon_type) {
   const bool exact_match = score == 1 || preferred_icon_size() == 0;
   if (exact_match ||
       best_favicon_candidate_.icon_type == chrome::INVALID_ICON ||
       score > best_favicon_candidate_.score) {
     best_favicon_candidate_ = FaviconCandidate(
         url, image_url, image, score, icon_type);
   }
   return exact_match;
 }
 
 void FaviconHandler::SetFavicon(
     const GURL& url,
     const GURL& icon_url,
     const gfx::Image& image,
     chrome::IconType icon_type) {
-  if (GetFaviconService() && ShouldSaveFavicon(url))
+  if (client_->GetFaviconService() && ShouldSaveFavicon(url))
     SetHistoryFavicons(url, icon_url, icon_type, image);
 
   if (UrlMatches(url, url_) && icon_type == chrome::FAVICON) {
     NavigationEntry* entry = GetEntry();
     if (entry)
       SetFaviconOnNavigationEntry(entry, icon_url, image);
   }
 }
 
 void FaviconHandler::SetFaviconOnNavigationEntry(
@@ skipping 39 matching lines @@
        i != candidates.end(); ++i) {
     if (!i->icon_url.is_empty() && (i->icon_type & icon_types_))
       image_urls_.push_back(*i);
   }
 
   // TODO(davemoore) Should clear on empty url. Currently we ignore it.
   // This appears to be what FF does as well.
   if (image_urls_.empty())
     return;
 
-  if (!GetFaviconService())
+  if (!client_->GetFaviconService())
     return;
 
   ProcessCurrentUrl();
 }
 
 void FaviconHandler::ProcessCurrentUrl() {
   DCHECK(!image_urls_.empty());
 
   NavigationEntry* entry = GetEntry();
   if (!entry)
@@ skipping 86 matching lines @@
 void FaviconHandler::UpdateFaviconMappingAndFetch(
     const GURL& page_url,
     const GURL& icon_url,
     chrome::IconType icon_type,
     const FaviconService::FaviconResultsCallback& callback,
     base::CancelableTaskTracker* tracker) {
   // TODO(pkotwicz): pass in all of |image_urls_| to
   // UpdateFaviconMappingsAndFetch().
   std::vector<GURL> icon_urls;
   icon_urls.push_back(icon_url);
-  GetFaviconService()->UpdateFaviconMappingsAndFetch(
+  client_->GetFaviconService()->UpdateFaviconMappingsAndFetch(
       page_url, icon_urls, icon_type, preferred_icon_size(), callback, tracker);
 }
 
 void FaviconHandler::GetFaviconFromFaviconService(
     const GURL& icon_url,
     chrome::IconType icon_type,
     const FaviconService::FaviconResultsCallback& callback,
     base::CancelableTaskTracker* tracker) {
-  GetFaviconService()->GetFavicon(
+  client_->GetFaviconService()->GetFavicon(
       icon_url, icon_type, preferred_icon_size(), callback, tracker);
 }
 
 void FaviconHandler::GetFaviconForURLFromFaviconService(
     const GURL& page_url,
     int icon_types,
     const FaviconService::FaviconResultsCallback& callback,
     base::CancelableTaskTracker* tracker) {
-  GetFaviconService()->GetFaviconForURL(
-      FaviconService::FaviconForURLParams(page_url, icon_types,
-                                          preferred_icon_size()),
+  client_->GetFaviconService()->GetFaviconForURL(
+      FaviconService::FaviconForURLParams(
+          page_url, icon_types, preferred_icon_size()),
       callback,
       tracker);
 }
 
 void FaviconHandler::SetHistoryFavicons(const GURL& page_url,
                                         const GURL& icon_url,
                                         chrome::IconType icon_type,
                                         const gfx::Image& image) {
-  GetFaviconService()->SetFavicons(page_url, icon_url, icon_type, image);
+  client_->GetFaviconService()->SetFavicons(
+      page_url, icon_url, icon_type, image);
 }
 
 bool FaviconHandler::ShouldSaveFavicon(const GURL& url) {
   if (!delegate_->IsOffTheRecord())
     return true;
 
   // Otherwise store the favicon if the page is bookmarked.
   BookmarkService* bookmark_service =
       BookmarkService::FromBrowserContext(profile_);
   return bookmark_service && bookmark_service->IsBookmarked(url);
@@ skipping 56 matching lines @@
   // renderer to download the icon.
 }
 
 void FaviconHandler::DownloadFaviconOrAskFaviconService(
     const GURL& page_url,
     const GURL& icon_url,
     chrome::IconType icon_type) {
   if (favicon_expired_or_incomplete_) {
     // We have the mapping, but the favicon is out of date. Download it now.
     ScheduleDownload(page_url, icon_url, icon_type);
-  } else if (GetFaviconService()) {
+  } else if (client_->GetFaviconService()) {
     // We don't know the favicon, but we may have previously downloaded the
     // favicon for another page that shares the same favicon. Ask for the
     // favicon given the favicon URL.
     if (delegate_->IsOffTheRecord()) {
       GetFaviconFromFaviconService(
           icon_url, icon_type,
           base::Bind(&FaviconHandler::OnFaviconData, base::Unretained(this)),
           &cancelable_task_tracker_);
     } else {
       // Ask the history service for the icon. This does two things:
@@ skipping 53 matching lines @@
                                           GetMaximalIconSize(icon_type));
   if (download_id) {
     // Download ids should be unique.
     DCHECK(download_requests_.find(download_id) == download_requests_.end());
     download_requests_[download_id] =
         DownloadRequest(url, image_url, icon_type);
   }
 
   return download_id;
 }