Convert ui::ScaleFactor -> float in favicon/history code

chrome/browser/history/history_backend_unittest.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/history/history_backend.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 308 matching lines @@
 
   // Returns a gfx::Size vector with tiny, small and large sizes.
   const std::vector<gfx::Size> GetSizesTinySmallAndLarge() {
     std::vector<gfx::Size> sizes_tiny_small_and_large;
     sizes_tiny_small_and_large.push_back(kTinySize);
     sizes_tiny_small_and_large.push_back(kSmallSize);
     sizes_tiny_small_and_large.push_back(kLargeSize);
     return sizes_tiny_small_and_large;
   }
 
-  // Returns 1x and 2x scale factors.
-  const std::vector<ui::ScaleFactor> GetScaleFactors1x2x() {
-    std::vector<ui::ScaleFactor> scale_factors_1x_2x;
-    scale_factors_1x_2x.push_back(ui::SCALE_FACTOR_100P);
-    scale_factors_1x_2x.push_back(ui::SCALE_FACTOR_200P);
-    return scale_factors_1x_2x;
+  // Returns 1x and 2x favicons cales.
+  const std::vector<float> GetFaviconScales1x2x() {
+    std::vector<float> scales_1x_2x;
+    scales_1x_2x.push_back(1.0f);
+    scales_1x_2x.push_back(2.0f);
+    return scales_1x_2x;
   }
 
   // Returns the number of icon mappings of |icon_type| to |page_url|.
   size_t NumIconMappingsForPageURL(const GURL& page_url,
                                    favicon_base::IconType icon_type) {
     std::vector<IconMapping> icon_mappings;
     backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url, icon_type,
                                                        &icon_mappings);
     return icon_mappings.size();
   }
@@ skipping 1432 matching lines @@
   backend_->SetFavicons(page_url1, favicon_base::FAVICON, favicon_bitmap_data);
 
   std::vector<GURL> icon_urls;
   icon_urls.push_back(icon_url);
 
   std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results;
   backend_->UpdateFaviconMappingsAndFetch(page_url2,
                                           icon_urls,
                                           favicon_base::FAVICON,
                                           kSmallSize.width(),
-                                          GetScaleFactors1x2x(),
+                                          GetFaviconScales1x2x(),
                                           &bitmap_results);
 
   // Check that the same FaviconID is mapped to both page URLs.
   std::vector<IconMapping> icon_mappings;
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(
       page_url1, &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   favicon_base::FaviconID favicon_id = icon_mappings[0].icon_id;
   EXPECT_NE(0, favicon_id);
 
@@ skipping 57 matching lines @@
   EXPECT_EQ(1, num_broadcasted_notifications());
 
   std::vector<GURL> icon_urls;
   icon_urls.push_back(icon_url);
 
   std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results;
   backend_->UpdateFaviconMappingsAndFetch(page_url,
                                           icon_urls,
                                           favicon_base::FAVICON,
                                           kSmallSize.width(),
-                                          GetScaleFactors1x2x(),
+                                          GetFaviconScales1x2x(),
                                           &bitmap_results);
 
   EXPECT_EQ(icon_id,
             backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
                 icon_url, favicon_base::FAVICON, NULL));
 
   // No notification should have been broadcast as no icon mapping, favicon,
   // or favicon bitmap was updated, added or removed.
   EXPECT_EQ(1, num_broadcasted_notifications());
 }
@@ skipping 316 matching lines @@
                          favicon_base::FAVICON,
                          bitmap_data,
                          kSmallSize);
 
   // Request favicon bitmaps for both 1x and 2x to simulate request done by
   // BookmarkModel::GetFavicon().
   std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results;
   backend_->GetFaviconsForURL(page_url,
                               favicon_base::FAVICON,
                               kSmallSize.width(),
-                              GetScaleFactors1x2x(),
+                              GetFaviconScales1x2x(),
                               &bitmap_results);
 
   EXPECT_EQ(2u, bitmap_results.size());
   const favicon_base::FaviconRawBitmapResult& first_result = bitmap_results[0];
   const favicon_base::FaviconRawBitmapResult& result =
       (first_result.pixel_size == kSmallSize) ? first_result
                                               : bitmap_results[1];
   EXPECT_TRUE(BitmapDataEqual('c', result.bitmap_data));
 }
 
