Revert "Revert 84829 - Initial implementation of "Synced Bookmarks" folder."

chrome/browser/bookmarks/bookmark_codec_unittest.cc

 // Copyright (c) 2011 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 "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/bookmarks/bookmark_codec.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_model_test_utils.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
+#include "chrome/common/chrome_switches.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 const char kUrl1Title[] = "url1";
 const char kUrl1Url[] = "http://www.url1.com";
 const char kUrl2Title[] = "url2";
 const char kUrl2Url[] = "http://www.url2.com";
 const char kUrl3Title[] = "url3";
 const char kUrl3Url[] = "http://www.url3.com";
@@ skipping 81 matching lines @@
     EXPECT_EQ(computed_checksum, stored_checksum);
 
     *checksum = computed_checksum;
     return value.release();
   }
 
   bool Decode(BookmarkCodec* codec, BookmarkModel* model, const Value& value) {
     int64 max_id;
     bool result = codec->Decode(AsMutable(model->GetBookmarkBarNode()),
                                 AsMutable(model->other_node()),
+                                AsMutable(model->synced_node()),
                                 &max_id, value);
     model->set_next_node_id(max_id);
     return result;
   }
 
   BookmarkModel* DecodeHelper(const Value& value,
                               const std::string& expected_stored_checksum,
                               std::string* computed_checksum,
                               bool expected_changes) {
     BookmarkCodec decoder;
@@ skipping 30 matching lines @@
     EXPECT_TRUE(assigned_ids->find(node_id) == assigned_ids->end());
     assigned_ids->insert(node_id);
     for (int i = 0; i < node->child_count(); ++i)
       CheckIDs(node->GetChild(i), assigned_ids);
   }
 
   void ExpectIDsUnique(BookmarkModel* model) {
     std::set<int64> assigned_ids;
     CheckIDs(model->GetBookmarkBarNode(), &assigned_ids);
     CheckIDs(model->other_node(), &assigned_ids);
+    CheckIDs(model->synced_node(), &assigned_ids);
   }
 };
 
 TEST_F(BookmarkCodecTest, ChecksumEncodeDecodeTest) {
   scoped_ptr<BookmarkModel> model_to_encode(CreateTestModel1());
   std::string enc_checksum;
   scoped_ptr<Value> value(EncodeHelper(model_to_encode.get(), &enc_checksum));
 
   EXPECT_TRUE(value.get() != NULL);
 
@@ skipping 106 matching lines @@
   BookmarkCodec encoder2;
   scoped_ptr<Value> model_value2(encoder2.Encode(&decoded_model));
 
   BookmarkModel decoded_model2(NULL);
   BookmarkCodec decoder2;
   ASSERT_TRUE(Decode(&decoder2, &decoded_model2, *model_value2.get()));
   BookmarkModelTestUtils::AssertModelsEqual(&decoded_model,
                                             &decoded_model2,
                                             true);
 }
+
+TEST_F(BookmarkCodecTest, CanDecodeModelWithoutSyncedBookmarks) {

[sky, 2011/05/12 16:29:13]

I assume we aren't going to have the switch forever, at which point this test
won't really be testing what we want it to. Additionally this is testing with
the current encoder, when we really want the old one. So, instead of this, save
a file to disk created with the last version (no synced folder) and then have
the test read that back in and make sure its ok.

+  scoped_ptr<BookmarkModel> model_to_encode(CreateTestModel3());
+  BookmarkCodec encoder;
+  scoped_ptr<Value> model_value(encoder.Encode(model_to_encode.get()));
+
+  // New model will be created with synced bookmarks.
+  CommandLine::ForCurrentProcess()->AppendSwitch(
+      switches::kEnableSyncedBookmarksFolder);
+
+  BookmarkModel decoded_model(NULL);
+  BookmarkCodec decoder;
+  ASSERT_TRUE(Decode(&decoder, &decoded_model, *model_value.get()));
+  BookmarkModelTestUtils::AssertNodesEqual(
+      model_to_encode->GetBookmarkBarNode(),
+      decoded_model.GetBookmarkBarNode(),
+      false);
+  BookmarkModelTestUtils::AssertNodesEqual(model_to_encode->other_node(),
+                                           decoded_model.other_node(),
+                                           false);
+  // Note: Explicitly don't check synced_node since it's not present in the old
+  // model.
+}