BookmarkModel cleanup. synced_node is now mobile_node and I'm nuking

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/bind.h"
 #include "base/bind_helpers.h"
-#include "base/command_line.h"
 #include "base/memory/scoped_vector.h"
 #include "base/string_util.h"
 #include "build/build_config.h"
 #include "chrome/browser/bookmarks/bookmark_expanded_state_tracker.h"
 #include "chrome/browser/bookmarks/bookmark_index.h"
 #include "chrome/browser/bookmarks/bookmark_model_observer.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/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
-#include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/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 13 matching lines @@
 }
 
 BookmarkNode::BookmarkNode(int64 id, const GURL& url)
     : url_(url) {
   Initialize(id);
 }
 
 BookmarkNode::~BookmarkNode() {
 }
 
-bool BookmarkNode::IsVisible() const {
-  return true;
-}
-
 void BookmarkNode::Initialize(int64 id) {
   id_ = id;
   type_ = url_.is_empty() ? FOLDER : URL;
   date_added_ = Time::Now();
   is_favicon_loaded_ = false;
   favicon_load_handle_ = 0;
 }
 
 void BookmarkNode::InvalidateFavicon() {
   favicon_ = SkBitmap();
   is_favicon_loaded_ = false;
 }
 
-// BookmarkPermanentNode ------------------------------------------------------
-
-BookmarkPermanentNode::BookmarkPermanentNode(int64 id,
-                                             const GURL& url,
-                                             Profile* profile)
-    : BookmarkNode(id, url),
-      profile_(profile) {
-}
-
-BookmarkPermanentNode::~BookmarkPermanentNode() {
-}
-
-bool BookmarkPermanentNode::IsVisible() const {
-  // The synced bookmark folder is invisible if the flag isn't set and there are
-  // no bookmarks under it.
-  return type() != BookmarkNode::SYNCED ||
-         CommandLine::ForCurrentProcess()->HasSwitch(
-             switches::kEnableSyncedBookmarksFolder) ||
-         !empty();
-}
-
 // BookmarkModel --------------------------------------------------------------
 
 namespace {
 
 // Comparator used when sorting bookmarks. Folders are sorted first, then
 // bookmarks.
 class SortComparator : public std::binary_function<const BookmarkNode*,
                                                    const BookmarkNode*,
                                                    bool> {
  public:
@@ skipping 18 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),
+      mobile_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() {
@@ skipping 444 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();
+  mobile_node_ = details->release_mobile_folder_node();
   index_.reset(details->release_index());
 
   // WARNING: order is important here, various places assume the order is
   // constant.
   root_.Add(bookmark_bar_node_, 0);
   root_.Add(other_node_, 1);
-  root_.Add(synced_node_, 2);
+  root_.Add(mobile_node_, 2);
 
   {
     base::AutoLock url_lock(url_lock_);
     // Update nodes_ordered_by_url_set_ from the nodes.
     PopulateNodesByURL(&root_);
   }
 
   loaded_ = true;
 
   loaded_signal_.Signal();
@@ skipping 103 matching lines @@
                                  int index,
                                  bool allow_end) {
   return (parent && parent->is_folder() &&
           (index >= 0 && (index < parent->child_count() ||
                           (allow_end && index == parent->child_count()))));
 }
 
 BookmarkNode* BookmarkModel::CreatePermanentNode(BookmarkNode::Type type) {
   DCHECK(type == BookmarkNode::BOOKMARK_BAR ||
          type == BookmarkNode::OTHER_NODE ||
-         type == BookmarkNode::SYNCED);
-  BookmarkPermanentNode* node = new BookmarkPermanentNode(
-      generate_next_node_id(), GURL(), profile_);
+         type == BookmarkNode::MOBILE);
+  BookmarkNode* node = new BookmarkNode(generate_next_node_id(), GURL());
   node->set_type(type);
   if (type == BookmarkNode::BOOKMARK_BAR) {
     node->set_title(l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_FOLDER_NAME));
   } else if (type == BookmarkNode::OTHER_NODE) {
     node->set_title(
         l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_OTHER_FOLDER_NAME));
   } else {
     node->set_title(
-        l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_SYNCED_FOLDER_NAME));
+        l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_MOBILE_FOLDER_NAME));
   }
   return node;
 }
 
 void BookmarkModel::OnFaviconDataAvailable(
     FaviconService::Handle handle,
     history::FaviconData favicon) {
   SkBitmap favicon_bitmap;
   BookmarkNode* node =
       load_consumer_.GetClientData(
@@ skipping 78 matching lines @@
     PopulateNodesByURL(node->GetChild(i));
 }
 
 int64 BookmarkModel::generate_next_node_id() {
   return next_node_id_++;
 }
 
 BookmarkLoadDetails* BookmarkModel::CreateLoadDetails() {
   BookmarkNode* bb_node = CreatePermanentNode(BookmarkNode::BOOKMARK_BAR);
   BookmarkNode* other_node = CreatePermanentNode(BookmarkNode::OTHER_NODE);
-  BookmarkNode* synced_node = CreatePermanentNode(BookmarkNode::SYNCED);
-  return new BookmarkLoadDetails(bb_node, other_node, synced_node,
+  BookmarkNode* mobile_node = CreatePermanentNode(BookmarkNode::MOBILE);
+  return new BookmarkLoadDetails(bb_node, other_node, mobile_node,
                                  new BookmarkIndex(profile_), next_node_id_);
 }