Update all bookmarks which use an icon URL when a favicon's bitmap is updated

components/bookmarks/browser/bookmark_model_unittest.cc

 // Copyright 2014 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 "components/bookmarks/browser/bookmark_model.h"
 
 #include <set>
 #include <string>
 
 #include "base/base_paths.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
+#include "components/bookmarks/browser/bookmark_match.h"
 #include "components/bookmarks/browser/bookmark_model_observer.h"
 #include "components/bookmarks/browser/bookmark_utils.h"
 #include "components/bookmarks/test/bookmark_test_helpers.h"
 #include "components/bookmarks/test/test_bookmark_client.h"
+#include "components/favicon_base/favicon_callback.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/base/models/tree_node_model.h"
+#include "ui/gfx/image/image.h"
 #include "url/gurl.h"
 
 using base::ASCIIToUTF16;
 using base::Time;
 using base::TimeDelta;
 
 namespace bookmarks {
 namespace {
 
 // Test cases used to test the removal of extra whitespace when adding
@@ skipping 162 matching lines @@
   }
 }
 
 void VerifyNoDuplicateIDs(BookmarkModel* model) {
   ui::TreeNodeIterator<const BookmarkNode> it(model->root_node());
   base::hash_set<int64> ids;
   while (it.has_next())
     ASSERT_TRUE(ids.insert(it.Next()->id()).second);
 }
 
