Sync the bookmark's icon URL

chrome/browser/sync/test/integration/bookmarks_helper.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/sync/test/integration/bookmarks_helper.h"
 
 #include "base/compiler_specific.h"
 #include "base/rand_util.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/bookmark_model_observer.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/browser/favicon/favicon_service_factory.h"
+#include "chrome/browser/favicon/favicon_util.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/history/history_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/profile_sync_service_harness.h"
 #include "chrome/browser/sync/test/integration/sync_test.h"
 #include "chrome/browser/sync/test/integration/sync_datatype_helper.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/models/tree_node_iterator.h"
-#include "ui/gfx/codec/png_codec.h"
+#include "ui/gfx/image/image_skia.h"
 
 using sync_datatype_helper::test;
 
 namespace {
 
 // History task which runs all pending tasks on the history thread and
 // signals when the tasks have completed.
 class HistoryEmptyTask : public HistoryDBTask {
  public:
   explicit HistoryEmptyTask(base::WaitableEvent* done) : done_(done) {}
@@ skipping 117 matching lines @@
   void* node_pixel_addr_b = bitmap_b.getPixels();
   EXPECT_TRUE(node_pixel_addr_b);
   if (memcmp(node_pixel_addr_a, node_pixel_addr_b, bitmap_a.getSize()) !=  0) {
     LOG(ERROR) << "Favicon bitmap mismatch";
     return false;
   } else {
     return true;
   }
 }
 
-// Gets the favicon associated with |node| in |model|.
-gfx::Image GetFavicon(BookmarkModel* model, const BookmarkNode* node) {
+// Represents a favicon image and the icon URL associated with it.
+struct FaviconData {
+  FaviconData() {
+  }
+
+  FaviconData(const gfx::Image& favicon_image,
+              const GURL& favicon_url)
+      : image(favicon_image),
+        icon_url(favicon_url) {
+  }
+
+  ~FaviconData() {
+  }
+
+  gfx::Image image;
+  GURL icon_url;
+};
+
+// Gets the favicon and icon URL associated with |node| in |model|.
+FaviconData GetFaviconData(BookmarkModel* model,
+                           const BookmarkNode* node) {
   // If a favicon wasn't explicitly set for a particular URL, simply return its
   // blank favicon.
   if (!urls_with_favicons_ ||
       urls_with_favicons_->find(node->url()) == urls_with_favicons_->end()) {
-    return gfx::Image();
+    return FaviconData();
   }
   // If a favicon was explicitly set, we may need to wait for it to be loaded
   // via BookmarkModel::GetFavicon(), which is an asynchronous operation.
   if (!node->is_favicon_loaded()) {
     FaviconChangeObserver observer(model, node);
     model->GetFavicon(node);
     observer.WaitForGetFavicon();
   }
   EXPECT_TRUE(node->is_favicon_loaded());
   EXPECT_FALSE(model->GetFavicon(node).IsEmpty());
-  return model->GetFavicon(node);
+  return FaviconData(model->GetFavicon(node), node->icon_url());
 }
 
 // Sets the favicon for |profile| and |node|. |profile| may be
 // |test()->verifier()|.
 void SetFaviconImpl(Profile* profile,
                     const BookmarkNode* node,
+                    const GURL& icon_url,
                     const gfx::Image& image) {
     BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile);
 
     FaviconChangeObserver observer(model, node);
     FaviconService* favicon_service =
         FaviconServiceFactory::GetForProfile(profile,
                                              Profile::EXPLICIT_ACCESS);
     favicon_service->SetFavicons(node->url(),
-                                 node->url(),
+                                 icon_url,
                                  history::FAVICON,
                                  image);
 
     // Wait for the favicon for |node| to be invalidated.
     observer.WaitForSetFavicon();
     // Wait for the BookmarkModel to fetch the updated favicon and for the new
     // favicon to be sent to BookmarkChangeProcessor.
-    GetFavicon(model, node);
+    GetFaviconData(model, node);
 }
 
 // Wait for all currently scheduled tasks on the history thread for all
 // profiles to complete and any notifications sent to the UI thread to have
 // finished processing.
 void WaitForHistoryToProcessPendingTasks() {
   // Skip waiting for history to complete for tests without favicons.
   if (!urls_with_favicons_)
     return;
 
@@ skipping 17 matching lines @@
   // to the UI thread are processed.
   content::RunAllPendingInMessageLoop();
 }
 
 // Checks if the favicon in |node_a| from |model_a| matches that of |node_b|
 // from |model_b|. Returns true if they match.
 bool FaviconsMatch(BookmarkModel* model_a,
                    BookmarkModel* model_b,
                    const BookmarkNode* node_a,
                    const BookmarkNode* node_b) {
-  const gfx::Image& bitmap_a = GetFavicon(model_a, node_a);
-  const gfx::Image& bitmap_b = GetFavicon(model_b, node_b);
+  FaviconData favicon_data_a = GetFaviconData(model_a, node_a);
+  FaviconData favicon_data_b = GetFaviconData(model_b, node_b);
 
-  if (bitmap_a.IsEmpty() && bitmap_b.IsEmpty())
+  if (favicon_data_a.icon_url != favicon_data_b.icon_url)
+    return false;
+
+  gfx::Image image_a = favicon_data_a.image;
+  gfx::Image image_b = favicon_data_b.image;
+
+  if (image_a.IsEmpty() && image_b.IsEmpty())
     return true;  // Two empty images are equivalent.
-  return !bitmap_a.IsEmpty() && !bitmap_b.IsEmpty() &&
-          FaviconBitmapsMatch(*bitmap_a.ToSkBitmap(), *bitmap_b.ToSkBitmap());
+
+  if (image_a.IsEmpty() != image_b.IsEmpty())
+    return false;
+
+  // Compare only the 1x bitmaps as only those are synced.
+  SkBitmap bitmap_a = image_a.AsImageSkia().GetRepresentation(
+      ui::SCALE_FACTOR_100P).sk_bitmap();
+  SkBitmap bitmap_b = image_b.AsImageSkia().GetRepresentation(
+      ui::SCALE_FACTOR_100P).sk_bitmap();
+  return FaviconBitmapsMatch(bitmap_a, bitmap_b);
 }
 
 // Does a deep comparison of BookmarkNode fields in |model_a| and |model_b|.
 // Returns true if they are all equal.
 bool NodesMatch(const BookmarkNode* node_a, const BookmarkNode* node_b) {
   if (node_a == NULL || node_b == NULL)
     return node_a == node_b;
   if (node_a->is_folder() != node_b->is_folder()) {
     LOG(ERROR) << "Cannot compare folder with bookmark";
     return false;
@@ skipping 189 matching lines @@
   if (test()->use_verifier()) {
     const BookmarkNode* v_node = NULL;
     FindNodeInVerifier(GetBookmarkModel(profile), node, &v_node);
     GetVerifierBookmarkModel()->SetTitle(v_node, WideToUTF16(new_title));
   }
   GetBookmarkModel(profile)->SetTitle(node, WideToUTF16(new_title));
 }
 
 void SetFavicon(int profile,
                 const BookmarkNode* node,
-                const std::vector<unsigned char>& icon_bytes_vector) {
-  scoped_refptr<base::RefCountedBytes> bitmap_data(
-      new base::RefCountedBytes(icon_bytes_vector));
-  gfx::Image image(bitmap_data->front(), bitmap_data->size());
+                const GURL& icon_url,
+                const gfx::Image& image) {
   ASSERT_EQ(GetBookmarkModel(profile)->GetNodeByID(node->id()), node)
       << "Node " << node->GetTitle() << " does not belong to "
       << "Profile " << profile;
   ASSERT_EQ(BookmarkNode::URL, node->type())
       << "Node " << node->GetTitle() << " must be a url.";
   if (urls_with_favicons_ == NULL)
     urls_with_favicons_ = new std::set<GURL>();
   urls_with_favicons_->insert(node->url());
   if (test()->use_verifier()) {
     const BookmarkNode* v_node = NULL;
     FindNodeInVerifier(GetBookmarkModel(profile), node, &v_node);
-    SetFaviconImpl(test()->verifier(), v_node, image);
+    SetFaviconImpl(test()->verifier(), v_node, icon_url, image);
   }
-  SetFaviconImpl(test()->GetProfile(profile), node, image);
+  SetFaviconImpl(test()->GetProfile(profile), node, icon_url, image);
 }
 
 const BookmarkNode* SetURL(int profile,
                            const BookmarkNode* node,
                            const GURL& new_url) {
   if (GetBookmarkModel(profile)->GetNodeByID(node->id()) != node) {
     LOG(ERROR) << "Node " << node->GetTitle() << " does not belong to "
                << "Profile " << profile;
     return NULL;
   }
@@ skipping 158 matching lines @@
                                       BookmarkNode::URL,
                                       WideToUTF16(title));
 }
 
 int CountFoldersWithTitlesMatching(int profile, const std::wstring& title) {
   return CountNodesWithTitlesMatching(GetBookmarkModel(profile),
                                       BookmarkNode::FOLDER,
                                       WideToUTF16(title));
 }
 
-std::vector<unsigned char> CreateFavicon(int seed) {
-  const int w = 16;
-  const int h = 16;
-  SkBitmap bmp;
-  bmp.setConfig(SkBitmap::kARGB_8888_Config, w, h);
-  bmp.allocPixels();
-  uint32_t* src_data = bmp.getAddr32(0, 0);
-  for (int i = 0; i < w * h; ++i) {
-    src_data[i] = SkPreMultiplyARGB((seed + i) % 255,
-                                    (seed + i) % 250,
-                                    (seed + i) % 245,
-                                    (seed + i) % 240);
+gfx::Image CreateFavicon(SkColor color) {
+  const int dip_width = 16;
+  const int dip_height = 16;
+  std::vector<ui::ScaleFactor> favicon_scale_factors =
+      FaviconUtil::GetFaviconScaleFactors();
+  gfx::ImageSkia favicon;
+  for (size_t i = 0; i < favicon_scale_factors.size(); ++i) {
+    float scale = ui::GetScaleFactorScale(favicon_scale_factors[i]);
+    int pixel_width = dip_width * scale;
+    int pixel_height = dip_height * scale;
+    SkBitmap bmp;
+    bmp.setConfig(SkBitmap::kARGB_8888_Config, pixel_width, pixel_height);
+    bmp.allocPixels();
+    bmp.eraseColor(color);
+    favicon.AddRepresentation(gfx::ImageSkiaRep(bmp, favicon_scale_factors[i]));
   }
-  std::vector<unsigned char> favicon;
-  gfx::PNGCodec::EncodeBGRASkBitmap(bmp, false, &favicon);
-  return favicon;
+  return gfx::Image(favicon);
 }
 
 std::string IndexedURL(int i) {
   return StringPrintf("http://www.host.ext:1234/path/filename/%d", i);
 }
 
 std::wstring IndexedURLTitle(int i) {
   return StringPrintf(L"URL Title %d", i);
 }
 
 std::wstring IndexedFolderName(int i) {
   return StringPrintf(L"Folder Name %d", i);
 }
 
 std::wstring IndexedSubfolderName(int i) {
   return StringPrintf(L"Subfolder Name %d", i);
 }
 
 std::wstring IndexedSubsubfolderName(int i) {
   return StringPrintf(L"Subsubfolder Name %d", i);
 }
 
 }  // namespace bookmarks_helper