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