components/enhanced_bookmarks/enhanced_bookmark_model_unittest.cc

   1 // Copyright 2014 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 "components/enhanced_bookmarks/enhanced_bookmark_model.h"
   6
   7 #include "base/base64.h"
   8 #include "base/macros.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/run_loop.h"
  12 #include "base/strings/string_number_conversions.h"
  13 #include "base/strings/string_util.h"
  14 #include "base/strings/utf_string_conversions.h"
  15 #include "components/bookmarks/browser/bookmark_model.h"
  16 #include "components/bookmarks/browser/bookmark_node.h"
  17 #include "components/bookmarks/test/test_bookmark_client.h"
  18 #include "components/enhanced_bookmarks/enhanced_bookmark_model_observer.h"
  19 #include "components/enhanced_bookmarks/proto/metadata.pb.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21 #include "url/gurl.h"
  22
  23 using enhanced_bookmarks::EnhancedBookmarkModel;
  24
  25 namespace {
  26 const std::string BOOKMARK_URL("http://example.com/index.html");
  27 }  // namespace
  28
  29 class EnhancedBookmarkModelTest
  30     : public testing::Test,
  31       public enhanced_bookmarks::EnhancedBookmarkModelObserver {
  32  public:
  33   EnhancedBookmarkModelTest()
  34       : loaded_calls_(0),
  35         shutting_down_calls_(0),
  36         added_calls_(0),
  37         removed_calls_(0),
  38         all_user_nodes_removed_calls_(0),
  39         remote_id_changed_calls_(0),
  40         last_added_(NULL),
  41         last_removed_(NULL),
  42         last_remote_id_node_(NULL) {}
  43   ~EnhancedBookmarkModelTest() override {}
  44
  45   void SetUp() override {
  46     message_loop_.reset(new base::MessageLoop(base::MessageLoop::TYPE_DEFAULT));
  47     bookmark_client_.reset(new bookmarks::TestBookmarkClient());
  48     bookmark_model_.reset(bookmark_client_->CreateModel().release());
  49     model_.reset(new EnhancedBookmarkModel(bookmark_model_.get(), "v1.0"));
  50     model_->AddObserver(this);
  51   }
  52
  53   void TearDown() override {
  54     if (model_)
  55       model_->Shutdown();
  56     model_.reset();
  57     bookmark_model_.reset();
  58     bookmark_client_.reset();
  59     message_loop_.reset();
  60   }
  61
  62  protected:
  63   const BookmarkNode* AddBookmark() {
  64     return AddBookmark("Some title", bookmark_model_->other_node());
  65   }
  66
  67   const BookmarkNode* AddFolder() {
  68     return AddFolder("Some title", bookmark_model_->other_node());
  69   }
  70
  71   const BookmarkNode* AddBookmark(const std::string& name,
  72                                   const BookmarkNode* parent) {
  73     return model_->AddURL(parent,
  74                           0,  // index.
  75                           base::ASCIIToUTF16(name),
  76                           GURL(BOOKMARK_URL),
  77                           base::Time::Now());
  78   }
  79
  80   const BookmarkNode* AddFolder(const std::string& name,
  81                                 const BookmarkNode* parent) {
  82     return model_->AddFolder(parent, 0, base::ASCIIToUTF16(name));
  83   }
  84
  85   std::string GetVersion(const BookmarkNode* node) {
  86     return GetMetaInfoField(node, "stars.version");
  87   }
  88
  89   std::string GetId(const BookmarkNode* node) {
  90     return GetMetaInfoField(node, "stars.id");
  91   }
  92
  93   std::string GetOldId(const BookmarkNode* node) {
  94     return GetMetaInfoField(node, "stars.oldId");
  95   }
  96
  97   std::string GetMetaInfoField(const BookmarkNode* node,
  98                                const std::string& name) {
  99     std::string value;
 100     if (!node->GetMetaInfo(name, &value))
 101       return std::string();
 102     return value;
 103   }
 104
 105   scoped_ptr<base::MessageLoop> message_loop_;
 106   scoped_ptr<bookmarks::TestBookmarkClient> bookmark_client_;
 107   scoped_ptr<BookmarkModel> bookmark_model_;
 108   scoped_ptr<EnhancedBookmarkModel> model_;
 109
 110   // EnhancedBookmarkModelObserver implementation:
 111   void EnhancedBookmarkModelLoaded() override { loaded_calls_++; }
 112   void EnhancedBookmarkModelShuttingDown() override { shutting_down_calls_++; }
 113   void EnhancedBookmarkAdded(const BookmarkNode* node) override {
 114     added_calls_++;
 115     last_added_ = node;
 116   }
 117   void EnhancedBookmarkRemoved(const BookmarkNode* node) override {
 118     removed_calls_++;
 119     last_removed_ = node;
 120   }
 121   void EnhancedBookmarkAllUserNodesRemoved() override {
 122     all_user_nodes_removed_calls_++;
 123   }
 124   void EnhancedBookmarkRemoteIdChanged(const BookmarkNode* node,
 125                                        const std::string& old_remote_id,
 126                                        const std::string& remote_id) override {
 127     remote_id_changed_calls_++;
 128     last_remote_id_node_ = node;
 129     last_old_remote_id_ = old_remote_id;
 130     last_remote_id_ = remote_id;
 131   }
 132
 133   // Observer call counters:
 134   int loaded_calls_;
 135   int shutting_down_calls_;
 136   int added_calls_;
 137   int removed_calls_;
 138   int all_user_nodes_removed_calls_;
 139   int remote_id_changed_calls_;
 140
 141   // Observer parameter cache:
 142   const BookmarkNode* last_added_;
 143   const BookmarkNode* last_removed_;
 144   const BookmarkNode* last_remote_id_node_;
 145   std::string last_old_remote_id_;
 146   std::string last_remote_id_;
 147
 148  private:
 149   DISALLOW_COPY_AND_ASSIGN(EnhancedBookmarkModelTest);
 150 };
 151
 152 TEST_F(EnhancedBookmarkModelTest, TestEmptySnippet) {
 153   const BookmarkNode* node = AddBookmark();
 154
 155   std::string snippet(model_->GetSnippet(node));
 156   EXPECT_EQ(snippet, "");
 157 };
 158
 159 TEST_F(EnhancedBookmarkModelTest, TestSnippet) {
 160   const BookmarkNode* node = AddBookmark();
 161
 162   // Binary serialize the protobuf.
 163   image::collections::PageData data;
 164   data.set_snippet("I'm happy!");
 165   ASSERT_TRUE(data.IsInitialized());
 166   std::string output;
 167   bool result = data.SerializeToString(&output);
 168   ASSERT_TRUE(result);
 169
 170   // base64 encode the output.
 171   std::string encoded;
 172   base::Base64Encode(output, &encoded);
 173   bookmark_model_->SetNodeMetaInfo(node, "stars.pageData", encoded);
 174
 175   std::string snippet(model_->GetSnippet(node));
 176   EXPECT_EQ(snippet, "I'm happy!");
 177 }
 178
 179 TEST_F(EnhancedBookmarkModelTest, TestBadEncodingSnippet) {
 180   const BookmarkNode* node = AddBookmark();
 181
 182   // Binary serialize the protobuf.
 183   image::collections::PageData data;
 184   data.set_snippet("You are happy!");
 185   ASSERT_TRUE(data.IsInitialized());
 186   std::string output;
 187   bool result = data.SerializeToString(&output);
 188   ASSERT_TRUE(result);
 189
 190   // don't base 64 encode the output.
 191   bookmark_model_->SetNodeMetaInfo(node, "stars.pageData", output);
 192
 193   std::string snippet(model_->GetSnippet(node));
 194   EXPECT_EQ(snippet, "");
 195 }
 196
 197 TEST_F(EnhancedBookmarkModelTest, TestOriginalImage) {
 198   const BookmarkNode* node = AddBookmark();
 199
 200   image::collections::ImageData data;
 201   // Intentionally make raw pointer.
 202   image::collections::ImageData_ImageInfo* info =
 203       new image::collections::ImageData_ImageInfo;
 204   info->set_url("http://example.com/foobar");
 205   info->set_width(15);
 206   info->set_height(55);
 207   // This method consumes the pointer.
 208   data.set_allocated_original_info(info);
 209
 210   std::string output;
 211   bool result = data.SerializePartialToString(&output);
 212   ASSERT_TRUE(result);
 213
 214   // base64 encode the output.
 215   std::string encoded;
 216   base::Base64Encode(output, &encoded);
 217   bookmark_model_->SetNodeMetaInfo(node, "stars.imageData", encoded);
 218
 219   GURL url;
 220   int width;
 221   int height;
 222   result = model_->GetOriginalImage(node, &url, &width, &height);
 223   ASSERT_TRUE(result);
 224   EXPECT_EQ(url, GURL("http://example.com/foobar"));
 225   EXPECT_EQ(width, 15);
 226   EXPECT_EQ(height, 55);
 227 }
 228
 229 TEST_F(EnhancedBookmarkModelTest, TestThumbnailImage) {
 230   const BookmarkNode* node = AddBookmark();
 231
 232   image::collections::ImageData data;
 233   // Intentionally make raw pointer.
 234   image::collections::ImageData_ImageInfo* info =
 235       new image::collections::ImageData_ImageInfo;
 236   info->set_url("http://example.com/foobar");
 237   info->set_width(15);
 238   info->set_height(55);
 239   // This method consumes the pointer.
 240   data.set_allocated_thumbnail_info(info);
 241
 242   std::string output;
 243   bool result = data.SerializePartialToString(&output);
 244   ASSERT_TRUE(result);
 245
 246   // base64 encode the output.
 247   std::string encoded;
 248   base::Base64Encode(output, &encoded);
 249   bookmark_model_->SetNodeMetaInfo(node, "stars.imageData", encoded);
 250
 251   GURL url;
 252   int width;
 253   int height;
 254   result = model_->GetThumbnailImage(node, &url, &width, &height);
 255   ASSERT_TRUE(result);
 256   EXPECT_EQ(url, GURL("http://example.com/foobar"));
 257   EXPECT_EQ(width, 15);
 258   EXPECT_EQ(height, 55);
 259 }
 260
 261 TEST_F(EnhancedBookmarkModelTest, TestOriginalImageMissingDimensions) {
 262   const BookmarkNode* node = AddBookmark();
 263
 264   image::collections::ImageData data;
 265   // Intentionally make raw pointer.
 266   image::collections::ImageData_ImageInfo* info =
 267       new image::collections::ImageData_ImageInfo;
 268   info->set_url("http://example.com/foobar");
 269   // This method consumes the pointer.
 270   data.set_allocated_original_info(info);
 271
 272   std::string output;
 273   bool result = data.SerializePartialToString(&output);
 274   ASSERT_TRUE(result);
 275
 276   // base64 encode the output.
 277   std::string encoded;
 278   base::Base64Encode(output, &encoded);
 279   bookmark_model_->SetNodeMetaInfo(node, "stars.imageData", encoded);
 280
 281   GURL url;
 282   int width;
 283   int height;
 284   result = model_->GetOriginalImage(node, &url, &width, &height);
 285   ASSERT_FALSE(result);
 286 }
 287
 288 TEST_F(EnhancedBookmarkModelTest, TestOriginalImageBadUrl) {
 289   const BookmarkNode* node = AddBookmark();
 290
 291   image::collections::ImageData data;
 292   // Intentionally make raw pointer.
 293   image::collections::ImageData_ImageInfo* info =
 294       new image::collections::ImageData_ImageInfo;
 295   info->set_url("asdf. 13r");
 296   info->set_width(15);
 297   info->set_height(55);
 298   // This method consumes the pointer.
 299   data.set_allocated_original_info(info);
 300
 301   std::string output;
 302   bool result = data.SerializePartialToString(&output);
 303   ASSERT_TRUE(result);
 304
 305   // base64 encode the output.
 306   std::string encoded;
 307   base::Base64Encode(output, &encoded);
 308   bookmark_model_->SetNodeMetaInfo(node, "stars.imageData", encoded);
 309
 310   GURL url;
 311   int width;
 312   int height;
 313   result = model_->GetOriginalImage(node, &url, &width, &height);
 314   ASSERT_FALSE(result);
 315 }
 316
 317 TEST_F(EnhancedBookmarkModelTest, TestEncodeDecode) {
 318   const BookmarkNode* node = AddBookmark();
 319
 320   bool result =
 321       model_->SetOriginalImage(node, GURL("http://example.com/i.jpg"), 22, 33);
 322   ASSERT_TRUE(result);
 323
 324   GURL url;
 325   int width;
 326   int height;
 327   result = model_->GetOriginalImage(node, &url, &width, &height);
 328   ASSERT_TRUE(result);
 329   EXPECT_EQ(url, GURL("http://example.com/i.jpg"));
 330   EXPECT_EQ(width, 22);
 331   EXPECT_EQ(height, 33);
 332   EXPECT_EQ("v1.0", GetVersion(node));
 333 }
 334
 335 TEST_F(EnhancedBookmarkModelTest, TestDoubleEncodeDecode) {
 336   const BookmarkNode* node = AddBookmark();
 337
 338   // Encode some information.
 339   bool result =
 340       model_->SetOriginalImage(node, GURL("http://example.com/i.jpg"), 22, 33);
 341   ASSERT_TRUE(result);
 342   // Encode some different information.
 343   result =
 344       model_->SetOriginalImage(node, GURL("http://example.com/i.jpg"), 33, 44);
 345   ASSERT_TRUE(result);
 346
 347   GURL url;
 348   int width;
 349   int height;
 350   result = model_->GetOriginalImage(node, &url, &width, &height);
 351   ASSERT_TRUE(result);
 352   EXPECT_EQ(url, GURL("http://example.com/i.jpg"));
 353   EXPECT_EQ(width, 33);
 354   EXPECT_EQ(height, 44);
 355   EXPECT_EQ("v1.0", GetVersion(node));
 356 }
 357
 358 TEST_F(EnhancedBookmarkModelTest, TestRemoteId) {
 359   const BookmarkNode* node = AddBookmark();
 360   // Verify that the remote id starts with the correct prefix.
 361   EXPECT_TRUE(StartsWithASCII(model_->GetRemoteId(node), "ebc_", true));
 362
 363   // Getting the remote id for nodes that don't have them should return the
 364   // empty string.
 365   const BookmarkNode* existing_node =
 366       bookmark_model_->AddURL(bookmark_model_->other_node(),
 367                               0,
 368                               base::ASCIIToUTF16("Title"),
 369                               GURL(GURL(BOOKMARK_URL)));
 370   EXPECT_TRUE(model_->GetRemoteId(existing_node).empty());
 371
 372   // Folder nodes should not have a remote id set on creation.
 373   const BookmarkNode* folder_node = AddFolder();
 374   EXPECT_TRUE(model_->GetRemoteId(folder_node).empty());
 375 }
 376
 377 TEST_F(EnhancedBookmarkModelTest, TestEmptyDescription) {
 378   const BookmarkNode* node = AddBookmark();
 379
 380   std::string description(model_->GetDescription(node));
 381   EXPECT_EQ(description, "");
 382 }
 383
 384 TEST_F(EnhancedBookmarkModelTest, TestDescription) {
 385   const BookmarkNode* node = AddBookmark();
 386   const std::string description("This is the most useful description of all.");
 387
 388   // Set the description.
 389   model_->SetDescription(node, description);
 390
 391   // Check the description is the one that was set.
 392   EXPECT_EQ(model_->GetDescription(node), description);
 393   EXPECT_EQ("v1.0", GetVersion(node));
 394 }
 395
 396 // If there is no notes field, the description should fall back on the snippet.
 397 TEST_F(EnhancedBookmarkModelTest, TestDescriptionFallback) {
 398   const BookmarkNode* node = AddBookmark();
 399
 400   // Binary serialize the protobuf.
 401   image::collections::PageData data;
 402   data.set_snippet("Joe Bar Team");
 403   ASSERT_TRUE(data.IsInitialized());
 404   std::string output;
 405   bool result = data.SerializeToString(&output);
 406   ASSERT_TRUE(result);
 407
 408   // base64 encode the output.
 409   std::string encoded;
 410   base::Base64Encode(output, &encoded);
 411   bookmark_model_->SetNodeMetaInfo(node, "stars.pageData", encoded);
 412
 413   // The snippet is used as the description.
 414   std::string snippet(model_->GetSnippet(node));
 415   EXPECT_EQ("Joe Bar Team", model_->GetDescription(node));
 416
 417   // Set the description.
 418   const std::string description("This is the most useful description of all.");
 419   model_->SetDescription(node, description);
 420
 421   // Check the description is the one that was set.
 422   EXPECT_EQ(model_->GetDescription(node), description);
 423 }
 424
 425 // Makes sure that the stars.version field is set every time
 426 // EnhancedBookmarkModel makes a change to a node.
 427 TEST_F(EnhancedBookmarkModelTest, TestVersionField) {
 428   const BookmarkNode* node = AddBookmark();
 429   EXPECT_EQ("", GetVersion(node));
 430
 431   model_->SetDescription(node, "foo");
 432   EXPECT_EQ("v1.0", GetVersion(node));
 433
 434   // Add a suffix to the version to set.
 435   model_->SetVersionSuffix("alpha");
 436
 437   model_->SetDescription(node, "foo");
 438   // Since the description didn't actually change, the version field should
 439   // not either.
 440   EXPECT_EQ("v1.0", GetVersion(node));
 441
 442   model_->SetDescription(node, "bar");
 443   EXPECT_EQ("v1.0/alpha", GetVersion(node));
 444 }
 445
 446 // Verifies that duplicate nodes are reset when the model is created.
 447 TEST_F(EnhancedBookmarkModelTest, ResetDuplicateNodesOnInitialization) {
 448   model_->Shutdown();
 449
 450   const BookmarkNode* parent = bookmark_model_->other_node();
 451   const BookmarkNode* node1 = bookmark_model_->AddURL(
 452       parent, 0, base::ASCIIToUTF16("Some title"), GURL(BOOKMARK_URL));
 453   const BookmarkNode* node2 = bookmark_model_->AddURL(
 454       parent, 0, base::ASCIIToUTF16("Some title"), GURL(BOOKMARK_URL));
 455   const BookmarkNode* node3 = bookmark_model_->AddURL(
 456       parent, 0, base::ASCIIToUTF16("Some title"), GURL(BOOKMARK_URL));
 457   const BookmarkNode* node4 = bookmark_model_->AddURL(
 458       parent, 0, base::ASCIIToUTF16("Some title"), GURL(BOOKMARK_URL));
 459
 460   bookmark_model_->SetNodeMetaInfo(node1, "stars.id", "c_1");
 461   bookmark_model_->SetNodeMetaInfo(node2, "stars.id", "c_2");
 462   bookmark_model_->SetNodeMetaInfo(node3, "stars.id", "c_1");
 463   bookmark_model_->SetNodeMetaInfo(node4, "stars.id", "c_1");
 464   EXPECT_EQ("c_1", GetId(node1));
 465   EXPECT_EQ("c_2", GetId(node2));
 466   EXPECT_EQ("c_1", GetId(node3));
 467   EXPECT_EQ("c_1", GetId(node4));
 468
 469   model_.reset(new EnhancedBookmarkModel(bookmark_model_.get(), "v2.0"));
 470   base::RunLoop().RunUntilIdle();
 471   EXPECT_EQ("c_2", GetId(node2));
 472   EXPECT_EQ("", GetId(node1));
 473   EXPECT_EQ("", GetId(node3));
 474   EXPECT_EQ("", GetId(node4));
 475   EXPECT_EQ("c_1", GetOldId(node1));
 476   EXPECT_EQ("c_1", GetOldId(node3));
 477   EXPECT_EQ("c_1", GetOldId(node4));
 478   EXPECT_EQ("v2.0", GetVersion(node1));
 479   EXPECT_EQ("v2.0", GetVersion(node3));
 480   EXPECT_EQ("v2.0", GetVersion(node4));
 481 }
 482
 483 // Verifies that duplicate nodes are reset if one is created.
 484 TEST_F(EnhancedBookmarkModelTest, ResetDuplicateAddedNodes) {
 485   BookmarkNode::MetaInfoMap meta_info;
 486   meta_info["stars.id"] = "c_1";
 487   const BookmarkNode* parent = bookmark_model_->other_node();
 488
 489   const BookmarkNode* node1 =
 490       bookmark_model_->AddURLWithCreationTimeAndMetaInfo(
 491           parent,
 492           0,
 493           base::ASCIIToUTF16("Some title"),
 494           GURL(BOOKMARK_URL),
 495           base::Time::Now(),
 496           &meta_info);
 497   EXPECT_EQ("c_1", GetId(node1));
 498
 499   const BookmarkNode* node2 =
 500       bookmark_model_->AddURLWithCreationTimeAndMetaInfo(
 501           parent,
 502           0,
 503           base::ASCIIToUTF16("Some title"),
 504           GURL(BOOKMARK_URL),
 505           base::Time::Now(),
 506           &meta_info);
 507
 508   base::RunLoop().RunUntilIdle();
 509   EXPECT_EQ("", GetId(node1));
 510   EXPECT_EQ("", GetId(node2));
 511   EXPECT_EQ("c_1", GetOldId(node1));
 512   EXPECT_EQ("c_1", GetOldId(node2));
 513   EXPECT_EQ("v1.0", GetVersion(node1));
 514   EXPECT_EQ("v1.0", GetVersion(node2));
 515 }
 516
 517 // Verifies that duplicate nodes are reset if an id is changed to a duplicate
 518 // value.
 519 TEST_F(EnhancedBookmarkModelTest, ResetDuplicateChangedNodes) {
 520   const BookmarkNode* node1 = AddBookmark();
 521   const BookmarkNode* node2 = AddBookmark();
 522
 523   bookmark_model_->SetNodeMetaInfo(node1, "stars.id", "c_1");
 524   EXPECT_EQ("c_1", GetId(node1));
 525
 526   bookmark_model_->SetNodeMetaInfo(node2, "stars.id", "c_1");
 527   base::RunLoop().RunUntilIdle();
 528   EXPECT_EQ("", GetId(node1));
 529   EXPECT_EQ("", GetId(node2));
 530   EXPECT_EQ("c_1", GetOldId(node1));
 531   EXPECT_EQ("c_1", GetOldId(node2));
 532   EXPECT_EQ("v1.0", GetVersion(node1));
 533   EXPECT_EQ("v1.0", GetVersion(node2));
 534 }
 535
 536 TEST_F(EnhancedBookmarkModelTest, SetMultipleMetaInfo) {
 537   const BookmarkNode* node = AddBookmark();
 538   BookmarkNode::MetaInfoMap meta_info;
 539   meta_info["a"] = "aa";
 540   meta_info["b"] = "bb";
 541
 542   model_->SetVersionSuffix("1");
 543   model_->SetMultipleMetaInfo(node, meta_info);
 544   EXPECT_EQ("aa", GetMetaInfoField(node, "a"));
 545   EXPECT_EQ("bb", GetMetaInfoField(node, "b"));
 546   EXPECT_EQ("v1.0/1", GetVersion(node));
 547
 548   // Not present fields does not erase the fields already set on the node.
 549   meta_info["a"] = "aaa";
 550   model_->SetVersionSuffix("2");
 551   model_->SetMultipleMetaInfo(node, meta_info);
 552   EXPECT_EQ("aaa", GetMetaInfoField(node, "a"));
 553   EXPECT_EQ("bb", GetMetaInfoField(node, "b"));
 554   EXPECT_EQ("v1.0/2", GetVersion(node));
 555
 556   // Not actually changing any values should not set the version field.
 557   model_->SetVersionSuffix("3");
 558   model_->SetMultipleMetaInfo(node, meta_info);
 559   EXPECT_EQ("v1.0/2", GetVersion(node));
 560 }
 561
 562 TEST_F(EnhancedBookmarkModelTest, ObserverShuttingDownEvent) {
 563   EXPECT_EQ(0, shutting_down_calls_);
 564   model_->Shutdown();
 565   EXPECT_EQ(1, shutting_down_calls_);
 566   model_.reset();
 567 }
 568
 569 TEST_F(EnhancedBookmarkModelTest, ObserverNodeAddedEvent) {
 570   EXPECT_EQ(0, added_calls_);
 571   const BookmarkNode* node = AddBookmark();
 572   EXPECT_EQ(1, added_calls_);
 573   EXPECT_EQ(node, last_added_);
 574
 575   const BookmarkNode* folder = AddFolder();
 576   EXPECT_EQ(2, added_calls_);
 577   EXPECT_EQ(folder, last_added_);
 578 }
 579
 580 TEST_F(EnhancedBookmarkModelTest, ObserverNodeRemovedEvent) {
 581   const BookmarkNode* node = AddBookmark();
 582   const BookmarkNode* folder = AddFolder();
 583
 584   EXPECT_EQ(0, removed_calls_);
 585   bookmark_model_->Remove(node->parent(), node->parent()->GetIndexOf(node));
 586   EXPECT_EQ(1, removed_calls_);
 587   EXPECT_EQ(node, last_removed_);
 588
 589   bookmark_model_->Remove(folder->parent(),
 590                           folder->parent()->GetIndexOf(folder));
 591   EXPECT_EQ(2, removed_calls_);
 592   EXPECT_EQ(folder, last_removed_);
 593 }
 594
 595 TEST_F(EnhancedBookmarkModelTest, ObserverAllUserNodesRemovedEvent) {
 596   AddBookmark();
 597   AddFolder();
 598   EXPECT_EQ(0, all_user_nodes_removed_calls_);
 599   bookmark_model_->RemoveAllUserBookmarks();
 600   EXPECT_EQ(0, removed_calls_);
 601   EXPECT_EQ(1, all_user_nodes_removed_calls_);
 602 }
 603
 604 TEST_F(EnhancedBookmarkModelTest, ObserverRemoteIdChangedEvent) {
 605   const BookmarkNode* node1 = AddFolder();
 606   const BookmarkNode* node2 = AddFolder();
 607
 608   EXPECT_EQ(0, remote_id_changed_calls_);
 609   bookmark_model_->SetNodeMetaInfo(node1, "stars.id", "c_1");
 610   base::RunLoop().RunUntilIdle();
 611   EXPECT_EQ(1, remote_id_changed_calls_);
 612   EXPECT_EQ(node1, last_remote_id_node_);
 613   EXPECT_EQ("", last_old_remote_id_);
 614   EXPECT_EQ("c_1", last_remote_id_);
 615
 616   bookmark_model_->SetNodeMetaInfo(node2, "stars.id", "c_2");
 617   base::RunLoop().RunUntilIdle();
 618   EXPECT_EQ(2, remote_id_changed_calls_);
 619   EXPECT_EQ(node2, last_remote_id_node_);
 620   EXPECT_EQ("", last_old_remote_id_);
 621   EXPECT_EQ("c_2", last_remote_id_);
 622
 623   bookmark_model_->SetNodeMetaInfo(node1, "stars.id", "c_3");
 624   base::RunLoop().RunUntilIdle();
 625   EXPECT_EQ(3, remote_id_changed_calls_);
 626   EXPECT_EQ(node1, last_remote_id_node_);
 627   EXPECT_EQ("c_1", last_old_remote_id_);
 628   EXPECT_EQ("c_3", last_remote_id_);
 629
 630   // Set to duplicate ids.
 631   bookmark_model_->SetNodeMetaInfo(node2, "stars.id", "c_3");
 632   EXPECT_EQ(4, remote_id_changed_calls_);
 633   EXPECT_EQ(node2, last_remote_id_node_);
 634   EXPECT_EQ("c_2", last_old_remote_id_);
 635   EXPECT_EQ("c_3", last_remote_id_);
 636   base::RunLoop().RunUntilIdle();
 637   EXPECT_EQ(6, remote_id_changed_calls_);
 638   EXPECT_EQ("", last_remote_id_);
 639 }
 640
 641 TEST_F(EnhancedBookmarkModelTest, ShutDownWhileResetDuplicationScheduled) {
 642   const BookmarkNode* node1 = AddBookmark();
 643   const BookmarkNode* node2 = AddBookmark();
 644   bookmark_model_->SetNodeMetaInfo(node1, "stars.id", "c_1");
 645   bookmark_model_->SetNodeMetaInfo(node2, "stars.id", "c_1");
 646   model_->Shutdown();
 647   model_.reset();
 648   base::RunLoop().RunUntilIdle();
 649 }
 650
 651 TEST_F(EnhancedBookmarkModelTest, NodeRemovedWhileResetDuplicationScheduled) {
 652   const BookmarkNode* node1 = AddBookmark();
 653   const BookmarkNode* node2 = AddBookmark();
 654   bookmark_model_->SetNodeMetaInfo(node1, "stars.id", "c_1");
 655   bookmark_model_->SetNodeMetaInfo(node2, "stars.id", "c_1");
 656   bookmark_model_->Remove(node1->parent(), node1->parent()->GetIndexOf(node1));
 657   base::RunLoop().RunUntilIdle();
 658 }
 659
 660 // Verifies that the NEEDS_OFFLINE_PROCESSING flag is set for nodes added
 661 // with no remote id.
 662 TEST_F(EnhancedBookmarkModelTest, BookmarkAddedSetsOfflineProcessingFlag) {
 663   const BookmarkNode* node =
 664       bookmark_model_->AddURL(bookmark_model_->other_node(),
 665                               0,
 666                               base::ASCIIToUTF16("Some title"),
 667                               GURL(BOOKMARK_URL));
 668   std::string flags_str;
 669   EXPECT_FALSE(node->GetMetaInfo("stars.flags", &flags_str));
 670   base::RunLoop().RunUntilIdle();
 671   ASSERT_TRUE(node->GetMetaInfo("stars.flags", &flags_str));
 672   int flags;
 673   ASSERT_TRUE(base::StringToInt(flags_str, &flags));
 674   EXPECT_EQ(1, (flags & 1));
 675 }
 676
 677 // Verifies that the NEEDS_OFFLINE_PROCESSING_FLAG is not set for added folders.
 678 TEST_F(EnhancedBookmarkModelTest, FolderAddedDoesNotSetOfflineProcessingFlag) {
 679   const BookmarkNode* node = AddFolder();
 680   base::RunLoop().RunUntilIdle();
 681
 682   std::string flags_str;
 683   if (node->GetMetaInfo("stars.flags", &flags_str)) {
 684     int flags;
 685     ASSERT_TRUE(base::StringToInt(flags_str, &flags));
 686     EXPECT_EQ(0, (flags & 1));
 687   }
 688 }
 689
 690 // Verifies that when a bookmark is added that has a remote id, the status of
 691 // the NEEDS_OFFLINE_PROCESSING flag doesn't change.
 692 TEST_F(EnhancedBookmarkModelTest,
 693        BookmarkAddedWithIdKeepsOfflineProcessingFlag) {
 694   BookmarkNode::MetaInfoMap meta_info;
 695   meta_info["stars.id"] = "some_id";
 696   meta_info["stars.flags"] = "1";
 697
 698   const BookmarkNode* node1 =
 699       bookmark_model_->AddURLWithCreationTimeAndMetaInfo(
 700           bookmark_model_->other_node(),
 701           0,
 702           base::ASCIIToUTF16("Some title"),
 703           GURL(BOOKMARK_URL),
 704           base::Time::Now(),
 705           &meta_info);
 706   base::RunLoop().RunUntilIdle();
 707   std::string flags_str;
 708   ASSERT_TRUE(node1->GetMetaInfo("stars.flags", &flags_str));
 709   int flags;
 710   ASSERT_TRUE(base::StringToInt(flags_str, &flags));
 711   EXPECT_EQ(1, (flags & 1));
 712
 713   meta_info["stars.flags"] = "0";
 714   const BookmarkNode* node2 =
 715       bookmark_model_->AddURLWithCreationTimeAndMetaInfo(
 716           bookmark_model_->other_node(),
 717           0,
 718           base::ASCIIToUTF16("Some title"),
 719           GURL(BOOKMARK_URL),
 720           base::Time::Now(),
 721           &meta_info);
 722   base::RunLoop().RunUntilIdle();
 723   ASSERT_TRUE(node2->GetMetaInfo("stars.flags", &flags_str));
 724   ASSERT_TRUE(base::StringToInt(flags_str, &flags));
 725   EXPECT_EQ(0, (flags & 1));
 726 }
 727
 728 TEST_F(EnhancedBookmarkModelTest,
 729        NodeRemovedWhileSetNeedsOfflineProcessingIsScheduled) {
 730   const BookmarkNode* node =
 731       bookmark_model_->AddURL(bookmark_model_->other_node(),
 732                               0,
 733                               base::ASCIIToUTF16("Some title"),
 734                               GURL(BOOKMARK_URL));
 735   bookmark_model_->Remove(node->parent(), node->parent()->GetIndexOf(node));
 736   base::RunLoop().RunUntilIdle();
 737 }