Refactor favicon to use C++11 loop and fix style violation

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 <algorithm>
 #include <cmath>
 #include <vector>
 
@@ skipping 29 matching lines @@
 // identical and if they match the icon URL and icon type in |favicon_url|.
 // Returns false if |bitmap_results| is empty.
 bool DoUrlsAndIconsMatch(
     const FaviconURL& favicon_url,
     const std::vector<favicon_base::FaviconRawBitmapResult>& bitmap_results) {
   if (bitmap_results.empty())
     return false;
 
   const favicon_base::IconType icon_type = favicon_url.icon_type;
 
-  for (size_t i = 0; i < bitmap_results.size(); ++i) {
-    if (favicon_url.icon_url != bitmap_results[i].icon_url ||
-        icon_type != bitmap_results[i].icon_type) {
+  for (const auto& bitmap_result : bitmap_results) {
+    if (favicon_url.icon_url != bitmap_result.icon_url ||
+        icon_type != bitmap_result.icon_type) {
       return false;
     }
   }
   return true;
 }
 
 std::string UrlWithoutFragment(const GURL& gurl) {
   GURL::Replacements replacements;
   replacements.ClearRef();
   return gurl.ReplaceComponents(replacements).spec();
@@ skipping 30 matching lines @@
     return false;
 
   // Check if the favicon for at least one of the scale factors is missing.
   // |bitmap_results| should always be complete for data inserted by
   // FaviconHandler as the FaviconHandler stores favicons resized to all
   // of favicon_base::GetFaviconScales() into the history backend.
   // Examples of when |bitmap_results| can be incomplete:
   // - Favicons inserted into the history backend by sync.
   // - Favicons for imported bookmarks.
   std::vector<gfx::Size> favicon_sizes;
-  for (size_t i = 0; i < bitmap_results.size(); ++i)
-    favicon_sizes.push_back(bitmap_results[i].pixel_size);
+  for (const auto& bitmap_result : bitmap_results)
+    favicon_sizes.push_back(bitmap_result.pixel_size);
 
   std::vector<float> favicon_scales = favicon_base::GetFaviconScales();
-  for (size_t i = 0; i < favicon_scales.size(); ++i) {
-    int edge_size_in_pixel = std::ceil(desired_size_in_dip * favicon_scales[i]);
-    std::vector<gfx::Size>::iterator it = std::find(favicon_sizes.begin(),
-        favicon_sizes.end(), gfx::Size(edge_size_in_pixel, edge_size_in_pixel));
+  for (float favicon_scale : favicon_scales) {
+    int edge_size_in_pixel = std::ceil(desired_size_in_dip * favicon_scale);
+    auto it = std::find(favicon_sizes.begin(), favicon_sizes.end(),
+                        gfx::Size(edge_size_in_pixel, edge_size_in_pixel));
     if (it == favicon_sizes.end())
       return true;
   }
   return false;
 }
 
 // Returns true if at least one of |bitmap_results| is valid.
 bool HasValidResult(
     const std::vector<favicon_base::FaviconRawBitmapResult>& bitmap_results) {
   return std::find_if(bitmap_results.begin(), bitmap_results.end(), IsValid) !=
@@ skipping 35 matching lines @@
     area2 = b2.icon_sizes.front().GetArea();
 
   return area1 > area2;
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 
 FaviconHandler::DownloadRequest::DownloadRequest()
-    : icon_type(favicon_base::INVALID_ICON) {}
+    : icon_type(favicon_base::INVALID_ICON) {
+}
 
 FaviconHandler::DownloadRequest::~DownloadRequest() {
 }
 
 FaviconHandler::DownloadRequest::DownloadRequest(
     const GURL& url,
     const GURL& image_url,
     favicon_base::IconType icon_type)
-    : url(url), image_url(image_url), icon_type(icon_type) {}
+    : url(url), image_url(image_url), icon_type(icon_type) {
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 
 FaviconHandler::FaviconCandidate::FaviconCandidate()
-    : score(0), icon_type(favicon_base::INVALID_ICON) {}
+    : score(0), icon_type(favicon_base::INVALID_ICON) {
+}
 
 FaviconHandler::FaviconCandidate::~FaviconCandidate() {
 }
 
 FaviconHandler::FaviconCandidate::FaviconCandidate(
     const GURL& url,
     const GURL& image_url,
     const gfx::Image& image,
     float score,
     favicon_base::IconType icon_type)
@@ skipping 126 matching lines @@
   favicon_base::SetFaviconColorSpace(&image_with_adjusted_colorspace);
 
   driver_->OnFaviconAvailable(
       image_with_adjusted_colorspace, icon_url, is_active_favicon);
 }
 
 void FaviconHandler::OnUpdateFaviconURL(
     const std::vector<FaviconURL>& candidates) {
   image_urls_.clear();
   best_favicon_candidate_ = FaviconCandidate();
-  for (std::vector<FaviconURL>::const_iterator i = candidates.begin();
-       i != candidates.end(); ++i) {
-    if (!i->icon_url.is_empty() && (i->icon_type & icon_types_))
-      image_urls_.push_back(*i);
+  for (const FaviconURL& candidate : candidates) {
+    if (!candidate.icon_url.is_empty() && (candidate.icon_type & icon_types_))
+      image_urls_.push_back(candidate);
   }
 
   if (download_largest_icon_)
     SortAndPruneImageUrls();
 
   // TODO(davemoore) Should clear on empty url. Currently we ignore it.
   // This appears to be what FF does as well.
   if (!image_urls_.empty())
     ProcessCurrentUrl();
 }
@@ skipping 322 matching lines @@
     // 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;
 }
 
 void FaviconHandler::SortAndPruneImageUrls() {
-  for (std::vector<FaviconURL>::iterator i = image_urls_.begin();
-       i != image_urls_.end(); ++i) {
-    if (i->icon_sizes.empty())
+  // Not using const-reference since the loop mutates FaviconURL::icon_sizes.
+  for (favicon::FaviconURL& image_url : image_urls_) {
+    if (image_url.icon_sizes.empty())
       continue;
 
-    gfx::Size largest = i->icon_sizes[GetLargestSizeIndex(i->icon_sizes)];
-    i->icon_sizes.clear();
-    i->icon_sizes.push_back(largest);
+    gfx::Size largest =
+        image_url.icon_sizes[GetLargestSizeIndex(image_url.icon_sizes)];
+    image_url.icon_sizes.clear();
+    image_url.icon_sizes.push_back(largest);
   }
   std::stable_sort(image_urls_.begin(), image_urls_.end(),
                    CompareIconSize);
 }