Home | History | Annotate | Download | only in glue 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/sync/glue/favicon_cache.h"
      6 
      7 #include "base/message_loop/message_loop.h"
      8 #include "base/metrics/histogram.h"
      9 #include "chrome/browser/chrome_notification_types.h"
     10 #include "chrome/browser/favicon/favicon_service.h"
     11 #include "chrome/browser/favicon/favicon_service_factory.h"
     12 #include "chrome/browser/history/history_notifications.h"
     13 #include "chrome/browser/history/history_types.h"
     14 #include "content/public/browser/notification_details.h"
     15 #include "content/public/browser/notification_source.h"
     16 #include "sync/api/time.h"
     17 #include "sync/protocol/favicon_image_specifics.pb.h"
     18 #include "sync/protocol/favicon_tracking_specifics.pb.h"
     19 #include "sync/protocol/sync.pb.h"
     20 #include "ui/gfx/favicon_size.h"
     21 
     22 namespace browser_sync {
     23 
     24 // Synced favicon storage and tracking.
     25 // Note: we don't use the favicon service for storing these because these
     26 // favicons are not necessarily associated with any local navigation, and
     27 // hence would not work with the current expiration logic. We have custom
     28 // expiration logic based on visit time/bookmark status/etc.
     29 // See crbug.com/122890.
     30 struct SyncedFaviconInfo {
     31   explicit SyncedFaviconInfo(const GURL& favicon_url)
     32       : favicon_url(favicon_url),
     33         is_bookmarked(false),
     34         received_local_update(false) {}
     35 
     36   // The actual favicon data.
     37   // TODO(zea): don't keep around the actual data for locally sourced
     38   // favicons (UI can access those directly).
     39   chrome::FaviconBitmapResult bitmap_data[NUM_SIZES];
     40   // The URL this favicon was loaded from.
     41   const GURL favicon_url;
     42   // Is the favicon for a bookmarked page?
     43   bool is_bookmarked;
     44   // The last time a tab needed this favicon.
     45   // Note: Do not modify this directly! It should only be modified via
     46   // UpdateFaviconVisitTime(..).
     47   base::Time last_visit_time;
     48   // Whether we've received a local update for this favicon since starting up.
     49   bool received_local_update;
     50 
     51  private:
     52   DISALLOW_COPY_AND_ASSIGN(SyncedFaviconInfo);
     53 };
     54 
     55 // Information for handling local favicon updates. Used in
     56 // OnFaviconDataAvailable.
     57 struct LocalFaviconUpdateInfo {
     58   LocalFaviconUpdateInfo()
     59       : new_image(false),
     60         new_tracking(false),
     61         image_needs_rewrite(false),
     62         favicon_info(NULL) {}
     63 
     64   bool new_image;
     65   bool new_tracking;
     66   bool image_needs_rewrite;
     67   SyncedFaviconInfo* favicon_info;
     68 };
     69 
     70 namespace {
     71 
     72 // Maximum number of favicons to keep in memory (0 means no limit).
     73 const size_t kMaxFaviconsInMem = 0;
     74 
     75 // Maximum width/height resolution supported.
     76 const int kMaxFaviconResolution = 16;
     77 
     78 // Returns a mask of the supported favicon types.
     79 // TODO(zea): Supporting other favicons types will involve some work in the
     80 // favicon service and navigation controller. See crbug.com/181068.
     81 int SupportedFaviconTypes() {
     82   return chrome::FAVICON;
     83 }
     84 
     85 // Returns the appropriate IconSize to use for a given gfx::Size pixel
     86 // dimensions.
     87 IconSize GetIconSizeBinFromBitmapResult(const gfx::Size& pixel_size) {
     88   int max_size =
     89       (pixel_size.width() > pixel_size.height() ?
     90        pixel_size.width() : pixel_size.height());
     91   // TODO(zea): re-enable 64p and 32p resolutions once we support them.
     92   if (max_size > 64)
     93     return SIZE_INVALID;
     94   else if (max_size > 32)
     95     return SIZE_INVALID;
     96   else if (max_size > 16)
     97     return SIZE_INVALID;
     98   else
     99     return SIZE_16;
    100 }
    101 
    102 // Helper for debug statements.
    103 std::string IconSizeToString(IconSize icon_size) {
    104   switch (icon_size) {
    105     case SIZE_16:
    106       return "16";
    107     case SIZE_32:
    108       return "32";
    109     case SIZE_64:
    110       return "64";
    111     default:
    112       return "INVALID";
    113   }
    114 }
    115 
    116 // Extract the favicon url from either of the favicon types.
    117 GURL GetFaviconURLFromSpecifics(const sync_pb::EntitySpecifics& specifics) {
    118   if (specifics.has_favicon_tracking())
    119     return GURL(specifics.favicon_tracking().favicon_url());
    120   else
    121     return GURL(specifics.favicon_image().favicon_url());
    122 }
    123 
    124 // Convert protobuf image data into a FaviconBitmapResult.
    125 chrome::FaviconBitmapResult GetImageDataFromSpecifics(
    126     const sync_pb::FaviconData& favicon_data) {
    127   base::RefCountedString* temp_string =
    128       new base::RefCountedString();
    129   temp_string->data() = favicon_data.favicon();
    130   chrome::FaviconBitmapResult bitmap_result;
    131   bitmap_result.bitmap_data = temp_string;
    132   bitmap_result.pixel_size.set_height(favicon_data.height());
    133   bitmap_result.pixel_size.set_width(favicon_data.width());
    134   return bitmap_result;
    135 }
    136 
    137 // Convert a FaviconBitmapResult into protobuf image data.
    138 void FillSpecificsWithImageData(
    139     const chrome::FaviconBitmapResult& bitmap_result,
    140     sync_pb::FaviconData* favicon_data) {
    141   if (!bitmap_result.bitmap_data.get())
    142     return;
    143   favicon_data->set_height(bitmap_result.pixel_size.height());
    144   favicon_data->set_width(bitmap_result.pixel_size.width());
    145   favicon_data->set_favicon(bitmap_result.bitmap_data->front(),
    146                             bitmap_result.bitmap_data->size());
    147 }
    148 
    149 // Build a FaviconImageSpecifics from a SyncedFaviconInfo.
    150 void BuildImageSpecifics(
    151     const SyncedFaviconInfo* favicon_info,
    152     sync_pb::FaviconImageSpecifics* image_specifics) {
    153   image_specifics->set_favicon_url(favicon_info->favicon_url.spec());
    154   FillSpecificsWithImageData(favicon_info->bitmap_data[SIZE_16],
    155                              image_specifics->mutable_favicon_web());
    156   // TODO(zea): bring this back if we can handle the load.
    157   // FillSpecificsWithImageData(favicon_info->bitmap_data[SIZE_32],
    158   //                            image_specifics->mutable_favicon_web_32());
    159   // FillSpecificsWithImageData(favicon_info->bitmap_data[SIZE_64],
    160   //                            image_specifics->mutable_favicon_touch_64());
    161 }
    162 
    163 // Build a FaviconTrackingSpecifics from a SyncedFaviconInfo.
    164 void BuildTrackingSpecifics(
    165     const SyncedFaviconInfo* favicon_info,
    166     sync_pb::FaviconTrackingSpecifics* tracking_specifics) {
    167   tracking_specifics->set_favicon_url(favicon_info->favicon_url.spec());
    168   tracking_specifics->set_last_visit_time_ms(
    169       syncer::TimeToProtoTime(favicon_info->last_visit_time));
    170   tracking_specifics->set_is_bookmarked(favicon_info->is_bookmarked);
    171 }
    172 
    173 // Updates |favicon_info| with the image data in |bitmap_result|.
    174 bool UpdateFaviconFromBitmapResult(
    175     const chrome::FaviconBitmapResult& bitmap_result,
    176     SyncedFaviconInfo* favicon_info) {
    177   DCHECK_EQ(favicon_info->favicon_url, bitmap_result.icon_url);
    178   if (!bitmap_result.is_valid()) {
    179     DVLOG(1) << "Received invalid favicon at " << bitmap_result.icon_url.spec();
    180     return false;
    181   }
    182 
    183   IconSize icon_size = GetIconSizeBinFromBitmapResult(
    184       bitmap_result.pixel_size);
    185   if (icon_size == SIZE_INVALID) {
    186     DVLOG(1) << "Ignoring unsupported resolution "
    187              << bitmap_result.pixel_size.height() << "x"
    188              << bitmap_result.pixel_size.width();
    189     return false;
    190   } else if (!favicon_info->bitmap_data[icon_size].bitmap_data.get() ||
    191              !favicon_info->received_local_update) {
    192     DVLOG(1) << "Storing " << IconSizeToString(icon_size) << "p"
    193              << " favicon for " << favicon_info->favicon_url.spec()
    194              << " with size " << bitmap_result.bitmap_data->size()
    195              << " bytes.";
    196     favicon_info->bitmap_data[icon_size] = bitmap_result;
    197     favicon_info->received_local_update = true;
    198     return true;
    199   } else {
    200     // We only allow updating the image data once per restart.
    201     DVLOG(2) << "Ignoring local update for " << bitmap_result.icon_url.spec();
    202     return false;
    203   }
    204 }
    205 
    206 bool FaviconInfoHasImages(const SyncedFaviconInfo& favicon_info) {
    207   return favicon_info.bitmap_data[SIZE_16].bitmap_data.get() ||
    208          favicon_info.bitmap_data[SIZE_32].bitmap_data.get() ||
    209          favicon_info.bitmap_data[SIZE_64].bitmap_data.get();
    210 }
    211 
    212 bool FaviconInfoHasTracking(const SyncedFaviconInfo& favicon_info) {
    213   return !favicon_info.last_visit_time.is_null();
    214 }
    215 
    216 bool FaviconInfoHasValidTypeData(const SyncedFaviconInfo& favicon_info,
    217                              syncer::ModelType type) {
    218   if (type == syncer::FAVICON_IMAGES)
    219     return FaviconInfoHasImages(favicon_info);
    220   else if (type == syncer::FAVICON_TRACKING)
    221     return FaviconInfoHasTracking(favicon_info);
    222   NOTREACHED();
    223   return false;
    224 }
    225 
    226 }  // namespace
    227 
    228 FaviconCache::FaviconCache(Profile* profile, int max_sync_favicon_limit)
    229     : profile_(profile),
    230       max_sync_favicon_limit_(max_sync_favicon_limit),
    231       weak_ptr_factory_(this) {
    232   notification_registrar_.Add(this,
    233                               chrome::NOTIFICATION_HISTORY_URLS_DELETED,
    234                               content::Source<Profile>(profile_));
    235   DVLOG(1) << "Setting favicon limit to " << max_sync_favicon_limit;
    236 }
    237 
    238 FaviconCache::~FaviconCache() {}
    239 
    240 syncer::SyncMergeResult FaviconCache::MergeDataAndStartSyncing(
    241     syncer::ModelType type,
    242     const syncer::SyncDataList& initial_sync_data,
    243     scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
    244     scoped_ptr<syncer::SyncErrorFactory> error_handler) {
    245   DCHECK(type == syncer::FAVICON_IMAGES || type == syncer::FAVICON_TRACKING);
    246   if (type == syncer::FAVICON_IMAGES)
    247     favicon_images_sync_processor_ = sync_processor.Pass();
    248   else
    249     favicon_tracking_sync_processor_ = sync_processor.Pass();
    250 
    251   syncer::SyncMergeResult merge_result(type);
    252   merge_result.set_num_items_before_association(synced_favicons_.size());
    253   std::set<GURL> unsynced_favicon_urls;
    254   for (FaviconMap::const_iterator iter = synced_favicons_.begin();
    255        iter != synced_favicons_.end(); ++iter) {
    256     if (FaviconInfoHasValidTypeData(*(iter->second), type))
    257       unsynced_favicon_urls.insert(iter->first);
    258   }
    259 
    260   syncer::SyncChangeList local_changes;
    261   for (syncer::SyncDataList::const_iterator iter = initial_sync_data.begin();
    262        iter != initial_sync_data.end(); ++iter) {
    263     GURL remote_url = GetFaviconURLFromSpecifics(iter->GetSpecifics());
    264     GURL favicon_url = GetLocalFaviconFromSyncedData(*iter);
    265     if (favicon_url.is_valid()) {
    266       unsynced_favicon_urls.erase(favicon_url);
    267       MergeSyncFavicon(*iter, &local_changes);
    268       merge_result.set_num_items_modified(
    269           merge_result.num_items_modified() + 1);
    270     } else {
    271       AddLocalFaviconFromSyncedData(*iter);
    272       merge_result.set_num_items_added(merge_result.num_items_added() + 1);
    273     }
    274   }
    275 
    276   // Rather than trigger a bunch of deletions when we set up sync, we drop
    277   // local favicons. Those pages that are currently open are likely to result in
    278   // loading new favicons/refreshing old favicons anyways, at which point
    279   // they'll be re-added and the appropriate synced favicons will be evicted.
    280   // TODO(zea): implement a smarter ordering of the which favicons to drop.
    281   int available_favicons = max_sync_favicon_limit_ - initial_sync_data.size();
    282   UMA_HISTOGRAM_BOOLEAN("Sync.FaviconsAvailableAtMerge",
    283                         available_favicons > 0);
    284   for (std::set<GURL>::const_iterator iter = unsynced_favicon_urls.begin();
    285        iter != unsynced_favicon_urls.end(); ++iter) {
    286     if (available_favicons > 0) {
    287       local_changes.push_back(
    288           syncer::SyncChange(FROM_HERE,
    289                              syncer::SyncChange::ACTION_ADD,
    290                              CreateSyncDataFromLocalFavicon(type, *iter)));
    291       available_favicons--;
    292     } else {
    293       FaviconMap::iterator favicon_iter = synced_favicons_.find(*iter);
    294       DVLOG(1) << "Dropping local favicon "
    295                << favicon_iter->second->favicon_url.spec();
    296       DropSyncedFavicon(favicon_iter);
    297       merge_result.set_num_items_deleted(merge_result.num_items_deleted() + 1);
    298     }
    299   }
    300   UMA_HISTOGRAM_COUNTS_10000("Sync.FaviconCount", synced_favicons_.size());
    301   merge_result.set_num_items_after_association(synced_favicons_.size());
    302 
    303   if (type == syncer::FAVICON_IMAGES) {
    304       merge_result.set_error(
    305           favicon_images_sync_processor_->ProcessSyncChanges(FROM_HERE,
    306                                                              local_changes));
    307   } else {
    308       merge_result.set_error(
    309           favicon_tracking_sync_processor_->ProcessSyncChanges(FROM_HERE,
    310                                                                local_changes));
    311   }
    312   return merge_result;
    313 }
    314 
    315 void FaviconCache::StopSyncing(syncer::ModelType type) {
    316   favicon_images_sync_processor_.reset();
    317   favicon_tracking_sync_processor_.reset();
    318   cancelable_task_tracker_.TryCancelAll();
    319   page_task_map_.clear();
    320 }
    321 
    322 syncer::SyncDataList FaviconCache::GetAllSyncData(syncer::ModelType type)
    323     const {
    324   syncer::SyncDataList data_list;
    325   for (FaviconMap::const_iterator iter = synced_favicons_.begin();
    326        iter != synced_favicons_.end(); ++iter) {
    327     data_list.push_back(CreateSyncDataFromLocalFavicon(type, iter->first));
    328   }
    329   return data_list;
    330 }
    331 
    332 syncer::SyncError FaviconCache::ProcessSyncChanges(
    333     const tracked_objects::Location& from_here,
    334     const syncer::SyncChangeList& change_list) {
    335   if (!favicon_images_sync_processor_.get() ||
    336       !favicon_tracking_sync_processor_.get()) {
    337     return syncer::SyncError(FROM_HERE,
    338                              syncer::SyncError::DATATYPE_ERROR,
    339                              "One or both favicon types disabled.",
    340                              change_list[0].sync_data().GetDataType());
    341   }
    342 
    343   syncer::SyncChangeList new_changes;
    344   syncer::SyncError error;
    345   syncer::ModelType type = syncer::UNSPECIFIED;
    346   for (syncer::SyncChangeList::const_iterator iter = change_list.begin();
    347       iter != change_list.end(); ++iter) {
    348     type = iter->sync_data().GetDataType();
    349     DCHECK(type == syncer::FAVICON_IMAGES || type == syncer::FAVICON_TRACKING);
    350     GURL favicon_url =
    351         GetFaviconURLFromSpecifics(iter->sync_data().GetSpecifics());
    352     if (!favicon_url.is_valid()) {
    353       error.Reset(FROM_HERE, "Received invalid favicon url.", type);
    354       break;
    355     }
    356     FaviconMap::iterator favicon_iter = synced_favicons_.find(favicon_url);
    357     if (iter->change_type() == syncer::SyncChange::ACTION_DELETE) {
    358       if (favicon_iter == synced_favicons_.end()) {
    359         // Two clients might wind up deleting different parts of the same
    360         // favicon, so ignore this.
    361         continue;
    362       } else {
    363         DVLOG(1) << "Deleting favicon at " << favicon_url.spec();
    364         // If we only have partial data for the favicon (which implies orphaned
    365         // nodes), delete the local favicon only if the type corresponds to the
    366         // partial data we have. If we do have orphaned nodes, we rely on the
    367         // expiration logic to remove them eventually.
    368         if (type == syncer::FAVICON_IMAGES &&
    369             FaviconInfoHasImages(*(favicon_iter->second)) &&
    370             !FaviconInfoHasTracking(*(favicon_iter->second))) {
    371           DropSyncedFavicon(favicon_iter);
    372         } else if (type == syncer::FAVICON_TRACKING &&
    373                    !FaviconInfoHasImages(*(favicon_iter->second)) &&
    374                    FaviconInfoHasTracking(*(favicon_iter->second))) {
    375           DropSyncedFavicon(favicon_iter);
    376         } else {
    377           // Only delete the data for the modified type.
    378           if (type == syncer::FAVICON_TRACKING) {
    379             recent_favicons_.erase(favicon_iter->second);
    380             favicon_iter->second->last_visit_time = base::Time();
    381             favicon_iter->second->is_bookmarked = false;
    382             recent_favicons_.insert(favicon_iter->second);
    383             DCHECK(!FaviconInfoHasTracking(*(favicon_iter->second)));
    384             DCHECK(FaviconInfoHasImages(*(favicon_iter->second)));
    385           } else {
    386             for (int i = 0; i < NUM_SIZES; ++i) {
    387               favicon_iter->second->bitmap_data[i] =
    388                   chrome::FaviconBitmapResult();
    389             }
    390             DCHECK(FaviconInfoHasTracking(*(favicon_iter->second)));
    391             DCHECK(!FaviconInfoHasImages(*(favicon_iter->second)));
    392           }
    393         }
    394       }
    395     } else if (iter->change_type() == syncer::SyncChange::ACTION_UPDATE ||
    396                iter->change_type() == syncer::SyncChange::ACTION_ADD) {
    397       // Adds and updates are treated the same due to the lack of strong
    398       // consistency (it's possible we'll receive an update for a tracking info
    399       // before we've received the add for the image, and should handle both
    400       // gracefully).
    401       if (favicon_iter == synced_favicons_.end()) {
    402         DVLOG(1) << "Adding favicon at " << favicon_url.spec();
    403         AddLocalFaviconFromSyncedData(iter->sync_data());
    404       } else {
    405         DVLOG(1) << "Updating favicon at " << favicon_url.spec();
    406         MergeSyncFavicon(iter->sync_data(), &new_changes);
    407       }
    408     } else {
    409       error.Reset(FROM_HERE, "Invalid action received.", type);
    410       break;
    411     }
    412   }
    413 
    414   // Note: we deliberately do not expire favicons here. If we received new
    415   // favicons and are now over the limit, the next local favicon change will
    416   // trigger the necessary expiration.
    417   if (!error.IsSet() && !new_changes.empty()) {
    418     if (type == syncer::FAVICON_IMAGES) {
    419         error =
    420             favicon_images_sync_processor_->ProcessSyncChanges(FROM_HERE,
    421                                                                new_changes);
    422     } else {
    423         error =
    424             favicon_tracking_sync_processor_->ProcessSyncChanges(FROM_HERE,
    425                                                                  new_changes);
    426     }
    427   }
    428 
    429   return error;
    430 }
    431 
    432 void FaviconCache::OnPageFaviconUpdated(const GURL& page_url) {
    433   DCHECK(page_url.is_valid());
    434 
    435   // If a favicon load is already happening for this url, let it finish.
    436   if (page_task_map_.find(page_url) != page_task_map_.end())
    437     return;
    438 
    439   PageFaviconMap::const_iterator url_iter = page_favicon_map_.find(page_url);
    440   if (url_iter != page_favicon_map_.end()) {
    441     FaviconMap::const_iterator icon_iter =
    442         synced_favicons_.find(url_iter->second);
    443     // TODO(zea): consider what to do when only a subset of supported
    444     // resolutions are available.
    445     if (icon_iter != synced_favicons_.end() &&
    446         icon_iter->second->bitmap_data[SIZE_16].bitmap_data.get()) {
    447       DVLOG(2) << "Using cached favicon url for " << page_url.spec()
    448                << ": " << icon_iter->second->favicon_url.spec();
    449       UpdateFaviconVisitTime(icon_iter->second->favicon_url, base::Time::Now());
    450       UpdateSyncState(icon_iter->second->favicon_url,
    451                       syncer::SyncChange::ACTION_INVALID,
    452                       syncer::SyncChange::ACTION_UPDATE);
    453       return;
    454     }
    455   }
    456 
    457   DVLOG(1) << "Triggering favicon load for url " << page_url.spec();
    458 
    459   if (!profile_) {
    460     page_task_map_[page_url] = 0;  // For testing only.
    461     return;
    462   }
    463   FaviconService* favicon_service =
    464       FaviconServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS);
    465   if (!favicon_service)
    466     return;
    467   // TODO(zea): This appears to only fetch one favicon (best match based on
    468   // desired_size_in_dip). Figure out a way to fetch all favicons we support.
    469   // See crbug.com/181068.
    470   CancelableTaskTracker::TaskId id = favicon_service->GetFaviconForURL(
    471       FaviconService::FaviconForURLParams(page_url, SupportedFaviconTypes(),
    472                                           kMaxFaviconResolution),
    473       base::Bind(&FaviconCache::OnFaviconDataAvailable,
    474                  weak_ptr_factory_.GetWeakPtr(), page_url),
    475       &cancelable_task_tracker_);
    476   page_task_map_[page_url] = id;
    477 }
    478 
    479 void FaviconCache::OnFaviconVisited(const GURL& page_url,
    480                                     const GURL& favicon_url) {
    481   DCHECK(page_url.is_valid());
    482   if (!favicon_url.is_valid() ||
    483       synced_favicons_.find(favicon_url) == synced_favicons_.end()) {
    484     // TODO(zea): consider triggering a favicon load if we have some but not
    485     // all desired resolutions?
    486     OnPageFaviconUpdated(page_url);
    487     return;
    488   }
    489 
    490   DVLOG(1) << "Associating " << page_url.spec() << " with favicon at "
    491            << favicon_url.spec() << " and marking visited.";
    492   page_favicon_map_[page_url] = favicon_url;
    493   UpdateFaviconVisitTime(favicon_url, base::Time::Now());
    494   UpdateSyncState(favicon_url,
    495                   syncer::SyncChange::ACTION_INVALID,
    496                   (FaviconInfoHasTracking(
    497                        *synced_favicons_.find(favicon_url)->second) ?
    498                    syncer::SyncChange::ACTION_UPDATE :
    499                    syncer::SyncChange::ACTION_ADD));
    500 }
    501 
    502 bool FaviconCache::GetSyncedFaviconForFaviconURL(
    503     const GURL& favicon_url,
    504     scoped_refptr<base::RefCountedMemory>* favicon_png) const {
    505   if (!favicon_url.is_valid())
    506     return false;
    507   FaviconMap::const_iterator iter = synced_favicons_.find(favicon_url);
    508 
    509   UMA_HISTOGRAM_BOOLEAN("Sync.FaviconCacheLookupSucceeded",
    510                         iter != synced_favicons_.end());
    511   if (iter == synced_favicons_.end())
    512     return false;
    513 
    514   // TODO(zea): support getting other resolutions.
    515   if (!iter->second->bitmap_data[SIZE_16].bitmap_data.get())
    516     return false;
    517 
    518   *favicon_png = iter->second->bitmap_data[SIZE_16].bitmap_data;
    519   return true;
    520 }
    521 
    522 bool FaviconCache::GetSyncedFaviconForPageURL(
    523     const GURL& page_url,
    524     scoped_refptr<base::RefCountedMemory>* favicon_png) const {
    525   if (!page_url.is_valid())
    526     return false;
    527   PageFaviconMap::const_iterator iter = page_favicon_map_.find(page_url);
    528 
    529   if (iter == page_favicon_map_.end())
    530     return false;
    531 
    532   return GetSyncedFaviconForFaviconURL(iter->second, favicon_png);
    533 }
    534 
    535 void FaviconCache::OnReceivedSyncFavicon(const GURL& page_url,
    536                                          const GURL& icon_url,
    537                                          const std::string& icon_bytes,
    538                                          int64 visit_time_ms) {
    539   if (!icon_url.is_valid() || !page_url.is_valid() || icon_url.SchemeIs("data"))
    540     return;
    541   DVLOG(1) << "Associating " << page_url.spec() << " with favicon at "
    542            << icon_url.spec();
    543   page_favicon_map_[page_url] = icon_url;
    544 
    545   // If there is no actual image, it means there either is no synced
    546   // favicon, or it's on its way (race condition).
    547   // TODO(zea): potentially trigger a favicon web download here (delayed?).
    548   if (icon_bytes.size() == 0)
    549     return;
    550 
    551   // Post a task to do the actual association because this method may have been
    552   // called while in a transaction.
    553   base::MessageLoop::current()->PostTask(
    554       FROM_HERE,
    555       base::Bind(&FaviconCache::OnReceivedSyncFaviconImpl,
    556                  weak_ptr_factory_.GetWeakPtr(),
    557                  icon_url,
    558                  icon_bytes,
    559                  visit_time_ms));
    560 }
    561 
    562 void FaviconCache::OnReceivedSyncFaviconImpl(
    563     const GURL& icon_url,
    564     const std::string& icon_bytes,
    565     int64 visit_time_ms) {
    566   // If this favicon is already synced, do nothing else.
    567   if (synced_favicons_.find(icon_url) != synced_favicons_.end())
    568     return;
    569 
    570   // Don't add any more favicons once we hit our in memory limit.
    571   // TODO(zea): UMA this.
    572   if (kMaxFaviconsInMem != 0 && synced_favicons_.size() > kMaxFaviconsInMem)
    573     return;
    574 
    575   SyncedFaviconInfo* favicon_info = GetFaviconInfo(icon_url);
    576   if (!favicon_info)
    577     return;  // We reached the in-memory limit.
    578   base::RefCountedString* temp_string = new base::RefCountedString();
    579   temp_string->data() = icon_bytes;
    580   favicon_info->bitmap_data[SIZE_16].bitmap_data = temp_string;
    581   // We assume legacy favicons are 16x16.
    582   favicon_info->bitmap_data[SIZE_16].pixel_size.set_width(16);
    583   favicon_info->bitmap_data[SIZE_16].pixel_size.set_height(16);
    584   bool added_tracking = !FaviconInfoHasTracking(*favicon_info);
    585   UpdateFaviconVisitTime(icon_url,
    586                          syncer::ProtoTimeToTime(visit_time_ms));
    587 
    588   UpdateSyncState(icon_url,
    589                   syncer::SyncChange::ACTION_ADD,
    590                   (added_tracking ?
    591                    syncer::SyncChange::ACTION_ADD :
    592                    syncer::SyncChange::ACTION_UPDATE));
    593 }
    594 
    595 void FaviconCache::Observe(int type,
    596                            const content::NotificationSource& source,
    597                            const content::NotificationDetails& details) {
    598   DCHECK_EQ(type, chrome::NOTIFICATION_HISTORY_URLS_DELETED);
    599 
    600   content::Details<history::URLsDeletedDetails> deleted_details(details);
    601 
    602   // We only care about actual user (or sync) deletions.
    603   if (deleted_details->archived)
    604     return;
    605 
    606   if (!deleted_details->all_history) {
    607     DeleteSyncedFavicons(deleted_details->favicon_urls);
    608     return;
    609   }
    610 
    611   // All history was cleared: just delete all favicons.
    612   DVLOG(1) << "History clear detected, deleting all synced favicons.";
    613   syncer::SyncChangeList image_deletions, tracking_deletions;
    614   while (!synced_favicons_.empty()) {
    615     DeleteSyncedFavicon(synced_favicons_.begin(),
    616                         &image_deletions,
    617                         &tracking_deletions);
    618   }
    619 
    620   if (favicon_images_sync_processor_.get()) {
    621     favicon_images_sync_processor_->ProcessSyncChanges(FROM_HERE,
    622                                                        image_deletions);
    623   }
    624   if (favicon_tracking_sync_processor_.get()) {
    625     favicon_tracking_sync_processor_->ProcessSyncChanges(FROM_HERE,
    626                                                          tracking_deletions);
    627   }
    628 }
    629 
    630 bool FaviconCache::FaviconRecencyFunctor::operator()(
    631     const linked_ptr<SyncedFaviconInfo>& lhs,
    632     const linked_ptr<SyncedFaviconInfo>& rhs) const {
    633   // TODO(zea): incorporate bookmarked status here once we care about it.
    634   if (lhs->last_visit_time < rhs->last_visit_time)
    635     return true;
    636   else if (lhs->last_visit_time == rhs->last_visit_time)
    637     return lhs->favicon_url.spec() < rhs->favicon_url.spec();
    638   return false;
    639 }
    640 
    641 void FaviconCache::OnFaviconDataAvailable(
    642     const GURL& page_url,
    643     const std::vector<chrome::FaviconBitmapResult>& bitmap_results) {
    644   PageTaskMap::iterator page_iter = page_task_map_.find(page_url);
    645   if (page_iter == page_task_map_.end())
    646     return;
    647   page_task_map_.erase(page_iter);
    648 
    649   if (bitmap_results.size() == 0) {
    650     // Either the favicon isn't loaded yet or there is no valid favicon.
    651     // We already cleared the task id, so just return.
    652     DVLOG(1) << "Favicon load failed for page " << page_url.spec();
    653     return;
    654   }
    655 
    656   base::Time now = base::Time::Now();
    657   std::map<GURL, LocalFaviconUpdateInfo> favicon_updates;
    658   for (size_t i = 0; i < bitmap_results.size(); ++i) {
    659     const chrome::FaviconBitmapResult& bitmap_result = bitmap_results[i];
    660     GURL favicon_url = bitmap_result.icon_url;
    661     if (!favicon_url.is_valid() || favicon_url.SchemeIs("data"))
    662       continue;  // Can happen if the page is still loading.
    663 
    664     SyncedFaviconInfo* favicon_info = GetFaviconInfo(favicon_url);
    665     if (!favicon_info)
    666       return;  // We reached the in-memory limit.
    667 
    668     favicon_updates[favicon_url].new_image |=
    669         !FaviconInfoHasImages(*favicon_info);
    670     favicon_updates[favicon_url].new_tracking |=
    671         !FaviconInfoHasTracking(*favicon_info);
    672     favicon_updates[favicon_url].image_needs_rewrite |=
    673         UpdateFaviconFromBitmapResult(bitmap_result, favicon_info);
    674     favicon_updates[favicon_url].favicon_info = favicon_info;
    675   }
    676 
    677   for (std::map<GURL, LocalFaviconUpdateInfo>::const_iterator
    678            iter = favicon_updates.begin(); iter != favicon_updates.end();
    679        ++iter) {
    680     SyncedFaviconInfo* favicon_info = iter->second.favicon_info;
    681     const GURL& favicon_url = favicon_info->favicon_url;
    682 
    683     // TODO(zea): support multiple favicon urls per page.
    684     page_favicon_map_[page_url] = favicon_url;
    685 
    686     if (!favicon_info->last_visit_time.is_null()) {
    687       UMA_HISTOGRAM_COUNTS_10000(
    688           "Sync.FaviconVisitPeriod",
    689           (now - favicon_info->last_visit_time).InHours());
    690     }
    691     favicon_info->received_local_update = true;
    692     UpdateFaviconVisitTime(favicon_url, now);
    693 
    694     syncer::SyncChange::SyncChangeType image_change =
    695         syncer::SyncChange::ACTION_INVALID;
    696     if (iter->second.new_image)
    697       image_change = syncer::SyncChange::ACTION_ADD;
    698     else if (iter->second.image_needs_rewrite)
    699       image_change = syncer::SyncChange::ACTION_UPDATE;
    700     syncer::SyncChange::SyncChangeType tracking_change =
    701         syncer::SyncChange::ACTION_UPDATE;
    702     if (iter->second.new_tracking)
    703       tracking_change = syncer::SyncChange::ACTION_ADD;
    704     UpdateSyncState(favicon_url, image_change, tracking_change);
    705   }
    706 }
    707 
    708 void FaviconCache::UpdateSyncState(
    709     const GURL& icon_url,
    710     syncer::SyncChange::SyncChangeType image_change_type,
    711     syncer::SyncChange::SyncChangeType tracking_change_type) {
    712   DCHECK(icon_url.is_valid());
    713   // It's possible that we'll receive a favicon update before both types
    714   // have finished setting up. In that case ignore the update.
    715   // TODO(zea): consider tracking these skipped updates somehow?
    716   if (!favicon_images_sync_processor_.get() ||
    717       !favicon_tracking_sync_processor_.get()) {
    718     return;
    719   }
    720 
    721   FaviconMap::const_iterator iter = synced_favicons_.find(icon_url);
    722   DCHECK(iter != synced_favicons_.end());
    723   const SyncedFaviconInfo* favicon_info = iter->second.get();
    724 
    725   syncer::SyncChangeList image_changes;
    726   syncer::SyncChangeList tracking_changes;
    727   if (image_change_type != syncer::SyncChange::ACTION_INVALID) {
    728     sync_pb::EntitySpecifics new_specifics;
    729     sync_pb::FaviconImageSpecifics* image_specifics =
    730         new_specifics.mutable_favicon_image();
    731     BuildImageSpecifics(favicon_info, image_specifics);
    732 
    733     image_changes.push_back(
    734         syncer::SyncChange(FROM_HERE,
    735                            image_change_type,
    736                            syncer::SyncData::CreateLocalData(
    737                                icon_url.spec(),
    738                                icon_url.spec(),
    739                                new_specifics)));
    740   }
    741   if (tracking_change_type != syncer::SyncChange::ACTION_INVALID) {
    742     sync_pb::EntitySpecifics new_specifics;
    743     sync_pb::FaviconTrackingSpecifics* tracking_specifics =
    744         new_specifics.mutable_favicon_tracking();
    745     BuildTrackingSpecifics(favicon_info, tracking_specifics);
    746 
    747     tracking_changes.push_back(
    748         syncer::SyncChange(FROM_HERE,
    749                            tracking_change_type,
    750                            syncer::SyncData::CreateLocalData(
    751                                icon_url.spec(),
    752                                icon_url.spec(),
    753                                new_specifics)));
    754   }
    755   ExpireFaviconsIfNecessary(&image_changes, &tracking_changes);
    756   if (!image_changes.empty()) {
    757     favicon_images_sync_processor_->ProcessSyncChanges(FROM_HERE,
    758                                                        image_changes);
    759   }
    760   if (!tracking_changes.empty()) {
    761     favicon_tracking_sync_processor_->ProcessSyncChanges(FROM_HERE,
    762                                                          tracking_changes);
    763   }
    764 }
    765 
    766 SyncedFaviconInfo* FaviconCache::GetFaviconInfo(
    767     const GURL& icon_url) {
    768   DCHECK_EQ(recent_favicons_.size(), synced_favicons_.size());
    769   if (synced_favicons_.count(icon_url) != 0)
    770     return synced_favicons_[icon_url].get();
    771 
    772   // TODO(zea): implement in-memory eviction.
    773   DVLOG(1) << "Adding favicon info for " << icon_url.spec();
    774   SyncedFaviconInfo* favicon_info = new SyncedFaviconInfo(icon_url);
    775   synced_favicons_[icon_url] = make_linked_ptr(favicon_info);
    776   recent_favicons_.insert(synced_favicons_[icon_url]);
    777   DCHECK_EQ(recent_favicons_.size(), synced_favicons_.size());
    778   return favicon_info;
    779 }
    780 
    781 void FaviconCache::UpdateFaviconVisitTime(const GURL& icon_url,
    782                                           base::Time time) {
    783   DCHECK_EQ(recent_favicons_.size(), synced_favicons_.size());
    784   FaviconMap::const_iterator iter = synced_favicons_.find(icon_url);
    785   DCHECK(iter != synced_favicons_.end());
    786   if (iter->second->last_visit_time >= time)
    787     return;
    788   // Erase, update the time, then re-insert to maintain ordering.
    789   recent_favicons_.erase(iter->second);
    790   DVLOG(1) << "Updating " << icon_url.spec() << " visit time to "
    791            << syncer::GetTimeDebugString(time);
    792   iter->second->last_visit_time = time;
    793   recent_favicons_.insert(iter->second);
    794 
    795   if (VLOG_IS_ON(2)) {
    796     for (RecencySet::const_iterator iter = recent_favicons_.begin();
    797          iter != recent_favicons_.end(); ++iter) {
    798       DVLOG(2) << "Favicon " << iter->get()->favicon_url.spec() << ": "
    799                << syncer::GetTimeDebugString(iter->get()->last_visit_time);
    800     }
    801   }
    802   DCHECK_EQ(recent_favicons_.size(), synced_favicons_.size());
    803 }
    804 
    805 void FaviconCache::ExpireFaviconsIfNecessary(
    806     syncer::SyncChangeList* image_changes,
    807     syncer::SyncChangeList* tracking_changes) {
    808   DCHECK_EQ(recent_favicons_.size(), synced_favicons_.size());
    809   // TODO(zea): once we have in-memory eviction, we'll need to track sync
    810   // favicon count separately from the synced_favicons_/recent_favicons_.
    811 
    812   // Iterate until we've removed the necessary amount. |recent_favicons_| is
    813   // already in recency order, so just start from the beginning.
    814   // TODO(zea): to reduce thrashing, consider removing more than the minimum.
    815   while (recent_favicons_.size() > max_sync_favicon_limit_) {
    816     linked_ptr<SyncedFaviconInfo> candidate = *recent_favicons_.begin();
    817     DVLOG(1) << "Expiring favicon " << candidate->favicon_url.spec();
    818     DeleteSyncedFavicon(synced_favicons_.find(candidate->favicon_url),
    819                         image_changes,
    820                         tracking_changes);
    821   }
    822   DCHECK_EQ(recent_favicons_.size(), synced_favicons_.size());
    823 }
    824 
    825 GURL FaviconCache::GetLocalFaviconFromSyncedData(
    826     const syncer::SyncData& sync_favicon) const {
    827   syncer::ModelType type = sync_favicon.GetDataType();
    828   DCHECK(type == syncer::FAVICON_IMAGES || type == syncer::FAVICON_TRACKING);
    829   GURL favicon_url = GetFaviconURLFromSpecifics(sync_favicon.GetSpecifics());
    830   return (synced_favicons_.count(favicon_url) > 0 ? favicon_url : GURL());
    831 }
    832 
    833 void FaviconCache::MergeSyncFavicon(const syncer::SyncData& sync_favicon,
    834                                     syncer::SyncChangeList* sync_changes) {
    835   syncer::ModelType type = sync_favicon.GetDataType();
    836   DCHECK(type == syncer::FAVICON_IMAGES || type == syncer::FAVICON_TRACKING);
    837   sync_pb::EntitySpecifics new_specifics;
    838   GURL favicon_url = GetFaviconURLFromSpecifics(sync_favicon.GetSpecifics());
    839   FaviconMap::const_iterator iter = synced_favicons_.find(favicon_url);
    840   DCHECK(iter != synced_favicons_.end());
    841   SyncedFaviconInfo* favicon_info = iter->second.get();
    842   if (type == syncer::FAVICON_IMAGES) {
    843     sync_pb::FaviconImageSpecifics image_specifics =
    844         sync_favicon.GetSpecifics().favicon_image();
    845 
    846     // Remote image data always clobbers local image data.
    847     bool needs_update = false;
    848     if (image_specifics.has_favicon_web()) {
    849       favicon_info->bitmap_data[SIZE_16] = GetImageDataFromSpecifics(
    850           image_specifics.favicon_web());
    851     } else if (favicon_info->bitmap_data[SIZE_16].bitmap_data.get()) {
    852       needs_update = true;
    853     }
    854     if (image_specifics.has_favicon_web_32()) {
    855       favicon_info->bitmap_data[SIZE_32] = GetImageDataFromSpecifics(
    856           image_specifics.favicon_web_32());
    857     } else if (favicon_info->bitmap_data[SIZE_32].bitmap_data.get()) {
    858       needs_update = true;
    859     }
    860     if (image_specifics.has_favicon_touch_64()) {
    861       favicon_info->bitmap_data[SIZE_64] = GetImageDataFromSpecifics(
    862           image_specifics.favicon_touch_64());
    863     } else if (favicon_info->bitmap_data[SIZE_64].bitmap_data.get()) {
    864       needs_update = true;
    865     }
    866 
    867     if (needs_update)
    868       BuildImageSpecifics(favicon_info, new_specifics.mutable_favicon_image());
    869   } else {
    870     sync_pb::FaviconTrackingSpecifics tracking_specifics =
    871         sync_favicon.GetSpecifics().favicon_tracking();
    872 
    873     // Tracking data is merged, such that bookmark data is the logical OR
    874     // of the two, and last visit time is the most recent.
    875 
    876     base::Time last_visit =  syncer::ProtoTimeToTime(
    877         tracking_specifics.last_visit_time_ms());
    878     // Due to crbug.com/258196, there are tracking nodes out there with
    879     // null visit times. If this is one of those, artificially make it a valid
    880     // visit time, so we know the node exists and update it properly on the next
    881     // real visit.
    882     if (last_visit.is_null())
    883       last_visit = last_visit + base::TimeDelta::FromMilliseconds(1);
    884     UpdateFaviconVisitTime(favicon_url, last_visit);
    885     favicon_info->is_bookmarked = (favicon_info->is_bookmarked ||
    886                                    tracking_specifics.is_bookmarked());
    887 
    888     if (syncer::TimeToProtoTime(favicon_info->last_visit_time) !=
    889             tracking_specifics.last_visit_time_ms() ||
    890         favicon_info->is_bookmarked != tracking_specifics.is_bookmarked()) {
    891       BuildTrackingSpecifics(favicon_info,
    892                              new_specifics.mutable_favicon_tracking());
    893     }
    894     DCHECK(!favicon_info->last_visit_time.is_null());
    895   }
    896 
    897   if (new_specifics.has_favicon_image() ||
    898       new_specifics.has_favicon_tracking()) {
    899     sync_changes->push_back(syncer::SyncChange(
    900         FROM_HERE,
    901         syncer::SyncChange::ACTION_UPDATE,
    902         syncer::SyncData::CreateLocalData(favicon_url.spec(),
    903                                           favicon_url.spec(),
    904                                           new_specifics)));
    905   }
    906 }
    907 
    908 void FaviconCache::AddLocalFaviconFromSyncedData(
    909     const syncer::SyncData& sync_favicon) {
    910   syncer::ModelType type = sync_favicon.GetDataType();
    911   DCHECK(type == syncer::FAVICON_IMAGES || type == syncer::FAVICON_TRACKING);
    912   if (type == syncer::FAVICON_IMAGES) {
    913     sync_pb::FaviconImageSpecifics image_specifics =
    914         sync_favicon.GetSpecifics().favicon_image();
    915     GURL favicon_url = GURL(image_specifics.favicon_url());
    916     DCHECK(favicon_url.is_valid());
    917     DCHECK(!synced_favicons_.count(favicon_url));
    918 
    919     SyncedFaviconInfo* favicon_info = GetFaviconInfo(favicon_url);
    920     if (!favicon_info)
    921       return;  // We reached the in-memory limit.
    922     if (image_specifics.has_favicon_web()) {
    923       favicon_info->bitmap_data[SIZE_16] = GetImageDataFromSpecifics(
    924           image_specifics.favicon_web());
    925     }
    926     if (image_specifics.has_favicon_web_32()) {
    927       favicon_info->bitmap_data[SIZE_32] = GetImageDataFromSpecifics(
    928           image_specifics.favicon_web_32());
    929     }
    930     if (image_specifics.has_favicon_touch_64()) {
    931       favicon_info->bitmap_data[SIZE_64] = GetImageDataFromSpecifics(
    932           image_specifics.favicon_touch_64());
    933     }
    934   } else {
    935     sync_pb::FaviconTrackingSpecifics tracking_specifics =
    936         sync_favicon.GetSpecifics().favicon_tracking();
    937     GURL favicon_url = GURL(tracking_specifics.favicon_url());
    938     DCHECK(favicon_url.is_valid());
    939     DCHECK(!synced_favicons_.count(favicon_url));
    940 
    941     SyncedFaviconInfo* favicon_info = GetFaviconInfo(favicon_url);
    942     if (!favicon_info)
    943       return;  // We reached the in-memory limit.
    944     base::Time last_visit =  syncer::ProtoTimeToTime(
    945         tracking_specifics.last_visit_time_ms());
    946     // Due to crbug.com/258196, there are tracking nodes out there with
    947     // null visit times. If this is one of those, artificially make it a valid
    948     // visit time, so we know the node exists and update it properly on the next
    949     // real visit.
    950     if (last_visit.is_null())
    951       last_visit = last_visit + base::TimeDelta::FromMilliseconds(1);
    952     UpdateFaviconVisitTime(favicon_url, last_visit);
    953     favicon_info->is_bookmarked = tracking_specifics.is_bookmarked();
    954     DCHECK(!favicon_info->last_visit_time.is_null());
    955   }
    956 }
    957 
    958 syncer::SyncData FaviconCache::CreateSyncDataFromLocalFavicon(
    959     syncer::ModelType type,
    960     const GURL& favicon_url) const {
    961   DCHECK(type == syncer::FAVICON_IMAGES || type == syncer::FAVICON_TRACKING);
    962   DCHECK(favicon_url.is_valid());
    963   FaviconMap::const_iterator iter = synced_favicons_.find(favicon_url);
    964   DCHECK(iter != synced_favicons_.end());
    965   SyncedFaviconInfo* favicon_info = iter->second.get();
    966 
    967   syncer::SyncData data;
    968   sync_pb::EntitySpecifics specifics;
    969   if (type == syncer::FAVICON_IMAGES) {
    970     sync_pb::FaviconImageSpecifics* image_specifics =
    971         specifics.mutable_favicon_image();
    972     BuildImageSpecifics(favicon_info, image_specifics);
    973   } else {
    974     sync_pb::FaviconTrackingSpecifics* tracking_specifics =
    975         specifics.mutable_favicon_tracking();
    976     BuildTrackingSpecifics(favicon_info, tracking_specifics);
    977   }
    978   data = syncer::SyncData::CreateLocalData(favicon_url.spec(),
    979                                            favicon_url.spec(),
    980                                            specifics);
    981   return data;
    982 }
    983 
    984 void FaviconCache::DeleteSyncedFavicons(const std::set<GURL>& favicon_urls) {
    985   syncer::SyncChangeList image_deletions, tracking_deletions;
    986   for (std::set<GURL>::const_iterator iter = favicon_urls.begin();
    987        iter != favicon_urls.end(); ++iter) {
    988     FaviconMap::iterator favicon_iter = synced_favicons_.find(*iter);
    989     if (favicon_iter == synced_favicons_.end())
    990       continue;
    991     DeleteSyncedFavicon(favicon_iter,
    992                         &image_deletions,
    993                         &tracking_deletions);
    994   }
    995   DVLOG(1) << "Deleting " << image_deletions.size() << " synced favicons.";
    996   if (favicon_images_sync_processor_.get()) {
    997     favicon_images_sync_processor_->ProcessSyncChanges(FROM_HERE,
    998                                                        image_deletions);
    999   }
   1000   if (favicon_tracking_sync_processor_.get()) {
   1001     favicon_tracking_sync_processor_->ProcessSyncChanges(FROM_HERE,
   1002                                                          tracking_deletions);
   1003   }
   1004 }
   1005 
   1006 void FaviconCache::DeleteSyncedFavicon(
   1007     FaviconMap::iterator favicon_iter,
   1008     syncer::SyncChangeList* image_changes,
   1009     syncer::SyncChangeList* tracking_changes) {
   1010   linked_ptr<SyncedFaviconInfo> favicon_info = favicon_iter->second;
   1011   if (FaviconInfoHasImages(*(favicon_iter->second))) {
   1012     image_changes->push_back(
   1013         syncer::SyncChange(FROM_HERE,
   1014                            syncer::SyncChange::ACTION_DELETE,
   1015                            syncer::SyncData::CreateLocalDelete(
   1016                                favicon_info->favicon_url.spec(),
   1017                                syncer::FAVICON_IMAGES)));
   1018   }
   1019   if (FaviconInfoHasTracking(*(favicon_iter->second))) {
   1020     tracking_changes->push_back(
   1021         syncer::SyncChange(FROM_HERE,
   1022                            syncer::SyncChange::ACTION_DELETE,
   1023                            syncer::SyncData::CreateLocalDelete(
   1024                                favicon_info->favicon_url.spec(),
   1025                                syncer::FAVICON_TRACKING)));
   1026   }
   1027   DropSyncedFavicon(favicon_iter);
   1028 }
   1029 
   1030 void FaviconCache::DropSyncedFavicon(FaviconMap::iterator favicon_iter) {
   1031   recent_favicons_.erase(favicon_iter->second);
   1032   synced_favicons_.erase(favicon_iter);
   1033 }
   1034 
   1035 size_t FaviconCache::NumFaviconsForTest() const {
   1036   return synced_favicons_.size();
   1037 }
   1038 
   1039 size_t FaviconCache::NumTasksForTest() const {
   1040   return page_task_map_.size();
   1041 }
   1042 
   1043 }  // namespace browser_sync
   1044