Makes sync code persist the date the node was added. I'm hoping this covers

chrome/browser/sync/profile_sync_service_bookmark_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.
 
 // TODO(akalin): This file is basically just a unit test for
 // BookmarkChangeProcessor.  Write unit tests for
 // BookmarkModelAssociator separately.
 
 #include <stack>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
+#include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/base_bookmark_model_observer.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/sync/glue/bookmark_change_processor.h"
 #include "chrome/browser/sync/glue/bookmark_model_associator.h"
 #include "chrome/browser/sync/glue/data_type_error_handler.h"
 #include "chrome/browser/sync/glue/data_type_error_handler_mock.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/testing_profile.h"
@@ skipping 934 matching lines @@
   const wchar_t* title;
   const char* url;
 };
 
 // TODO(ncarter): Integrate the existing TestNode/PopulateNodeFromString code
 // in the bookmark model unittest, to make it simpler to set up test data
 // here (and reduce the amount of duplication among tests), and to reduce the
 // duplication.
 class ProfileSyncServiceBookmarkTestWithData
     : public ProfileSyncServiceBookmarkTest {
+ public:
+  ProfileSyncServiceBookmarkTestWithData();
+
  protected:
   // Populates or compares children of the given bookmark node from/with the
-  // given test data array with the given size.
+  // given test data array with the given size. |running_count| is updated as
+  // urls are added. It is used to set the creation date (or test the creation
+  // date for CompareWithTestData()).
   void PopulateFromTestData(const BookmarkNode* node,
                             const TestData* data,
-                            int size);
+                            int size,
+                            int* running_count);
   void CompareWithTestData(const BookmarkNode* node,
                            const TestData* data,
-                           int size);
+                           int size,
+                           int* running_count);
 
   void ExpectBookmarkModelMatchesTestData();
   void WriteTestDataToBookmarkModel();
+
+ private:
+  const base::Time start_time_;
+
+  DISALLOW_COPY_AND_ASSIGN(ProfileSyncServiceBookmarkTestWithData);
 };
 
 namespace {
 
 // Constants for bookmark model that looks like:
 // |-- Bookmark bar
 // |   |-- u2, http://www.u2.com/
 // |   |-- f1
 // |   |   |-- f1u4, http://www.f1u4.com/
 // |   |   |-- f1u2, http://www.f1u2.com/
@@ skipping 88 matching lines @@
   { L"f5u1", "http://www.f5u1.com/" },
   { L"f5u2", "http://www.f5u2.com/" },
 };
 static TestData kF6Children[] = {
   { L"f6u1", "http://www.f6u1.com/" },
   { L"f6u2", "http://www.f6u2.com/" },
 };
 
 }  // anonymous namespace.
 
