Renamed FaviconHandlerDelegate to FaviconDriver.

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 223 matching lines @@
     favicon_base::IconType icon_type)
     : url(url),
       image_url(image_url),
       image(image),
       score(score),
       icon_type(icon_type) {}
 
 ////////////////////////////////////////////////////////////////////////////////
 
 FaviconHandler::FaviconHandler(FaviconClient* client,
-                               FaviconHandlerDelegate* delegate,
+                               FaviconDriver* driver,
                                Type icon_type,
                                bool download_largest_icon)
     : got_favicon_from_history_(false),
       favicon_expired_or_incomplete_(false),
       icon_types_(icon_type == FAVICON
                       ? favicon_base::FAVICON
                       : favicon_base::TOUCH_ICON |
                             favicon_base::TOUCH_PRECOMPOSED_ICON),
       download_largest_icon_(download_largest_icon),
       client_(client),
-      delegate_(delegate) {
-  DCHECK(delegate_);
+      driver_(driver) {
+  DCHECK(driver_);
 }
 
 FaviconHandler::~FaviconHandler() {
 }
 
 void FaviconHandler::FetchFavicon(const GURL& url) {
   cancelable_task_tracker_.TryCancelAll();
 
   url_ = url;
 
@@ skipping 221 matching lines @@
                  best_favicon_candidate_.icon_type);
       // Reset candidate.
       image_urls_.clear();
       best_favicon_candidate_ = FaviconCandidate();
     }
   }
   download_requests_.erase(i);
 }
 
 NavigationEntry* FaviconHandler::GetEntry() {
-  NavigationEntry* entry = delegate_->GetActiveEntry();
+  NavigationEntry* entry = driver_->GetActiveEntry();
   if (entry && UrlMatches(entry->GetURL(), url_))
     return entry;
 
   // If the URL has changed out from under us (as will happen with redirects)
   // return NULL.
   return NULL;
 }
 
 int FaviconHandler::DownloadFavicon(const GURL& image_url,
                                     int max_bitmap_size) {
   if (!image_url.is_valid()) {
     NOTREACHED();
     return 0;
   }
-  return delegate_->StartDownload(image_url, max_bitmap_size);
+  return driver_->StartDownload(image_url, max_bitmap_size);
 }
 
 void FaviconHandler::UpdateFaviconMappingAndFetch(
     const GURL& page_url,
     const GURL& icon_url,
     favicon_base::IconType icon_type,
     const FaviconService::FaviconResultsCallback& callback,
     base::CancelableTaskTracker* tracker) {
   // TODO(pkotwicz): pass in all of |image_urls_| to
   // UpdateFaviconMappingsAndFetch().
@@ skipping 26 matching lines @@
 
 void FaviconHandler::SetHistoryFavicons(const GURL& page_url,
                                         const GURL& icon_url,
                                         favicon_base::IconType icon_type,
                                         const gfx::Image& image) {
   client_->GetFaviconService()->SetFavicons(
       page_url, icon_url, icon_type, image);
 }
 
 bool FaviconHandler::ShouldSaveFavicon(const GURL& url) {
-  if (!delegate_->IsOffTheRecord())
+  if (!driver_->IsOffTheRecord())
     return true;
 
   // Otherwise store the favicon if the page is bookmarked.
   return client_->IsBookmarked(url);
 }
 
 void FaviconHandler::NotifyFaviconUpdated(bool icon_url_changed) {
-  delegate_->NotifyFaviconUpdated(icon_url_changed);
+  driver_->NotifyFaviconUpdated(icon_url_changed);
 }
 
 void FaviconHandler::OnFaviconDataForInitialURLFromFaviconService(
     const std::vector<favicon_base::FaviconBitmapResult>&
         favicon_bitmap_results) {
   NavigationEntry* entry = GetEntry();
   if (!entry)
     return;
 
   got_favicon_from_history_ = true;
@@ skipping 47 matching lines @@
     const GURL& page_url,
     const GURL& icon_url,
     favicon_base::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 (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()) {
+    if (driver_->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:
       // 1. Attempts to fetch the favicon data from the database.
       // 2. If the favicon exists in the database, this updates the database to
       //    include the mapping between the page url and the favicon url.
       // This is asynchronous. The history service will call back when done.
@@ skipping 35 matching lines @@
     ScheduleDownload(entry->GetURL(), current_candidate()->icon_url,
                      ToChromeIconType(current_candidate()->icon_type));
   }
   history_results_ = favicon_bitmap_results;
 }
 
 int FaviconHandler::ScheduleDownload(const GURL& url,
                                      const GURL& image_url,
                                      favicon_base::IconType icon_type) {
   // A max bitmap size is specified to avoid receiving huge bitmaps in
-  // OnDidDownloadFavicon(). See FaviconHandlerDelegate::StartDownload()
+  // OnDidDownloadFavicon(). See FaviconDriver::StartDownload()
   // for more details about the max bitmap size.
   const int download_id = DownloadFavicon(image_url,
                                           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);
   }
 
@@ skipping 14 matching lines @@
     } else {
       gfx::Size largest = i->icon_sizes[index];
       i->icon_sizes.clear();
       i->icon_sizes.push_back(largest);
       ++i;
     }
   }
   std::stable_sort(image_urls_.begin(), image_urls_.end(),
                    CompareIconSize);
 }