chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.h"
   6
   7 #include <math.h>  // For floor()
   8 #include <vector>
   9
  10 #include "base/strings/string_number_conversions.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "chrome/browser/bookmarks/chrome_bookmark_client.h"
  13 #include "chrome/browser/extensions/api/bookmarks/bookmark_api_constants.h"
  14 #include "chrome/common/extensions/api/bookmarks.h"
  15 #include "components/bookmarks/browser/bookmark_model.h"
  16 #include "components/bookmarks/browser/bookmark_utils.h"
  17
  18 using bookmarks::BookmarkModel;
  19 using bookmarks::BookmarkNode;
  20
  21 namespace extensions {
  22
  23 namespace keys = bookmark_api_constants;
  24 using api::bookmarks::BookmarkTreeNode;
  25
  26 namespace bookmark_api_helpers {
  27
  28 namespace {
  29
  30 void AddNodeHelper(ChromeBookmarkClient* client,
  31                    const BookmarkNode* node,
  32                    std::vector<linked_ptr<BookmarkTreeNode> >* nodes,
  33                    bool recurse,
  34                    bool only_folders) {
  35   if (node->IsVisible()) {
  36     linked_ptr<BookmarkTreeNode> new_node(GetBookmarkTreeNode(client,
  37                                                               node,
  38                                                               recurse,
  39                                                               only_folders));
  40     nodes->push_back(new_node);
  41   }
  42 }
  43
  44 }  // namespace
  45
  46 BookmarkTreeNode* GetBookmarkTreeNode(ChromeBookmarkClient* client,
  47                                       const BookmarkNode* node,
  48                                       bool recurse,
  49                                       bool only_folders) {
  50   BookmarkTreeNode* bookmark_tree_node = new BookmarkTreeNode;
  51
  52   bookmark_tree_node->id = base::Int64ToString(node->id());
  53
  54   const BookmarkNode* parent = node->parent();
  55   if (parent) {
  56     bookmark_tree_node->parent_id.reset(new std::string(
  57         base::Int64ToString(parent->id())));
  58     bookmark_tree_node->index.reset(new int(parent->GetIndexOf(node)));
  59   }
  60
  61   if (!node->is_folder()) {
  62     bookmark_tree_node->url.reset(new std::string(node->url().spec()));
  63   } else {
  64     // Javascript Date wants milliseconds since the epoch, ToDoubleT is seconds.
  65     base::Time t = node->date_folder_modified();
  66     if (!t.is_null()) {
  67       bookmark_tree_node->date_group_modified.reset(
  68           new double(floor(t.ToDoubleT() * 1000)));
  69     }
  70   }
  71
  72   bookmark_tree_node->title = base::UTF16ToUTF8(node->GetTitle());
  73   if (!node->date_added().is_null()) {
  74     // Javascript Date wants milliseconds since the epoch, ToDoubleT is seconds.
  75     bookmark_tree_node->date_added.reset(
  76         new double(floor(node->date_added().ToDoubleT() * 1000)));
  77   }
  78
  79   if (bookmarks::IsDescendantOf(node, client->managed_node()) ||
  80       bookmarks::IsDescendantOf(node, client->supervised_node())) {
  81     bookmark_tree_node->unmodifiable =
  82         api::bookmarks::BOOKMARK_TREE_NODE_UNMODIFIABLE_MANAGED;
  83   }
  84
  85   if (recurse && node->is_folder()) {
  86     std::vector<linked_ptr<BookmarkTreeNode> > children;
  87     for (int i = 0; i < node->child_count(); ++i) {
  88       const BookmarkNode* child = node->GetChild(i);
  89       if (child->IsVisible() && (!only_folders || child->is_folder())) {
  90         linked_ptr<BookmarkTreeNode> child_node(
  91             GetBookmarkTreeNode(client, child, true, only_folders));
  92         children.push_back(child_node);
  93       }
  94     }
  95     bookmark_tree_node->children.reset(
  96         new std::vector<linked_ptr<BookmarkTreeNode> >(children));
  97   }
  98   return bookmark_tree_node;
  99 }
 100
 101 void AddNode(ChromeBookmarkClient* client,
 102              const BookmarkNode* node,
 103              std::vector<linked_ptr<BookmarkTreeNode> >* nodes,
 104              bool recurse) {
 105   return AddNodeHelper(client, node, nodes, recurse, false);
 106 }
 107
 108 void AddNodeFoldersOnly(ChromeBookmarkClient* client,
 109                         const BookmarkNode* node,
 110                         std::vector<linked_ptr<BookmarkTreeNode> >* nodes,
 111                         bool recurse) {
 112   return AddNodeHelper(client, node, nodes, recurse, true);
 113 }
 114
 115 bool RemoveNode(BookmarkModel* model,
 116                 ChromeBookmarkClient* client,
 117                 int64 id,
 118                 bool recursive,
 119                 std::string* error) {
 120   const BookmarkNode* node = bookmarks::GetBookmarkNodeByID(model, id);
 121   if (!node) {
 122     *error = keys::kNoNodeError;
 123     return false;
 124   }
 125   if (model->is_permanent_node(node)) {
 126     *error = keys::kModifySpecialError;
 127     return false;
 128   }
 129   if (bookmarks::IsDescendantOf(node, client->managed_node()) ||
 130       bookmarks::IsDescendantOf(node, client->supervised_node())) {
 131     *error = keys::kModifyManagedError;
 132     return false;
 133   }
 134   if (node->is_folder() && !node->empty() && !recursive) {
 135     *error = keys::kFolderNotEmptyError;
 136     return false;
 137   }
 138
 139   const BookmarkNode* parent = node->parent();
 140   model->Remove(parent, parent->GetIndexOf(node));
 141   return true;
 142 }
 143
 144 void GetMetaInfo(const BookmarkNode& node,
 145                  base::DictionaryValue* id_to_meta_info_map) {
 146   if (!node.IsVisible())
 147     return;
 148
 149   const BookmarkNode::MetaInfoMap* meta_info = node.GetMetaInfoMap();
 150   base::DictionaryValue* value = new base::DictionaryValue();
 151   if (meta_info) {
 152     BookmarkNode::MetaInfoMap::const_iterator itr;
 153     for (itr = meta_info->begin(); itr != meta_info->end(); ++itr) {
 154       value->SetStringWithoutPathExpansion(itr->first, itr->second);
 155     }
 156   }
 157   id_to_meta_info_map->Set(base::Int64ToString(node.id()), value);
 158
 159   if (node.is_folder()) {
 160     for (int i = 0; i < node.child_count(); ++i) {
 161       GetMetaInfo(*(node.GetChild(i)), id_to_meta_info_map);
 162     }
 163   }
 164 }
 165
 166 }  // namespace bookmark_api_helpers
 167 }  // namespace extensions