+}  // namespace
+
 class BookmarkModelTest : public testing::Test,
                           public BookmarkModelObserver {
  public:
   struct ObserverDetails {
     ObserverDetails() {
       Set(NULL, NULL, -1, -1);
     }
 
     void Set(const BookmarkNode* node1,
              const BookmarkNode* node2,
@@ skipping 20 matching lines @@
     const BookmarkNode* node2_;
     int index1_;
     int index2_;
   };
 
   BookmarkModelTest() : model_(client_.CreateModel()) {
     model_->AddObserver(this);
     ClearCounts();
   }
 
+  // Emulates the favicon getting asynchronously loaded. In production, the
+  // favicon is asynchronously loaded when BookmarkModel::GetFavicon() is
+  // called.
+  void OnFaviconLoaded(BookmarkNode* node, const GURL& icon_url) {
+    SkBitmap bitmap;
+    bitmap.allocN32Pixels(16, 16);
+    bitmap.eraseColor(SK_ColorBLUE);
+    gfx::Image image = gfx::Image::CreateFrom1xBitmap(bitmap);
+
+    favicon_base::FaviconImageResult image_result;
+    image_result.image = image;
+    image_result.icon_url = icon_url;
+    model_->OnFaviconDataAvailable(node, favicon_base::IconType::FAVICON,
+                                   image_result);
+  }
+
   void BookmarkModelLoaded(BookmarkModel* model, bool ids_reassigned) override {
     // We never load from the db, so that this should never get invoked.
     NOTREACHED();
   }
 
   void BookmarkNodeMoved(BookmarkModel* model,
                          const BookmarkNode* old_parent,
                          int old_index,
                          const BookmarkNode* new_parent,
                          int new_index) override {
@@ skipping 40 matching lines @@
     ++reordered_count_;
   }
 
   void OnWillReorderBookmarkNode(BookmarkModel* model,
                                  const BookmarkNode* node) override {
     ++before_reorder_count_;
   }
 
   void BookmarkNodeFaviconChanged(BookmarkModel* model,
                                   const BookmarkNode* node) override {
-    // We never attempt to load favicons, so that this method never
-    // gets invoked.
   }
 
   void ExtensiveBookmarkChangesBeginning(BookmarkModel* model) override {
     ++extensive_changes_beginning_count_;
   }
 
   void ExtensiveBookmarkChangesEnded(BookmarkModel* model) override {
     ++extensive_changes_ended_count_;
   }
 
@@ skipping 276 matching lines @@
   const GURL url("http://foo.com");
   model_->AddURL(folder, 0, title, url);
 
   ClearCounts();
 
   // Now remove the folder.
   model_->Remove(root->GetChild(0));
   ASSERT_EQ(0, root->child_count());
   AssertObserverCount(0, 0, 1, 0, 0, 1, 0, 0, 0);
   observer_details_.ExpectEquals(root, NULL, 0, -1);
+}
 
-  // Make sure there is no mapping for the URL.
-  ASSERT_TRUE(model_->GetMostRecentlyAddedUserNodeForURL(url) == NULL);
+// Test that removing a BookmarkNode from the BookmarkModel clears any data that
+// the BookmarkModel has cached about that BookmarkNode.
+TEST_F(BookmarkModelTest, RemoveURLClearsCachedData) {
+  const BookmarkNode* root = model_->bookmark_bar_node();
+  base::string16 kTitle(ASCIIToUTF16("foo"));
+  GURL kPageURL("http://www.google.com");
+  GURL kFaviconURL("http://www.google.com/favicon.ico");
+
+  const BookmarkNode* node = model_->AddURL(root, 0, kTitle, kPageURL);
+
+  // Emulate the favicon getting asynchronously loaded.
+  OnFaviconLoaded(AsMutable(node), kFaviconURL);
+
+  // Test initial state.
+  std::vector<const BookmarkNode*> nodes;
+  model_->GetNodesByURL(kPageURL, &nodes);
+  ASSERT_EQ(1u, nodes.size());
+  ASSERT_EQ(node, nodes[0]);
+
+  nodes.clear();
+  model_->GetNodesByIconURL(kFaviconURL, &nodes);
+  ASSERT_EQ(1u, nodes.size());
+  ASSERT_EQ(node, nodes[0]);
+
+  std::vector<BookmarkMatch> matches;
+  model_->GetBookmarksMatching(kTitle, 1u, &matches);
+  ASSERT_EQ(1u, nodes.size());
+  ASSERT_EQ(node, nodes[0]);
+
+  // Remove |node| from the BookmarkModel.
+  model_->Remove(nodes[0]);
+
+  // Test that the BookmarkModel has forgotten about |node|.
+  nodes.clear();
+  model_->GetNodesByURL(kPageURL, &nodes);
+  EXPECT_TRUE(nodes.empty());
+
+  model_->GetNodesByIconURL(kFaviconURL, &nodes);
+  EXPECT_TRUE(nodes.empty());
+
+  matches.clear();
+  model_->GetBookmarksMatching(kTitle, 1u, &matches);
+  EXPECT_TRUE(matches.empty());
 }
 
 TEST_F(BookmarkModelTest, RemoveAllUserBookmarks) {
   const BookmarkNode* bookmark_bar_node = model_->bookmark_bar_node();
 
   ClearCounts();
 
   // Add a url to bookmark bar.
   base::string16 title(ASCIIToUTF16("foo"));
   GURL url("http://foo.com");
@@ skipping 53 matching lines @@
 
   ClearCounts();
 
   url = GURL("http://foo2.com");
   model_->SetURL(node, url);
   AssertObserverCount(0, 0, 0, 1, 0, 0, 1, 0, 0);
   observer_details_.ExpectEquals(node, NULL, -1, -1);
   EXPECT_EQ(url, node->url());
 }
 
+// Test that changing a BookmarkNode's page URL clears the BookmarkModel's
+// cached favicon data and the BookmarkNode's favicon data.
+TEST_F(BookmarkModelTest, SetURLClearsFaviconData) {
+  const BookmarkNode* root = model_->bookmark_bar_node();
+  base::string16 kTitle(ASCIIToUTF16("foo"));
+  GURL kPageURL1("http://www.google.com");
+  GURL kFaviconURL1("http://www.google.com/favicon.ico");
+  GURL kPageURL2("http://www.wikipedia.org");
+
+  const BookmarkNode* node = model_->AddURL(root, 0, kTitle, kPageURL1);
+
+  // Emulate the favicon getting asynchronously loaded.
+  OnFaviconLoaded(AsMutable(node), kFaviconURL1);
+
+  // Test initial state.
+  std::vector<const BookmarkNode*> nodes;
+  model_->GetNodesByIconURL(kFaviconURL1, &nodes);
+  ASSERT_EQ(1u, nodes.size());
+  ASSERT_EQ(node, nodes[0]);
+  ASSERT_EQ(kFaviconURL1, node->icon_url());
+
+  // Change |node|'s page URL
+  model_->SetURL(node, kPageURL2);
+
+  // BookmarkModel should have forgotten about |kFaviconURL1|.
+  nodes.clear();
+  model_->GetNodesByIconURL(kFaviconURL1, &nodes);
+  EXPECT_TRUE(nodes.empty());
+
+  // |node|'s favicon data should have been cleared.
+  EXPECT_EQ(GURL(), node->icon_url());
+}
+
 TEST_F(BookmarkModelTest, SetDateAdded) {
   const BookmarkNode* root = model_->bookmark_bar_node();
   const base::string16 title(ASCIIToUTF16("foo"));
   GURL url("http://foo.com");
   const BookmarkNode* node = model_->AddURL(root, 0, title, url);
 
   ClearCounts();
 
   base::Time new_time = base::Time::Now() + base::TimeDelta::FromMinutes(20);
   model_->SetDateAdded(node, new_time);
@@ skipping 480 matching lines @@
     PopulateNodeFromString(data[i].mobile_contents, &mobile);
     PopulateBookmarkNode(&mobile, model.get(), model->mobile_node());
 
     VerifyModelMatchesNode(&bbn, model->bookmark_bar_node());
     VerifyModelMatchesNode(&other, model->other_node());
     VerifyModelMatchesNode(&mobile, model->mobile_node());
     VerifyNoDuplicateIDs(model.get());
   }
 }
 
-}  // namespace
 }  // namespace bookmarks