+ProfileSyncServiceBookmarkTestWithData::
+ProfileSyncServiceBookmarkTestWithData()
+    : start_time_(base::Time::Now()) {
+}
+
 void ProfileSyncServiceBookmarkTestWithData::PopulateFromTestData(
-    const BookmarkNode* node, const TestData* data, int size) {
+    const BookmarkNode* node,
+    const TestData* data,
+    int size,
+    int* running_count) {
   DCHECK(node);
   DCHECK(data);
   DCHECK(node->is_folder());
   for (int i = 0; i < size; ++i) {
     const TestData& item = data[i];
     if (item.url) {
-      model_->AddURL(node, i, WideToUTF16Hack(item.title), GURL(item.url));
+      const base::Time add_time =
+          start_time_ + base::TimeDelta::FromMinutes(*running_count);
+      model_->AddURLWithCreationTime(node, i, WideToUTF16Hack(item.title),
+                                     GURL(item.url), add_time);
+      (*running_count)++;
     } else {
       model_->AddFolder(node, i, WideToUTF16Hack(item.title));
     }
   }
 }
 
 void ProfileSyncServiceBookmarkTestWithData::CompareWithTestData(
-    const BookmarkNode* node, const TestData* data, int size) {
+    const BookmarkNode* node,
+    const TestData* data,
+    int size,
+    int* running_count) {
   DCHECK(node);
   DCHECK(data);
   DCHECK(node->is_folder());
   ASSERT_EQ(size, node->child_count());
   for (int i = 0; i < size; ++i) {
     const BookmarkNode* child_node = node->GetChild(i);
     const TestData& item = data[i];
     GURL url = GURL(item.url == NULL ? "" : item.url);
     BookmarkNode test_node(url);
     test_node.SetTitle(WideToUTF16Hack(item.title));
     EXPECT_EQ(child_node->GetTitle(), test_node.GetTitle());
     if (item.url) {
       EXPECT_FALSE(child_node->is_folder());
       EXPECT_TRUE(child_node->is_url());
       EXPECT_EQ(child_node->url(), test_node.url());
+      const base::Time expected_time =
+          start_time_ + base::TimeDelta::FromMinutes(*running_count);
+      EXPECT_EQ(expected_time.ToInternalValue(),
+                child_node->date_added().ToInternalValue());
+      (*running_count)++;
     } else {
       EXPECT_TRUE(child_node->is_folder());
       EXPECT_FALSE(child_node->is_url());
     }
   }
 }
 
 // TODO(munjal): We should implement some way of generating random data and can
 // use the same seed to generate the same sequence.
 void ProfileSyncServiceBookmarkTestWithData::WriteTestDataToBookmarkModel() {
   const BookmarkNode* bookmarks_bar_node = model_->bookmark_bar_node();
+  int count = 0;
   PopulateFromTestData(bookmarks_bar_node,
                        kBookmarkBarChildren,
-                       arraysize(kBookmarkBarChildren));
+                       arraysize(kBookmarkBarChildren),
+                       &count);
 
   ASSERT_GE(bookmarks_bar_node->child_count(), 4);
   const BookmarkNode* f1_node = bookmarks_bar_node->GetChild(1);
-  PopulateFromTestData(f1_node, kF1Children, arraysize(kF1Children));
+  PopulateFromTestData(f1_node, kF1Children, arraysize(kF1Children), &count);
   const BookmarkNode* f2_node = bookmarks_bar_node->GetChild(3);
-  PopulateFromTestData(f2_node, kF2Children, arraysize(kF2Children));
+  PopulateFromTestData(f2_node, kF2Children, arraysize(kF2Children), &count);
 
   const BookmarkNode* other_bookmarks_node = model_->other_node();
   PopulateFromTestData(other_bookmarks_node,
                        kOtherBookmarkChildren,
-                       arraysize(kOtherBookmarkChildren));
+                       arraysize(kOtherBookmarkChildren),
+                       &count);
 
   ASSERT_GE(other_bookmarks_node->child_count(), 6);
   const BookmarkNode* f3_node = other_bookmarks_node->GetChild(0);
-  PopulateFromTestData(f3_node, kF3Children, arraysize(kF3Children));
+  PopulateFromTestData(f3_node, kF3Children, arraysize(kF3Children), &count);
   const BookmarkNode* f4_node = other_bookmarks_node->GetChild(3);
-  PopulateFromTestData(f4_node, kF4Children, arraysize(kF4Children));
+  PopulateFromTestData(f4_node, kF4Children, arraysize(kF4Children), &count);
   const BookmarkNode* dup_node = other_bookmarks_node->GetChild(4);
-  PopulateFromTestData(dup_node, kDup1Children, arraysize(kDup1Children));
+  PopulateFromTestData(dup_node, kDup1Children, arraysize(kDup1Children),
+                       &count);
   dup_node = other_bookmarks_node->GetChild(5);
-  PopulateFromTestData(dup_node, kDup2Children, arraysize(kDup2Children));
+  PopulateFromTestData(dup_node, kDup2Children, arraysize(kDup2Children),
+                       &count);
 
   const BookmarkNode* mobile_bookmarks_node = model_->mobile_node();
   PopulateFromTestData(mobile_bookmarks_node,
                        kMobileBookmarkChildren,
-                       arraysize(kMobileBookmarkChildren));
+                       arraysize(kMobileBookmarkChildren),
+                       &count);
 
   ASSERT_GE(mobile_bookmarks_node->child_count(), 3);
   const BookmarkNode* f5_node = mobile_bookmarks_node->GetChild(0);
-  PopulateFromTestData(f5_node, kF5Children, arraysize(kF5Children));
+  PopulateFromTestData(f5_node, kF5Children, arraysize(kF5Children), &count);
   const BookmarkNode* f6_node = mobile_bookmarks_node->GetChild(1);
