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

chrome/browser/bookmarks/bookmark_model.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 "chrome/browser/bookmarks/bookmark_model.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/callback.h"
+#include "base/command_line.h"
 #include "base/memory/scoped_vector.h"
 #include "build/build_config.h"
 #include "chrome/browser/bookmarks/bookmark_index.h"
 #include "chrome/browser/bookmarks/bookmark_storage.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/history/history_notifications.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/common/chrome_switches.h"
 #include "content/common/notification_service.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/l10n_util_collator.h"
 #include "ui/gfx/codec/png_codec.h"
 
 using base::Time;
 
 namespace {
 
@@ skipping 39 matching lines @@
   switch (entry.type) {
     case history::StarredEntry::URL:
       type_ = BookmarkNode::URL;
       break;
     case history::StarredEntry::USER_FOLDER:
       type_ = BookmarkNode::FOLDER;
       break;
     case history::StarredEntry::BOOKMARK_BAR:
       type_ = BookmarkNode::BOOKMARK_BAR;
       break;
+    case history::StarredEntry::SYNCED:
+        type_ = BookmarkNode::SYNCED;
+        break;
     case history::StarredEntry::OTHER:
       type_ = BookmarkNode::OTHER_NODE;
       break;
     default:
       NOTREACHED();
   }
   date_added_ = entry.date_added;
   date_folder_modified_ = entry.date_folder_modified;
   set_title(entry.title);
 }
@@ skipping 29 matching lines @@
 
 }  // namespace
 
 BookmarkModel::BookmarkModel(Profile* profile)
     : profile_(profile),
       loaded_(false),
       file_changed_(false),
       root_(GURL()),
       bookmark_bar_node_(NULL),
       other_node_(NULL),
+      synced_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());
   }
 }
 
 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();
   }
+  // If the switch wasn't set, then synced_node_ hasn't been added to the model
+  // and we must delete it.
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableSyncedBookmarksFolder)) {
+    delete synced_node_;
+  }
 }
 
 void BookmarkModel::Load() {
   if (store_.get()) {
     // If the store is non-null, it means Load was already invoked. Load should
     // only be invoked once.
     NOTREACHED();
     return;
   }
 
@@ skipping 97 matching lines @@
 }
 
 void BookmarkModel::SetTitle(const BookmarkNode* node, const string16& title) {
   if (!node) {
     NOTREACHED();
     return;
   }
   if (node->GetTitle() == title)
     return;
 
-  if (node == bookmark_bar_node_ || node == other_node_) {
+  if (node == bookmark_bar_node_ || node == other_node_ ||
+      node == synced_node_) {
     NOTREACHED();
     return;
   }
 
   // The title index doesn't support changing the title, instead we remove then
   // add it back.
   index_->Remove(node);
   AsMutable(node)->set_title(title);
   index_->Add(node);
 
@@ skipping 288 matching lines @@
       details->ids_reassigned()) {
     // If bookmarks file changed externally, the IDs may have changed
     // externally. In that case, the decoder may have reassigned IDs to make
     // them unique. So when the file has changed externally, we should save the
     // bookmarks file to persist new IDs.
     if (store_.get())
       store_->ScheduleSave();
   }
   bookmark_bar_node_ = details->release_bb_node();
   other_node_ = details->release_other_folder_node();
+  synced_node_ = details->release_synced_folder_node();
   index_.reset(details->release_index());
 
   // WARNING: order is important here, various places assume bookmark bar then
   // other node.
   root_.Add(bookmark_bar_node_, 0);
   root_.Add(other_node_, 1);
+  // TODO(yfriedman): If this switch is removed, update the desctructor to avoid
+  // double-delete of synced_node_;
+
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableSyncedBookmarksFolder)) {
+    root_.Add(synced_node_, 2);

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

How come we don't always add the node to the model?

[Yaron, 2011/05/12 18:19:23]

Because that caused it to show in the UI. Perhaps I should just guard it at the
higher layer?

+  }
 
   {
     base::AutoLock url_lock(url_lock_);
     // Update nodes_ordered_by_url_set_ from the nodes.
     PopulateNodesByURL(&root_);
   }
 
   loaded_ = true;
 
   loaded_signal_.Signal();
@@ skipping 125 matching lines @@
   entry.type = history::StarredEntry::BOOKMARK_BAR;
   return CreateRootNodeFromStarredEntry(entry);
 }
 
 BookmarkNode* BookmarkModel::CreateOtherBookmarksNode() {
   history::StarredEntry entry;
   entry.type = history::StarredEntry::OTHER;
   return CreateRootNodeFromStarredEntry(entry);
 }
 
+BookmarkNode* BookmarkModel::CreateSyncedBookmarksNode() {
+  history::StarredEntry entry;
+  entry.type = history::StarredEntry::SYNCED;
+  return CreateRootNodeFromStarredEntry(entry);
+}
+
 BookmarkNode* BookmarkModel::CreateRootNodeFromStarredEntry(
     const history::StarredEntry& entry) {
   DCHECK(entry.type == history::StarredEntry::BOOKMARK_BAR ||
-         entry.type == history::StarredEntry::OTHER);
+         entry.type == history::StarredEntry::OTHER ||
+         entry.type == history::StarredEntry::SYNCED);
   BookmarkNode* node = new BookmarkNode(generate_next_node_id(), GURL());
   node->Reset(entry);
   if (entry.type == history::StarredEntry::BOOKMARK_BAR) {
     node->set_title(l10n_util::GetStringUTF16(IDS_BOOMARK_BAR_FOLDER_NAME));
+  } else if (entry.type == history::StarredEntry::SYNCED) {
+    node->set_title(l10n_util::GetStringUTF16(
+        IDS_BOOMARK_BAR_SYNCED_FOLDER_NAME));
   } else {
     node->set_title(
         l10n_util::GetStringUTF16(IDS_BOOMARK_BAR_OTHER_FOLDER_NAME));
   }
   return node;
 }
 
 void BookmarkModel::OnFaviconDataAvailable(
     FaviconService::Handle handle,
     history::FaviconData favicon) {
@@ skipping 79 matching lines @@
   return next_node_id_++;
 }
 
 void BookmarkModel::SetFileChanged() {
   file_changed_ = true;
 }
 
 BookmarkLoadDetails* BookmarkModel::CreateLoadDetails() {
   BookmarkNode* bb_node = CreateBookmarkNode();
   BookmarkNode* other_folder_node = CreateOtherBookmarksNode();
+  BookmarkNode* synced_folder_node = CreateSyncedBookmarksNode();
   return new BookmarkLoadDetails(
-      bb_node, other_folder_node, new BookmarkIndex(profile()), next_node_id_);
+      bb_node, other_folder_node, synced_folder_node,
+      new BookmarkIndex(profile()), next_node_id_);
 }