Reduce the memory usage of bookmarks storage

components/bookmarks/browser/bookmark_storage.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_storage.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <utility>
 
@@ skipping 35 matching lines @@
     if (node->url().is_valid())
       details->index()->Add(node);
   } else {
     for (int i = 0; i < node->child_count(); ++i)
       AddBookmarksToIndex(details, node->GetChild(i));
   }
 }
 
 void LoadCallback(const base::FilePath& path,
                   const base::WeakPtr<BookmarkStorage>& storage,
+                  const std::vector<std::string>& excluded_meta_keys,
                   std::unique_ptr<BookmarkLoadDetails> details,
                   base::SequencedTaskRunner* task_runner) {
   bool load_index = false;
   bool bookmark_file_exists = base::PathExists(path);
   if (bookmark_file_exists) {
     // Titles may end up containing invalid utf and we shouldn't throw away
     // all bookmarks if some titles have invalid utf.
     JSONFileValueDeserializer deserializer(
         path, base::JSON_REPLACE_INVALID_CHARACTERS);
     std::unique_ptr<base::Value> root = deserializer.Deserialize(NULL, NULL);
 
     if (root.get()) {
       // Building the index can take a while, so we do it on the background
       // thread.
       int64_t max_node_id = 0;
       BookmarkCodec codec;
+      codec.set_excluded_meta_info_keys(excluded_meta_keys);
+
       TimeTicks start_time = TimeTicks::Now();
       codec.Decode(details->bb_node(), details->other_folder_node(),
                    details->mobile_folder_node(), &max_node_id, *root.get());
       details->set_max_id(std::max(max_node_id, details->max_id()));
       details->set_computed_checksum(codec.computed_checksum());
       details->set_stored_checksum(codec.stored_checksum());
       details->set_ids_reassigned(codec.ids_reassigned());
       details->set_model_meta_info_map(codec.model_meta_info_map());
       details->set_model_sync_transaction_version(
           codec.model_sync_transaction_version());
@@ skipping 80 matching lines @@
   if (writer_.HasPendingWrite())
     writer_.DoScheduledWrite();
 }
 
 void BookmarkStorage::LoadBookmarks(
     std::unique_ptr<BookmarkLoadDetails> details,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
   sequenced_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&LoadCallback, writer_.path(), weak_factory_.GetWeakPtr(),
-                 base::Passed(&details), base::RetainedRef(task_runner)));
+                 model_->client()->ExecludedMetaKeys(), base::Passed(&details),
+                 base::RetainedRef(task_runner)));
 }
 
 void BookmarkStorage::ScheduleSave() {
   switch (backup_state_) {
     case BACKUP_NONE:
       backup_state_ = BACKUP_DISPATCHED;
       sequenced_task_runner_->PostTaskAndReply(
           FROM_HERE, base::Bind(&BackupCallback, writer_.path()),
           base::Bind(&BookmarkStorage::OnBackupFinished,
                      weak_factory_.GetWeakPtr()));
@@ skipping 46 matching lines @@
   }
 
   std::unique_ptr<std::string> data(new std::string);
   if (!SerializeData(data.get()))
     return false;
   writer_.WriteNow(std::move(data));
   return true;
 }
 
 }  // namespace bookmarks