Add a preference to enable/disable ID persistence in bookmark model and...

chrome/browser/bookmarks/bookmark_model.cc

 // Copyright (c) 2006-2008 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 "chrome/browser/bookmarks/bookmark_model.h"
 
 #include "app/l10n_util.h"
 #include "base/gfx/png_decoder.h"
 #include "base/scoped_vector.h"
 #include "build/build_config.h"
 #include "chrome/browser/bookmarks/bookmark_index.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/browser/bookmarks/bookmark_storage.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profile.h"
 #include "chrome/common/notification_service.h"
+#include "chrome/common/pref_service.h"
 #include "grit/generated_resources.h"
 
 using base::Time;
 
 // BookmarkNode ---------------------------------------------------------------
 
 BookmarkNode::BookmarkNode(const GURL& url)
     : url_(url) {
   Initialize(0);
 }
@@ skipping 20 matching lines @@
   type_ = entry.type;
   date_added_ = entry.date_added;
   date_group_modified_ = entry.date_group_modified;
   SetTitle(entry.title);
 }
 
 // BookmarkModel --------------------------------------------------------------
 
 namespace {
 
+// Constant for persist IDs prefernece.
+const wchar_t kPrefPersistIDs[] = L"bookmarks.persist_ids";
+
 // Comparator used when sorting bookmarks. Folders are sorted first, then
   // bookmarks.
 class SortComparator : public std::binary_function<BookmarkNode*,
                                                    BookmarkNode*,
                                                    bool> {
  public:
   explicit SortComparator(Collator* collator) : collator_(collator) { }
 
   // Returns true if lhs preceeds rhs.
   bool operator() (BookmarkNode* n1, BookmarkNode* n2) {
@@ skipping 10 matching lines @@
 
  private:
   Collator* collator_;
 };
 
 }  // namespace
 
 BookmarkModel::BookmarkModel(Profile* profile)
     : profile_(profile),
       loaded_(false),
+      persist_ids_(false),
       root_(GURL()),
       bookmark_bar_node_(NULL),
       other_node_(NULL),
       next_node_id_(1),
       observers_(ObserverList<BookmarkModelObserver>::NOTIFY_EXISTING_ONLY),
       loaded_signal_(TRUE, FALSE) {
   if (!profile_) {
     // Profile is null during testing.
     DoneLoading(CreateLoadDetails());
   }
+  RegisterPreferences();
+  LoadPreferences();
 }
 
 BookmarkModel::~BookmarkModel() {
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     BookmarkModelBeingDeleted(this));
 
   if (store_) {
     // The store maintains a reference back to us. We need to tell it we're gone
     // so that it doesn't try and invoke a method back on us again.
     store_->BookmarkModelDeleted();
@@ skipping 263 matching lines @@
     return;
 
   index_->GetBookmarksWithTitlesMatching(text, max_count, matches);
 }
 
 void BookmarkModel::ClearStore() {
   registrar_.RemoveAll();
   store_ = NULL;
 }
 
+void BookmarkModel::SetPersistIDs(bool value) {
+  if (value == persist_ids_)
+    return;
+  persist_ids_ = value;
+  if (profile_) {
+    PrefService* pref_service = profile_->GetPrefs();
+    pref_service->SetBoolean(kPrefPersistIDs, persist_ids_);
+  }
+}
+
 bool BookmarkModel::IsBookmarkedNoLock(const GURL& url) {
   BookmarkNode tmp_node(url);
   return (nodes_ordered_by_url_set_.find(&tmp_node) !=
           nodes_ordered_by_url_set_.end());
 }
 
 void BookmarkModel::FavIconLoaded(BookmarkNode* node) {
   // Send out notification to the observer.
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     BookmarkNodeFavIconLoaded(this, node));
@@ skipping 292 matching lines @@
 int BookmarkModel::generate_next_node_id() {
   return next_node_id_++;
 }
 
 BookmarkStorage::LoadDetails* BookmarkModel::CreateLoadDetails() {
   BookmarkNode* bb_node = CreateBookmarkNode();
   BookmarkNode* other_folder_node = CreateOtherBookmarksNode();
   return new BookmarkStorage::LoadDetails(
       bb_node, other_folder_node, new BookmarkIndex(), next_node_id_);
 }
+
+void BookmarkModel::RegisterPreferences() {
+  if (!profile_)
+    return;
+  PrefService* pref_service = profile_->GetPrefs();
+  if (!pref_service->IsPrefRegistered(kPrefPersistIDs))
+    pref_service->RegisterBooleanPref(kPrefPersistIDs, false);
+}
+
+void BookmarkModel::LoadPreferences() {
+  if (!profile_)
+    return;
+  PrefService* pref_service = profile_->GetPrefs();
+  persist_ids_ = pref_service->GetBoolean(kPrefPersistIDs);
+}