Reduce the memory usage of bookmarks storage

components/bookmarks/browser/bookmark_codec_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_codec.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 171 matching lines @@
   }
 
   BookmarkModel* DecodeHelper(const base::Value& value,
                               const std::string& expected_stored_checksum,
                               std::string* computed_checksum,
                               bool expected_changes) {
     BookmarkCodec decoder;
     // Computed and stored checksums should be empty.
     EXPECT_EQ("", decoder.computed_checksum());
     EXPECT_EQ("", decoder.stored_checksum());
+    return DecodeHelper(&decoder, value, expected_stored_checksum,
+                        computed_checksum, expected_changes);
+  }
 
+  BookmarkModel* DecodeHelper(BookmarkCodec* decoder,
+                              const base::Value& value,
+                              const std::string& expected_stored_checksum,
+                              std::string* computed_checksum,
+                              bool expected_changes) {
     std::unique_ptr<BookmarkModel> model(TestBookmarkClient::CreateModel());
-    EXPECT_TRUE(Decode(&decoder, model.get(), value));
+    EXPECT_TRUE(Decode(decoder, model.get(), value));
 
-    *computed_checksum = decoder.computed_checksum();
-    const std::string& stored_checksum = decoder.stored_checksum();
+    *computed_checksum = decoder->computed_checksum();
+    const std::string& stored_checksum = decoder->stored_checksum();
 
     // Computed and stored checksums should not be empty.
     EXPECT_FALSE(computed_checksum->empty());
     EXPECT_FALSE(stored_checksum.empty());
 
     // Stored checksum should be as expected.
     EXPECT_EQ(expected_stored_checksum, stored_checksum);
 
     // The two checksums should be equal if expected_changes is true; otherwise
     // they should be different.
@@ skipping 212 matching lines @@
   EXPECT_EQ("value1", meta_value);
   EXPECT_FALSE(model->root_node()->GetMetaInfo("other_key", &meta_value));
   const BookmarkNode* bbn = model->bookmark_bar_node();
   ASSERT_EQ(1, bbn->child_count());
   const BookmarkNode* child = bbn->GetChild(0);
   EXPECT_TRUE(child->GetMetaInfo("node_info", &meta_value));
   EXPECT_EQ("value2", meta_value);
   EXPECT_FALSE(child->GetMetaInfo("other_key", &meta_value));
 }
 
+TEST_F(BookmarkCodecTest, ExcludeMetaKeysOnDecode) {
+  // Add meta info and encode.
+  std::unique_ptr<BookmarkModel> model(CreateTestModel1());
+  model->SetNodeMetaInfo(model->root_node(), "model_info", "value1");
+  model->SetNodeMetaInfo(model->root_node(), "excluded", "value1");
+  model->SetNodeMetaInfo(model->bookmark_bar_node()->GetChild(0),
+                         "not_included", "value2");
+  model->SetNodeMetaInfo(model->bookmark_bar_node()->GetChild(0), "node_info",
+                         "value2");
+  std::string checksum;
+  std::unique_ptr<base::Value> value(EncodeHelper(model.get(), &checksum));
+  ASSERT_TRUE(value.get() != NULL);
+
+  BookmarkCodec decoder;
+  const char* const kExcludedList[] = {"excluded", "not_included"};
+  std::vector<std::string> list(std::begin(kExcludedList),
+                                std::end(kExcludedList));
+  decoder.set_excluded_meta_info_keys(list);
+
+  // Decode and check for meta info with exclusion.
+  model.reset(DecodeHelper(&decoder, *value, checksum, &checksum, false));
+
+  std::string meta_value;
+  EXPECT_TRUE(model->root_node()->GetMetaInfo("model_info", &meta_value));
+  EXPECT_EQ("value1", meta_value);
+  EXPECT_FALSE(model->root_node()->GetMetaInfo("excluded", &meta_value));
+  const BookmarkNode* bbn = model->bookmark_bar_node();
+  ASSERT_EQ(1, bbn->child_count());
+  const BookmarkNode* child = bbn->GetChild(0);
+  EXPECT_TRUE(child->GetMetaInfo("node_info", &meta_value));
+  EXPECT_EQ("value2", meta_value);
+  EXPECT_FALSE(child->GetMetaInfo("not_included", &meta_value));
+}
+
 TEST_F(BookmarkCodecTest, EncodeAndDecodeSyncTransactionVersion) {
   // Add sync transaction version and encode.
   std::unique_ptr<BookmarkModel> model(CreateTestModel2());
   model->SetNodeSyncTransactionVersion(model->root_node(), 1);
   const BookmarkNode* bbn = model->bookmark_bar_node();
   model->SetNodeSyncTransactionVersion(bbn->GetChild(1), 42);
 
   std::string checksum;
   std::unique_ptr<base::Value> value(EncodeHelper(model.get(), &checksum));
   ASSERT_TRUE(value.get() != NULL);
@@ skipping 37 matching lines @@
       bbn->GetChild(1)->GetMetaInfo(kSyncTransactionVersionKey, &meta_value));
   EXPECT_TRUE(bbn->GetChild(0)->GetMetaInfo(kNormalKey, &meta_value));
   EXPECT_EQ("value", meta_value);
   EXPECT_TRUE(bbn->GetChild(1)->GetMetaInfo(kNormalKey, &meta_value));
   EXPECT_EQ("value2", meta_value);
   EXPECT_TRUE(bbn->GetChild(0)->GetMetaInfo(kNestedKey, &meta_value));
   EXPECT_EQ("value3", meta_value);
 }
 
 }  // namespace bookmarks