-  PopulateFromTestData(f6_node, kF6Children, arraysize(kF6Children));
+  PopulateFromTestData(f6_node, kF6Children, arraysize(kF6Children), &count);
 
   ExpectBookmarkModelMatchesTestData();
 }
 
 void ProfileSyncServiceBookmarkTestWithData::
     ExpectBookmarkModelMatchesTestData() {
   const BookmarkNode* bookmark_bar_node = model_->bookmark_bar_node();
+  int count = 0;
   CompareWithTestData(bookmark_bar_node,
                       kBookmarkBarChildren,
-                      arraysize(kBookmarkBarChildren));
+                      arraysize(kBookmarkBarChildren),
+                      &count);
 
   ASSERT_GE(bookmark_bar_node->child_count(), 4);
   const BookmarkNode* f1_node = bookmark_bar_node->GetChild(1);
-  CompareWithTestData(f1_node, kF1Children, arraysize(kF1Children));
+  CompareWithTestData(f1_node, kF1Children, arraysize(kF1Children), &count);
   const BookmarkNode* f2_node = bookmark_bar_node->GetChild(3);
-  CompareWithTestData(f2_node, kF2Children, arraysize(kF2Children));
+  CompareWithTestData(f2_node, kF2Children, arraysize(kF2Children), &count);
 
   const BookmarkNode* other_bookmarks_node = model_->other_node();
   CompareWithTestData(other_bookmarks_node,
                       kOtherBookmarkChildren,
-                      arraysize(kOtherBookmarkChildren));
+                      arraysize(kOtherBookmarkChildren),
+                      &count);
 
   ASSERT_GE(other_bookmarks_node->child_count(), 6);
   const BookmarkNode* f3_node = other_bookmarks_node->GetChild(0);
-  CompareWithTestData(f3_node, kF3Children, arraysize(kF3Children));
+  CompareWithTestData(f3_node, kF3Children, arraysize(kF3Children), &count);
   const BookmarkNode* f4_node = other_bookmarks_node->GetChild(3);
-  CompareWithTestData(f4_node, kF4Children, arraysize(kF4Children));
+  CompareWithTestData(f4_node, kF4Children, arraysize(kF4Children), &count);
   const BookmarkNode* dup_node = other_bookmarks_node->GetChild(4);
-  CompareWithTestData(dup_node, kDup1Children, arraysize(kDup1Children));
+  CompareWithTestData(dup_node, kDup1Children, arraysize(kDup1Children),
+                      &count);
   dup_node = other_bookmarks_node->GetChild(5);
-  CompareWithTestData(dup_node, kDup2Children, arraysize(kDup2Children));
+  CompareWithTestData(dup_node, kDup2Children, arraysize(kDup2Children),
+                      &count);
 
   const BookmarkNode* mobile_bookmarks_node = model_->mobile_node();
   CompareWithTestData(mobile_bookmarks_node,
                       kMobileBookmarkChildren,
-                      arraysize(kMobileBookmarkChildren));
+                      arraysize(kMobileBookmarkChildren),
+                      &count);
 
   ASSERT_GE(mobile_bookmarks_node->child_count(), 3);
   const BookmarkNode* f5_node = mobile_bookmarks_node->GetChild(0);
-  CompareWithTestData(f5_node, kF5Children, arraysize(kF5Children));
+  CompareWithTestData(f5_node, kF5Children, arraysize(kF5Children), &count);
   const BookmarkNode* f6_node = mobile_bookmarks_node->GetChild(1);
-  CompareWithTestData(f6_node, kF6Children, arraysize(kF6Children));
+  CompareWithTestData(f6_node, kF6Children, arraysize(kF6Children), &count);
 
 }
 
 // Tests persistence of the profile sync service by unloading the
 // database and then reloading it from disk.
 TEST_F(ProfileSyncServiceBookmarkTestWithData, Persistence) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, SAVE_TO_STORAGE);
   StartSync();
 
   WriteTestDataToBookmarkModel();
@@ skipping 264 matching lines @@
   EXPECT_EQ(1, observer.get_started());
   EXPECT_EQ(0, observer.get_completed_count_at_started());
   EXPECT_EQ(1, observer.get_completed());
 
   model_->RemoveObserver(&observer);
 }
 
 }  // namespace
 
 }  // namespace browser_sync