@@ skipping 134 matching lines @@
   icon_urls.push_back(icon_urla);
   icon_urls.push_back(icon_urlb);
   icon_urls.push_back(icon_urlc);
 
   std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results;
   backend_->UpdateFaviconMappingsAndFetch(
       page_url3,
       icon_urls,
       (favicon_base::TOUCH_ICON | favicon_base::TOUCH_PRECOMPOSED_ICON),
       kSmallSize.width(),
-      GetScaleFactors1x2x(),
+      GetFaviconScales1x2x(),
       &bitmap_results);
 
   // |page_url1| and |page_url2| should still be mapped to the same icon URLs.
   std::vector<IconMapping> icon_mappings;
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url1,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_urla, icon_mappings[0].icon_url);
   EXPECT_EQ(favicon_base::TOUCH_ICON, icon_mappings[0].icon_type);
 
@@ skipping 18 matching lines @@
 
 // Test the results of GetFaviconsFromDB() when there are no found
 // favicons.
 TEST_F(HistoryBackendTest, GetFaviconsFromDBEmpty) {
   const GURL page_url("http://www.google.com/");
 
   std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results;
   EXPECT_FALSE(backend_->GetFaviconsFromDB(page_url,
                                            favicon_base::FAVICON,
                                            kSmallSize.width(),
-                                           GetScaleFactors1x2x(),
+                                           GetFaviconScales1x2x(),
                                            &bitmap_results));
   EXPECT_TRUE(bitmap_results.empty());
 }
 
 // Test the results of GetFaviconsFromDB() when there are matching favicons
 // but there are no associated favicon bitmaps.
 TEST_F(HistoryBackendTest, GetFaviconsFromDBNoFaviconBitmaps) {
   const GURL page_url("http://www.google.com/");
   const GURL icon_url("http://www.google.com/icon1");
 
   favicon_base::FaviconID icon_id =
       backend_->thumbnail_db_->AddFavicon(icon_url, favicon_base::FAVICON);
   EXPECT_NE(0, icon_id);
   EXPECT_NE(0, backend_->thumbnail_db_->AddIconMapping(page_url, icon_id));
 
   std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results_out;
   EXPECT_FALSE(backend_->GetFaviconsFromDB(page_url,
                                            favicon_base::FAVICON,
                                            kSmallSize.width(),
-                                           GetScaleFactors1x2x(),
+                                           GetFaviconScales1x2x(),
                                            &bitmap_results_out));
   EXPECT_TRUE(bitmap_results_out.empty());
 }
 
 // Test that GetFaviconsFromDB() returns results for the bitmaps which most
 // closely match the passed in desired size and scale factors.
 TEST_F(HistoryBackendTest, GetFaviconsFromDBSelectClosestMatch) {
   const GURL page_url("http://www.google.com/");
   const GURL icon_url("http://www.google.com/icon1");
 
   std::vector<favicon_base::FaviconRawBitmapData> favicon_bitmap_data;
   GenerateFaviconBitmapData(icon_url, GetSizesTinySmallAndLarge(),
                             &favicon_bitmap_data);
 
   backend_->SetFavicons(page_url, favicon_base::FAVICON, favicon_bitmap_data);
 
   std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results_out;
   EXPECT_TRUE(backend_->GetFaviconsFromDB(page_url,
                                           favicon_base::FAVICON,
                                           kSmallSize.width(),
-                                          GetScaleFactors1x2x(),
+                                          GetFaviconScales1x2x(),
                                           &bitmap_results_out));
 
   // The bitmap data for the small and large bitmaps should be returned as their
   // sizes match exactly.
   EXPECT_EQ(2u, bitmap_results_out.size());
   // No required order for results.
   if (bitmap_results_out[0].pixel_size == kLargeSize) {
     favicon_base::FaviconRawBitmapResult tmp_result = bitmap_results_out[0];
     bitmap_results_out[0] = bitmap_results_out[1];
     bitmap_results_out[1] = tmp_result;
@@ skipping 23 matching lines @@
   std::vector<favicon_base::FaviconRawBitmapData> favicon_bitmap_data;
   GenerateFaviconBitmapData(icon_url1, GetSizesSmall(), icon_url2,
                             GetSizesLarge(), &favicon_bitmap_data);
 
   backend_->SetFavicons(page_url, favicon_base::FAVICON, favicon_bitmap_data);
 
   std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results_out;
   EXPECT_TRUE(backend_->GetFaviconsFromDB(page_url,
                                           favicon_base::FAVICON,
                                           kSmallSize.width(),
-                                          GetScaleFactors1x2x(),
+                                          GetFaviconScales1x2x(),
                                           &bitmap_results_out));
 
   // The results should have results for the icon URL with the large bitmap as
   // downscaling is preferred to upscaling.
   EXPECT_EQ(1u, bitmap_results_out.size());
   EXPECT_EQ(kLargeSize, bitmap_results_out[0].pixel_size);
   EXPECT_EQ(icon_url2, bitmap_results_out[0].icon_url);
 }
 
 // Test the results of GetFaviconsFromDB() when called with different
 // |icon_types|.
 TEST_F(HistoryBackendTest, GetFaviconsFromDBIconType) {
   const GURL page_url("http://www.google.com/");
   const GURL icon_url1("http://www.google.com/icon1.png");
   const GURL icon_url2("http://www.google.com/icon2.png");
 
   std::vector<favicon_base::FaviconRawBitmapData> favicon_bitmap_data;
   GenerateFaviconBitmapData(icon_url1, GetSizesSmall(),  &favicon_bitmap_data);
   backend_->SetFavicons(page_url, favicon_base::FAVICON, favicon_bitmap_data);
 
   GenerateFaviconBitmapData(icon_url2, GetSizesSmall(), &favicon_bitmap_data);
   backend_->SetFavicons(
       page_url, favicon_base::TOUCH_ICON, favicon_bitmap_data);
 
   std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results_out;
   EXPECT_TRUE(backend_->GetFaviconsFromDB(page_url,
                                           favicon_base::FAVICON,
                                           kSmallSize.width(),
-                                          GetScaleFactors1x2x(),
+                                          GetFaviconScales1x2x(),
                                           &bitmap_results_out));
 
   EXPECT_EQ(1u, bitmap_results_out.size());
   EXPECT_EQ(favicon_base::FAVICON, bitmap_results_out[0].icon_type);
   EXPECT_EQ(icon_url1, bitmap_results_out[0].icon_url);
 
   bitmap_results_out.clear();
   EXPECT_TRUE(backend_->GetFaviconsFromDB(page_url,
                                           favicon_base::TOUCH_ICON,
                                           kSmallSize.width(),
-                                          GetScaleFactors1x2x(),
+                                          GetFaviconScales1x2x(),
                                           &bitmap_results_out));
 
   EXPECT_EQ(1u, bitmap_results_out.size());
   EXPECT_EQ(favicon_base::TOUCH_ICON, bitmap_results_out[0].icon_type);
   EXPECT_EQ(icon_url2, bitmap_results_out[0].icon_url);
 }
 
 // Test that GetFaviconsFromDB() correctly sets the expired flag for bitmap
 // reults.
 TEST_F(HistoryBackendTest, GetFaviconsFromDBExpired) {
   const GURL page_url("http://www.google.com/");
   const GURL icon_url("http://www.google.com/icon.png");
 
   std::vector<unsigned char> data;
   data.push_back('a');
   scoped_refptr<base::RefCountedBytes> bitmap_data(
       base::RefCountedBytes::TakeVector(&data));
   base::Time last_updated = base::Time::FromTimeT(0);
   favicon_base::FaviconID icon_id = backend_->thumbnail_db_->AddFavicon(
       icon_url, favicon_base::FAVICON, bitmap_data, last_updated, kSmallSize);
   EXPECT_NE(0, icon_id);
   EXPECT_NE(0, backend_->thumbnail_db_->AddIconMapping(page_url, icon_id));
 
   std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results_out;
   EXPECT_TRUE(backend_->GetFaviconsFromDB(page_url,
                                           favicon_base::FAVICON,
                                           kSmallSize.width(),
-                                          GetScaleFactors1x2x(),
+                                          GetFaviconScales1x2x(),
                                           &bitmap_results_out));
 
   EXPECT_EQ(1u, bitmap_results_out.size());
   EXPECT_TRUE(bitmap_results_out[0].expired);
 }
 
 // Check that UpdateFaviconMappingsAndFetch() call back to the UI when there is
 // no valid thumbnail database.
 TEST_F(HistoryBackendTest, UpdateFaviconMappingsAndFetchNoDB) {
   // Make the thumbnail database invalid.
   backend_->thumbnail_db_.reset();
 
   std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results;
 
   backend_->UpdateFaviconMappingsAndFetch(GURL(),
                                           std::vector<GURL>(),
                                           favicon_base::FAVICON,
                                           kSmallSize.width(),
-                                          GetScaleFactors1x2x(),
+                                          GetFaviconScales1x2x(),
                                           &bitmap_results);
 
   EXPECT_TRUE(bitmap_results.empty());
 }
 
 TEST_F(HistoryBackendTest, CloneFaviconIsRestrictedToSameDomain) {
   const GURL url("http://www.google.com/");
   const GURL same_domain_url("http://www.google.com/subdir/index.html");
   const GURL foreign_domain_url("http://www.not-google.com/");
   const GURL icon_url("http://www.google.com/icon.png");
 
   // Add a favicon
   std::vector<favicon_base::FaviconRawBitmapData> favicon_bitmap_data;
   GenerateFaviconBitmapData(icon_url, GetSizesSmall(),  &favicon_bitmap_data);
   backend_->SetFavicons(url, favicon_base::FAVICON, favicon_bitmap_data);
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(
       url, favicon_base::FAVICON, NULL));
 
   // Validate starting state.
   std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results_out;
   EXPECT_TRUE(backend_->GetFaviconsFromDB(url,
                                           favicon_base::FAVICON,
                                           kSmallSize.width(),
-                                          GetScaleFactors1x2x(),
+                                          GetFaviconScales1x2x(),
                                           &bitmap_results_out));
   EXPECT_FALSE(backend_->GetFaviconsFromDB(same_domain_url,
                                            favicon_base::FAVICON,
                                            kSmallSize.width(),
-                                           GetScaleFactors1x2x(),
+                                           GetFaviconScales1x2x(),
                                            &bitmap_results_out));
   EXPECT_FALSE(backend_->GetFaviconsFromDB(foreign_domain_url,
                                            favicon_base::FAVICON,
                                            kSmallSize.width(),
-                                           GetScaleFactors1x2x(),
+                                           GetFaviconScales1x2x(),
                                            &bitmap_results_out));
 
   // Same-domain cloning should work.
   backend_->CloneFavicons(url, same_domain_url);
   EXPECT_TRUE(backend_->GetFaviconsFromDB(same_domain_url,
                                           favicon_base::FAVICON,
                                           kSmallSize.width(),
-                                          GetScaleFactors1x2x(),
+                                          GetFaviconScales1x2x(),
                                           &bitmap_results_out));
 
   // Foreign-domain cloning is forbidden.
   backend_->CloneFavicons(url, foreign_domain_url);
   EXPECT_FALSE(backend_->GetFaviconsFromDB(foreign_domain_url,
                                            favicon_base::FAVICON,
                                            kSmallSize.width(),
-                                           GetScaleFactors1x2x(),
+                                           GetFaviconScales1x2x(),
                                            &bitmap_results_out));
 }
 
 TEST_F(HistoryBackendTest, QueryFilteredURLs) {
   const char* google = "http://www.google.com/";
   const char* yahoo = "http://www.yahoo.com/";
   const char* yahoo_sports = "http://sports.yahoo.com/";
   const char* yahoo_sports_with_article1 =
       "http://sports.yahoo.com/article1.htm";
   const char* yahoo_sports_with_article2 =
@@ skipping 728 matching lines @@
   // Verify that the second term is no longer returned as result, and also check
   // at the low level that it is gone for good. The term corresponding to the
   // first URLRow should not be affected.
   EXPECT_EQ(1u, GetNumberOfMatchingSearchTerms(kTestKeywordId, term1));
   EXPECT_EQ(0u, GetNumberOfMatchingSearchTerms(kTestKeywordId, term2));
   EXPECT_TRUE(mem_backend_->db()->GetKeywordSearchTermRow(row1.id(), NULL));
   EXPECT_FALSE(mem_backend_->db()->GetKeywordSearchTermRow(row2.id(), NULL));
 }
 
 }  // namespace history