src/chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_api.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/bookmark_manager_private/bookmark_manager_private_api.h"
   6
   7 #include <vector>
   8
   9 #include "base/lazy_instance.h"
  10 #include "base/memory/linked_ptr.h"
  11 #include "base/prefs/pref_service.h"
  12 #include "base/strings/string_number_conversions.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "base/values.h"
  15 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
  16 #include "chrome/browser/bookmarks/bookmark_stats.h"
  17 #include "chrome/browser/bookmarks/chrome_bookmark_client.h"
  18 #include "chrome/browser/extensions/api/bookmarks/bookmark_api_constants.h"
  19 #include "chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.h"
  20 #include "chrome/browser/extensions/extension_web_ui.h"
  21 #include "chrome/browser/profiles/profile.h"
  22 #include "chrome/browser/ui/bookmarks/bookmark_drag_drop.h"
  23 #include "chrome/browser/undo/bookmark_undo_service.h"
  24 #include "chrome/browser/undo/bookmark_undo_service_factory.h"
  25 #include "chrome/common/extensions/api/bookmark_manager_private.h"
  26 #include "chrome/common/pref_names.h"
  27 #include "chrome/grit/generated_resources.h"
  28 #include "components/bookmarks/browser/bookmark_model.h"
  29 #include "components/bookmarks/browser/bookmark_node_data.h"
  30 #include "components/bookmarks/browser/bookmark_utils.h"
  31 #include "components/bookmarks/browser/scoped_group_bookmark_actions.h"
  32 #include "components/user_prefs/user_prefs.h"
  33 #include "content/public/browser/render_view_host.h"
  34 #include "content/public/browser/web_contents.h"
  35 #include "content/public/browser/web_ui.h"
  36 #include "extensions/browser/extension_function_dispatcher.h"
  37 #include "extensions/browser/view_type_utils.h"
  38 #include "ui/base/dragdrop/drag_drop_types.h"
  39 #include "ui/base/l10n/l10n_util.h"
  40 #include "ui/base/webui/web_ui_util.h"
  41
  42 using bookmarks::BookmarkNodeData;
  43
  44 namespace extensions {
  45
  46 namespace bookmark_keys = bookmark_api_constants;
  47 namespace bookmark_manager_private = api::bookmark_manager_private;
  48 namespace CanPaste = api::bookmark_manager_private::CanPaste;
  49 namespace Copy = api::bookmark_manager_private::Copy;
  50 namespace CreateWithMetaInfo =
  51     api::bookmark_manager_private::CreateWithMetaInfo;
  52 namespace Cut = api::bookmark_manager_private::Cut;
  53 namespace Drop = api::bookmark_manager_private::Drop;
  54 namespace GetSubtree = api::bookmark_manager_private::GetSubtree;
  55 namespace GetMetaInfo = api::bookmark_manager_private::GetMetaInfo;
  56 namespace Paste = api::bookmark_manager_private::Paste;
  57 namespace RedoInfo = api::bookmark_manager_private::GetRedoInfo;
  58 namespace RemoveTrees = api::bookmark_manager_private::RemoveTrees;
  59 namespace SetMetaInfo = api::bookmark_manager_private::SetMetaInfo;
  60 namespace SortChildren = api::bookmark_manager_private::SortChildren;
  61 namespace StartDrag = api::bookmark_manager_private::StartDrag;
  62 namespace UndoInfo = api::bookmark_manager_private::GetUndoInfo;
  63 namespace UpdateMetaInfo = api::bookmark_manager_private::UpdateMetaInfo;
  64
  65 using content::WebContents;
  66
  67 namespace {
  68
  69 // Returns a single bookmark node from the argument ID.
  70 // This returns NULL in case of failure.
  71 const BookmarkNode* GetNodeFromString(BookmarkModel* model,
  72                                       const std::string& id_string) {
  73   int64 id;
  74   if (!base::StringToInt64(id_string, &id))
  75     return NULL;
  76   return bookmarks::GetBookmarkNodeByID(model, id);
  77 }
  78
  79 // Gets a vector of bookmark nodes from the argument list of IDs.
  80 // This returns false in the case of failure.
  81 bool GetNodesFromVector(BookmarkModel* model,
  82                         const std::vector<std::string>& id_strings,
  83                         std::vector<const BookmarkNode*>* nodes) {
  84   if (id_strings.empty())
  85     return false;
  86
  87   for (size_t i = 0; i < id_strings.size(); ++i) {
  88     const BookmarkNode* node = GetNodeFromString(model, id_strings[i]);
  89     if (!node)
  90       return false;
  91     nodes->push_back(node);
  92   }
  93
  94   return true;
  95 }
  96
  97 // Recursively create a bookmark_manager_private::BookmarkNodeDataElement from
  98 // a bookmark node. This is by used |BookmarkNodeDataToJSON| when the data comes
  99 // from the current profile. In this case we have a BookmarkNode since we got
 100 // the data from the current profile.
 101 linked_ptr<bookmark_manager_private::BookmarkNodeDataElement>
 102 CreateNodeDataElementFromBookmarkNode(const BookmarkNode& node) {
 103   linked_ptr<bookmark_manager_private::BookmarkNodeDataElement> element(
 104       new bookmark_manager_private::BookmarkNodeDataElement);
 105   // Add id and parentId so we can associate the data with existing nodes on the
 106   // client side.
 107   element->id.reset(new std::string(base::Int64ToString(node.id())));
 108   element->parent_id.reset(
 109       new std::string(base::Int64ToString(node.parent()->id())));
 110
 111   if (node.is_url())
 112     element->url.reset(new std::string(node.url().spec()));
 113
 114   element->title = base::UTF16ToUTF8(node.GetTitle());
 115   for (int i = 0; i < node.child_count(); ++i) {
 116     element->children.push_back(
 117         CreateNodeDataElementFromBookmarkNode(*node.GetChild(i)));
 118   }
 119
 120   return element;
 121 }
 122
 123 // Recursively create a bookmark_manager_private::BookmarkNodeDataElement from
 124 // a BookmarkNodeData::Element. This is used by |BookmarkNodeDataToJSON| when
 125 // the data comes from a different profile. When the data comes from a different
 126 // profile we do not have any IDs or parent IDs.
 127 linked_ptr<bookmark_manager_private::BookmarkNodeDataElement>
 128 CreateApiNodeDataElement(const BookmarkNodeData::Element& element) {
 129   linked_ptr<bookmark_manager_private::BookmarkNodeDataElement> node_element(
 130       new bookmark_manager_private::BookmarkNodeDataElement);
 131
 132   if (element.is_url)
 133     node_element->url.reset(new std::string(element.url.spec()));
 134   node_element->title = base::UTF16ToUTF8(element.title);
 135   for (size_t i = 0; i < element.children.size(); ++i) {
 136     node_element->children.push_back(
 137         CreateApiNodeDataElement(element.children[i]));
 138   }
 139
 140   return node_element;
 141 }
 142
 143 // Creates a bookmark_manager_private::BookmarkNodeData from a BookmarkNodeData.
 144 scoped_ptr<bookmark_manager_private::BookmarkNodeData>
 145 CreateApiBookmarkNodeData(Profile* profile, const BookmarkNodeData& data) {
 146   const base::FilePath& profile_path = profile->GetPath();
 147
 148   scoped_ptr<bookmark_manager_private::BookmarkNodeData> node_data(
 149       new bookmark_manager_private::BookmarkNodeData);
 150   node_data->same_profile = data.IsFromProfilePath(profile_path);
 151
 152   if (node_data->same_profile) {
 153     std::vector<const BookmarkNode*> nodes = data.GetNodes(
 154         BookmarkModelFactory::GetForProfile(profile), profile_path);
 155     for (size_t i = 0; i < nodes.size(); ++i) {
 156       node_data->elements.push_back(
 157           CreateNodeDataElementFromBookmarkNode(*nodes[i]));
 158     }
 159   } else {
 160     // We do not have a node IDs when the data comes from a different profile.
 161     std::vector<BookmarkNodeData::Element> elements = data.elements;
 162     for (size_t i = 0; i < elements.size(); ++i)
 163       node_data->elements.push_back(CreateApiNodeDataElement(elements[i]));
 164   }
 165   return node_data.Pass();
 166 }
 167
 168 }  // namespace
 169
 170 BookmarkManagerPrivateEventRouter::BookmarkManagerPrivateEventRouter(
 171     content::BrowserContext* browser_context,
 172     BookmarkModel* bookmark_model)
 173     : browser_context_(browser_context), bookmark_model_(bookmark_model) {
 174   bookmark_model_->AddObserver(this);
 175 }
 176
 177 BookmarkManagerPrivateEventRouter::~BookmarkManagerPrivateEventRouter() {
 178   if (bookmark_model_)
 179     bookmark_model_->RemoveObserver(this);
 180 }
 181
 182 void BookmarkManagerPrivateEventRouter::DispatchEvent(
 183     const std::string& event_name,
 184     scoped_ptr<base::ListValue> event_args) {
 185   extensions::EventRouter::Get(browser_context_)->BroadcastEvent(
 186       make_scoped_ptr(new extensions::Event(event_name, event_args.Pass())));
 187 }
 188
 189 void BookmarkManagerPrivateEventRouter::BookmarkModelChanged() {}
 190
 191 void BookmarkManagerPrivateEventRouter::BookmarkModelBeingDeleted(
 192     BookmarkModel* model) {
 193   bookmark_model_ = NULL;
 194 }
 195
 196 void BookmarkManagerPrivateEventRouter::OnWillChangeBookmarkMetaInfo(
 197     BookmarkModel* model,
 198     const BookmarkNode* node) {
 199   DCHECK(prev_meta_info_.empty());
 200   if (node->GetMetaInfoMap())
 201     prev_meta_info_ = *node->GetMetaInfoMap();
 202 }
 203
 204 void BookmarkManagerPrivateEventRouter::BookmarkMetaInfoChanged(
 205     BookmarkModel* model,
 206     const BookmarkNode* node) {
 207   const BookmarkNode::MetaInfoMap* new_meta_info = node->GetMetaInfoMap();
 208   bookmark_manager_private::MetaInfoFields changes;
 209
 210   // Identify changed/removed fields:
 211   for (BookmarkNode::MetaInfoMap::const_iterator it = prev_meta_info_.begin();
 212        it != prev_meta_info_.end();
 213        ++it) {
 214     if (!new_meta_info) {
 215       changes.additional_properties[it->first] = "";
 216     } else {
 217       BookmarkNode::MetaInfoMap::const_iterator new_meta_field =
 218           new_meta_info->find(it->first);
 219       if (new_meta_field == new_meta_info->end()) {
 220         changes.additional_properties[it->first] = "";
 221       } else if (it->second != new_meta_field->second) {
 222         changes.additional_properties[it->first] = new_meta_field->second;
 223       }
 224     }
 225   }
 226
 227   // Identify added fields:
 228   if (new_meta_info) {
 229     for (BookmarkNode::MetaInfoMap::const_iterator it = new_meta_info->begin();
 230          it != new_meta_info->end();
 231          ++it) {
 232       BookmarkNode::MetaInfoMap::const_iterator prev_meta_field =
 233           prev_meta_info_.find(it->first);
 234       if (prev_meta_field == prev_meta_info_.end())
 235         changes.additional_properties[it->first] = it->second;
 236     }
 237   }
 238
 239   prev_meta_info_.clear();
 240   DispatchEvent(bookmark_manager_private::OnMetaInfoChanged::kEventName,
 241                 bookmark_manager_private::OnMetaInfoChanged::Create(
 242                     base::Int64ToString(node->id()), changes));
 243 }
 244
 245 BookmarkManagerPrivateAPI::BookmarkManagerPrivateAPI(
 246     content::BrowserContext* browser_context)
 247     : browser_context_(browser_context) {
 248   EventRouter* event_router = EventRouter::Get(browser_context);
 249   event_router->RegisterObserver(
 250       this, bookmark_manager_private::OnMetaInfoChanged::kEventName);
 251 }
 252
 253 BookmarkManagerPrivateAPI::~BookmarkManagerPrivateAPI() {}
 254
 255 void BookmarkManagerPrivateAPI::Shutdown() {
 256   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 257 }
 258
 259 static base::LazyInstance<
 260     BrowserContextKeyedAPIFactory<BookmarkManagerPrivateAPI> > g_factory =
 261     LAZY_INSTANCE_INITIALIZER;
 262
 263 // static
 264 BrowserContextKeyedAPIFactory<BookmarkManagerPrivateAPI>*
 265 BookmarkManagerPrivateAPI::GetFactoryInstance() {
 266   return g_factory.Pointer();
 267 }
 268
 269 void BookmarkManagerPrivateAPI::OnListenerAdded(
 270     const EventListenerInfo& details) {
 271   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 272   event_router_.reset(new BookmarkManagerPrivateEventRouter(
 273       browser_context_,
 274       BookmarkModelFactory::GetForProfile(
 275           Profile::FromBrowserContext(browser_context_))));
 276 }
 277
 278 BookmarkManagerPrivateDragEventRouter::BookmarkManagerPrivateDragEventRouter(
 279     Profile* profile,
 280     content::WebContents* web_contents)
 281     : profile_(profile), web_contents_(web_contents) {
 282   BookmarkTabHelper* bookmark_tab_helper =
 283       BookmarkTabHelper::FromWebContents(web_contents_);
 284   bookmark_tab_helper->set_bookmark_drag_delegate(this);
 285 }
 286
 287 BookmarkManagerPrivateDragEventRouter::
 288     ~BookmarkManagerPrivateDragEventRouter() {
 289   BookmarkTabHelper* bookmark_tab_helper =
 290       BookmarkTabHelper::FromWebContents(web_contents_);
 291   if (bookmark_tab_helper->bookmark_drag_delegate() == this)
 292     bookmark_tab_helper->set_bookmark_drag_delegate(NULL);
 293 }
 294
 295 void BookmarkManagerPrivateDragEventRouter::DispatchEvent(
 296     const std::string& event_name,
 297     scoped_ptr<base::ListValue> args) {
 298   EventRouter* event_router = EventRouter::Get(profile_);
 299   if (!event_router)
 300     return;
 301
 302   scoped_ptr<Event> event(new Event(event_name, args.Pass()));
 303   event_router->BroadcastEvent(event.Pass());
 304 }
 305
 306 void BookmarkManagerPrivateDragEventRouter::OnDragEnter(
 307     const BookmarkNodeData& data) {
 308   if (data.size() == 0)
 309     return;
 310   DispatchEvent(bookmark_manager_private::OnDragEnter::kEventName,
 311                 bookmark_manager_private::OnDragEnter::Create(
 312                     *CreateApiBookmarkNodeData(profile_, data)));
 313 }
 314
 315 void BookmarkManagerPrivateDragEventRouter::OnDragOver(
 316     const BookmarkNodeData& data) {
 317   // Intentionally empty since these events happens too often and floods the
 318   // message queue. We do not need this event for the bookmark manager anyway.
 319 }
 320
 321 void BookmarkManagerPrivateDragEventRouter::OnDragLeave(
 322     const BookmarkNodeData& data) {
 323   if (data.size() == 0)
 324     return;
 325   DispatchEvent(bookmark_manager_private::OnDragLeave::kEventName,
 326                 bookmark_manager_private::OnDragLeave::Create(
 327                     *CreateApiBookmarkNodeData(profile_, data)));
 328 }
 329
 330 void BookmarkManagerPrivateDragEventRouter::OnDrop(
 331     const BookmarkNodeData& data) {
 332   if (data.size() == 0)
 333     return;
 334   DispatchEvent(bookmark_manager_private::OnDrop::kEventName,
 335                 bookmark_manager_private::OnDrop::Create(
 336                     *CreateApiBookmarkNodeData(profile_, data)));
 337
 338   // Make a copy that is owned by this instance.
 339   ClearBookmarkNodeData();
 340   bookmark_drag_data_ = data;
 341 }
 342
 343 const BookmarkNodeData*
 344 BookmarkManagerPrivateDragEventRouter::GetBookmarkNodeData() {
 345   if (bookmark_drag_data_.is_valid())
 346     return &bookmark_drag_data_;
 347   return NULL;
 348 }
 349
 350 void BookmarkManagerPrivateDragEventRouter::ClearBookmarkNodeData() {
 351   bookmark_drag_data_.Clear();
 352 }
 353
 354 bool ClipboardBookmarkManagerFunction::CopyOrCut(bool cut,
 355     const std::vector<std::string>& id_list) {
 356   BookmarkModel* model = GetBookmarkModel();
 357   ChromeBookmarkClient* client = GetChromeBookmarkClient();
 358   std::vector<const BookmarkNode*> nodes;
 359   EXTENSION_FUNCTION_VALIDATE(GetNodesFromVector(model, id_list, &nodes));
 360   if (cut && client->HasDescendantsOfManagedNode(nodes)) {
 361     error_ = bookmark_keys::kModifyManagedError;
 362     return false;
 363   }
 364   bookmarks::CopyToClipboard(model, nodes, cut);
 365   return true;
 366 }
 367
 368 bool BookmarkManagerPrivateCopyFunction::RunOnReady() {
 369   scoped_ptr<Copy::Params> params(Copy::Params::Create(*args_));
 370   EXTENSION_FUNCTION_VALIDATE(params);
 371   return CopyOrCut(false, params->id_list);
 372 }
 373
 374 bool BookmarkManagerPrivateCutFunction::RunOnReady() {
 375   if (!EditBookmarksEnabled())
 376     return false;
 377
 378   scoped_ptr<Cut::Params> params(Cut::Params::Create(*args_));
 379   EXTENSION_FUNCTION_VALIDATE(params);
 380   return CopyOrCut(true, params->id_list);
 381 }
 382
 383 bool BookmarkManagerPrivatePasteFunction::RunOnReady() {
 384   if (!EditBookmarksEnabled())
 385     return false;
 386
 387   scoped_ptr<Paste::Params> params(Paste::Params::Create(*args_));
 388   EXTENSION_FUNCTION_VALIDATE(params);
 389   BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
 390   const BookmarkNode* parent_node = GetNodeFromString(model, params->parent_id);
 391   if (!CanBeModified(parent_node))
 392     return false;
 393   bool can_paste = bookmarks::CanPasteFromClipboard(model, parent_node);
 394   if (!can_paste)
 395     return false;
 396
 397   // We want to use the highest index of the selected nodes as a destination.
 398   std::vector<const BookmarkNode*> nodes;
 399   // No need to test return value, if we got an empty list, we insert at end.
 400   if (params->selected_id_list)
 401     GetNodesFromVector(model, *params->selected_id_list, &nodes);
 402   int highest_index = -1;  // -1 means insert at end of list.
 403   for (size_t i = 0; i < nodes.size(); ++i) {
 404     // + 1 so that we insert after the selection.
 405     int index = parent_node->GetIndexOf(nodes[i]) + 1;
 406     if (index > highest_index)
 407       highest_index = index;
 408   }
 409
 410   bookmarks::PasteFromClipboard(model, parent_node, highest_index);
 411   return true;
 412 }
 413
 414 bool BookmarkManagerPrivateCanPasteFunction::RunOnReady() {
 415   if (!EditBookmarksEnabled())
 416     return false;
 417
 418   scoped_ptr<CanPaste::Params> params(CanPaste::Params::Create(*args_));
 419   EXTENSION_FUNCTION_VALIDATE(params);
 420
 421   BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
 422   const BookmarkNode* parent_node = GetNodeFromString(model, params->parent_id);
 423   if (!parent_node) {
 424     error_ = bookmark_keys::kNoParentError;
 425     return false;
 426   }
 427   bool can_paste = bookmarks::CanPasteFromClipboard(model, parent_node);
 428   SetResult(new base::FundamentalValue(can_paste));
 429   return true;
 430 }
 431
 432 bool BookmarkManagerPrivateSortChildrenFunction::RunOnReady() {
 433   if (!EditBookmarksEnabled())
 434     return false;
 435
 436   scoped_ptr<SortChildren::Params> params(SortChildren::Params::Create(*args_));
 437   EXTENSION_FUNCTION_VALIDATE(params);
 438
 439   BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
 440   const BookmarkNode* parent_node = GetNodeFromString(model, params->parent_id);
 441   if (!CanBeModified(parent_node))
 442     return false;
 443   model->SortChildren(parent_node);
 444   return true;
 445 }
 446
 447 bool BookmarkManagerPrivateGetStringsFunction::RunAsync() {
 448   base::DictionaryValue* localized_strings = new base::DictionaryValue();
 449
 450   localized_strings->SetString("title",
 451       l10n_util::GetStringUTF16(IDS_BOOKMARK_MANAGER_TITLE));
 452   localized_strings->SetString("search_button",
 453       l10n_util::GetStringUTF16(IDS_BOOKMARK_MANAGER_SEARCH_BUTTON));
 454   localized_strings->SetString("organize_menu",
 455       l10n_util::GetStringUTF16(IDS_BOOKMARK_MANAGER_ORGANIZE_MENU));
 456   localized_strings->SetString("show_in_folder",
 457       l10n_util::GetStringUTF16(IDS_BOOKMARK_MANAGER_SHOW_IN_FOLDER));
 458   localized_strings->SetString("sort",
 459       l10n_util::GetStringUTF16(IDS_BOOKMARK_MANAGER_SORT));
 460   localized_strings->SetString("import_menu",
 461       l10n_util::GetStringUTF16(IDS_BOOKMARK_MANAGER_IMPORT_MENU));
 462   localized_strings->SetString("export_menu",
 463       l10n_util::GetStringUTF16(IDS_BOOKMARK_MANAGER_EXPORT_MENU));
 464   localized_strings->SetString("rename_folder",
 465       l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_RENAME_FOLDER));
 466   localized_strings->SetString("edit",
 467       l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_EDIT));
 468   localized_strings->SetString("should_open_all",
 469       l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_SHOULD_OPEN_ALL));
 470   localized_strings->SetString("open_incognito",
 471       l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_OPEN_INCOGNITO));
 472   localized_strings->SetString("open_in_new_tab",
 473       l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_OPEN_IN_NEW_TAB));
 474   localized_strings->SetString("open_in_new_window",
 475       l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_OPEN_IN_NEW_WINDOW));
 476   localized_strings->SetString("add_new_bookmark",
 477       l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_ADD_NEW_BOOKMARK));
 478   localized_strings->SetString("new_folder",
 479       l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_NEW_FOLDER));
 480   localized_strings->SetString("open_all",
 481       l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_OPEN_ALL));
 482   localized_strings->SetString("open_all_new_window",
 483       l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW));
 484   localized_strings->SetString("open_all_incognito",
 485       l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_OPEN_ALL_INCOGNITO));
 486   localized_strings->SetString("remove",
 487       l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_REMOVE));
 488   localized_strings->SetString("copy",
 489       l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_COPY));
 490   localized_strings->SetString("cut",
 491       l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_CUT));
 492   localized_strings->SetString("paste",
 493       l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_PASTE));
 494   localized_strings->SetString("delete",
 495       l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_DELETE));
 496   localized_strings->SetString("undo_delete",
 497       l10n_util::GetStringUTF16(IDS_UNDO_DELETE));
 498   localized_strings->SetString("new_folder_name",
 499       l10n_util::GetStringUTF16(IDS_BOOKMARK_EDITOR_NEW_FOLDER_NAME));
 500   localized_strings->SetString("name_input_placeholder",
 501       l10n_util::GetStringUTF16(IDS_BOOKMARK_MANAGER_NAME_INPUT_PLACE_HOLDER));
 502   localized_strings->SetString("url_input_placeholder",
 503       l10n_util::GetStringUTF16(IDS_BOOKMARK_MANAGER_URL_INPUT_PLACE_HOLDER));
 504   localized_strings->SetString("invalid_url",
 505       l10n_util::GetStringUTF16(IDS_BOOKMARK_MANAGER_INVALID_URL));
 506   localized_strings->SetString("recent",
 507       l10n_util::GetStringUTF16(IDS_BOOKMARK_MANAGER_RECENT));
 508   localized_strings->SetString("search",
 509       l10n_util::GetStringUTF16(IDS_BOOKMARK_MANAGER_SEARCH));
 510   localized_strings->SetString("save",
 511       l10n_util::GetStringUTF16(IDS_SAVE));
 512   localized_strings->SetString("cancel",
 513       l10n_util::GetStringUTF16(IDS_CANCEL));
 514
 515   webui::SetFontAndTextDirection(localized_strings);
 516
 517   SetResult(localized_strings);
 518
 519   // This is needed because unlike the rest of these functions, this class
 520   // inherits from AsyncFunction directly, rather than BookmarkFunction.
 521   SendResponse(true);
 522
 523   return true;
 524 }
 525
 526 bool BookmarkManagerPrivateStartDragFunction::RunOnReady() {
 527   if (!EditBookmarksEnabled())
 528     return false;
 529
 530   scoped_ptr<StartDrag::Params> params(StartDrag::Params::Create(*args_));
 531   EXTENSION_FUNCTION_VALIDATE(params);
 532
 533   BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
 534   std::vector<const BookmarkNode*> nodes;
 535   EXTENSION_FUNCTION_VALIDATE(
 536       GetNodesFromVector(model, params->id_list, &nodes));
 537
 538   WebContents* web_contents =
 539       WebContents::FromRenderViewHost(render_view_host_);
 540   if (GetViewType(web_contents) == VIEW_TYPE_TAB_CONTENTS) {
 541     WebContents* web_contents =
 542         dispatcher()->delegate()->GetAssociatedWebContents();
 543     CHECK(web_contents);
 544
 545     ui::DragDropTypes::DragEventSource source =
 546         ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE;
 547     if (params->is_from_touch)
 548       source = ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH;
 549
 550     chrome::DragBookmarks(
 551         GetProfile(), nodes, web_contents->GetNativeView(), source);
 552
 553     return true;
 554   } else {
 555     NOTREACHED();
 556     return false;
 557   }
 558 }
 559
 560 bool BookmarkManagerPrivateDropFunction::RunOnReady() {
 561   if (!EditBookmarksEnabled())
 562     return false;
 563
 564   scoped_ptr<Drop::Params> params(Drop::Params::Create(*args_));
 565   EXTENSION_FUNCTION_VALIDATE(params);
 566
 567   BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
 568
 569   const BookmarkNode* drop_parent = GetNodeFromString(model, params->parent_id);
 570   if (!CanBeModified(drop_parent))
 571     return false;
 572
 573   int drop_index;
 574   if (params->index)
 575     drop_index = *params->index;
 576   else
 577     drop_index = drop_parent->child_count();
 578
 579   WebContents* web_contents =
 580       WebContents::FromRenderViewHost(render_view_host_);
 581   if (GetViewType(web_contents) == VIEW_TYPE_TAB_CONTENTS) {
 582     WebContents* web_contents =
 583         dispatcher()->delegate()->GetAssociatedWebContents();
 584     CHECK(web_contents);
 585     ExtensionWebUI* web_ui =
 586         static_cast<ExtensionWebUI*>(web_contents->GetWebUI()->GetController());
 587     CHECK(web_ui);
 588     BookmarkManagerPrivateDragEventRouter* router =
 589         web_ui->bookmark_manager_private_drag_event_router();
 590
 591     DCHECK(router);
 592     const BookmarkNodeData* drag_data = router->GetBookmarkNodeData();
 593     if (drag_data == NULL) {
 594       NOTREACHED() <<"Somehow we're dropping null bookmark data";
 595       return false;
 596     }
 597     const bool copy = false;
 598     chrome::DropBookmarks(
 599         GetProfile(), *drag_data, drop_parent, drop_index, copy);
 600
 601     router->ClearBookmarkNodeData();
 602     return true;
 603   } else {
 604     NOTREACHED();
 605     return false;
 606   }
 607 }
 608
 609 bool BookmarkManagerPrivateGetSubtreeFunction::RunOnReady() {
 610   scoped_ptr<GetSubtree::Params> params(GetSubtree::Params::Create(*args_));
 611   EXTENSION_FUNCTION_VALIDATE(params);
 612
 613   const BookmarkNode* node = NULL;
 614
 615   if (params->id == "") {
 616     BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
 617     node = model->root_node();
 618   } else {
 619     node = GetBookmarkNodeFromId(params->id);
 620     if (!node)
 621       return false;
 622   }
 623
 624   std::vector<linked_ptr<api::bookmarks::BookmarkTreeNode> > nodes;
 625   ChromeBookmarkClient* client = GetChromeBookmarkClient();
 626   if (params->folders_only)
 627     bookmark_api_helpers::AddNodeFoldersOnly(client, node, &nodes, true);
 628   else
 629     bookmark_api_helpers::AddNode(client, node, &nodes, true);
 630   results_ = GetSubtree::Results::Create(nodes);
 631   return true;
 632 }
 633
 634 bool BookmarkManagerPrivateCanEditFunction::RunOnReady() {
 635   PrefService* prefs = user_prefs::UserPrefs::Get(GetProfile());
 636   SetResult(new base::FundamentalValue(
 637       prefs->GetBoolean(bookmarks::prefs::kEditBookmarksEnabled)));
 638   return true;
 639 }
 640
 641 bool BookmarkManagerPrivateRecordLaunchFunction::RunOnReady() {
 642   RecordBookmarkLaunch(NULL, BOOKMARK_LAUNCH_LOCATION_MANAGER);
 643   return true;
 644 }
 645
 646 bool BookmarkManagerPrivateCreateWithMetaInfoFunction::RunOnReady() {
 647   scoped_ptr<CreateWithMetaInfo::Params> params(
 648       CreateWithMetaInfo::Params::Create(*args_));
 649   EXTENSION_FUNCTION_VALIDATE(params);
 650
 651   BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
 652   const BookmarkNode* node = CreateBookmarkNode(
 653       model, params->bookmark, &params->meta_info.additional_properties);
 654   if (!node)
 655     return false;
 656
 657   scoped_ptr<api::bookmarks::BookmarkTreeNode> result_node(
 658       bookmark_api_helpers::GetBookmarkTreeNode(
 659           GetChromeBookmarkClient(), node, false, false));
 660   results_ = CreateWithMetaInfo::Results::Create(*result_node);
 661
 662   return true;
 663 }
 664
 665 bool BookmarkManagerPrivateGetMetaInfoFunction::RunOnReady() {
 666   scoped_ptr<GetMetaInfo::Params> params(GetMetaInfo::Params::Create(*args_));
 667   EXTENSION_FUNCTION_VALIDATE(params);
 668
 669   if (params->id) {
 670     const BookmarkNode* node = GetBookmarkNodeFromId(*params->id);
 671     if (!node)
 672       return false;
 673
 674     if (params->key) {
 675       std::string value;
 676       if (node->GetMetaInfo(*params->key, &value)) {
 677         GetMetaInfo::Results::Value result;
 678         result.as_string.reset(new std::string(value));
 679         results_ = GetMetaInfo::Results::Create(result);
 680       }
 681     } else {
 682       GetMetaInfo::Results::Value result;
 683       result.as_object.reset(new GetMetaInfo::Results::Value::Object);
 684
 685       const BookmarkNode::MetaInfoMap* meta_info = node->GetMetaInfoMap();
 686       if (meta_info) {
 687         BookmarkNode::MetaInfoMap::const_iterator itr;
 688         base::DictionaryValue& temp = result.as_object->additional_properties;
 689         for (itr = meta_info->begin(); itr != meta_info->end(); itr++) {
 690           temp.SetStringWithoutPathExpansion(itr->first, itr->second);
 691         }
 692       }
 693       results_ = GetMetaInfo::Results::Create(result);
 694     }
 695   } else {
 696     if (params->key) {
 697       error_ = bookmark_api_constants::kInvalidParamError;
 698       return true;
 699     }
 700
 701     BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
 702     const BookmarkNode* node = model->root_node();
 703
 704     GetMetaInfo::Results::Value result;
 705     result.as_object.reset(new GetMetaInfo::Results::Value::Object);
 706
 707     bookmark_api_helpers::GetMetaInfo(*node,
 708         &result.as_object->additional_properties);
 709
 710     results_ = GetMetaInfo::Results::Create(result);
 711   }
 712
 713   return true;
 714 }
 715
 716 bool BookmarkManagerPrivateSetMetaInfoFunction::RunOnReady() {
 717   scoped_ptr<SetMetaInfo::Params> params(SetMetaInfo::Params::Create(*args_));
 718   EXTENSION_FUNCTION_VALIDATE(params);
 719
 720   const BookmarkNode* node = GetBookmarkNodeFromId(params->id);
 721   if (!node)
 722     return false;
 723
 724   BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
 725   model->SetNodeMetaInfo(node, params->key, params->value);
 726   return true;
 727 }
 728
 729 bool BookmarkManagerPrivateUpdateMetaInfoFunction::RunOnReady() {
 730   scoped_ptr<UpdateMetaInfo::Params> params(
 731       UpdateMetaInfo::Params::Create(*args_));
 732   EXTENSION_FUNCTION_VALIDATE(params);
 733
 734   const BookmarkNode* node = GetBookmarkNodeFromId(params->id);
 735   if (!node)
 736     return false;
 737
 738   BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
 739   BookmarkNode::MetaInfoMap new_meta_info(
 740       params->meta_info_changes.additional_properties);
 741   if (node->GetMetaInfoMap()) {
 742     new_meta_info.insert(node->GetMetaInfoMap()->begin(),
 743                          node->GetMetaInfoMap()->end());
 744   }
 745   model->SetNodeMetaInfoMap(node, new_meta_info);
 746
 747   return true;
 748 }
 749
 750 bool BookmarkManagerPrivateCanOpenNewWindowsFunction::RunOnReady() {
 751   bool can_open_new_windows = true;
 752   SetResult(new base::FundamentalValue(can_open_new_windows));
 753   return true;
 754 }
 755
 756 bool BookmarkManagerPrivateRemoveTreesFunction::RunOnReady() {
 757   scoped_ptr<RemoveTrees::Params> params(RemoveTrees::Params::Create(*args_));
 758   EXTENSION_FUNCTION_VALIDATE(params);
 759
 760   BookmarkModel* model = GetBookmarkModel();
 761   ChromeBookmarkClient* client = GetChromeBookmarkClient();
 762   bookmarks::ScopedGroupBookmarkActions group_deletes(model);
 763   int64 id;
 764   for (size_t i = 0; i < params->id_list.size(); ++i) {
 765     if (!GetBookmarkIdAsInt64(params->id_list[i], &id))
 766       return false;
 767     if (!bookmark_api_helpers::RemoveNode(model, client, id, true, &error_))
 768       return false;
 769   }
 770
 771   return true;
 772 }
 773
 774 bool BookmarkManagerPrivateUndoFunction::RunOnReady() {
 775   BookmarkUndoServiceFactory::GetForProfile(GetProfile())->undo_manager()->
 776       Undo();
 777   return true;
 778 }
 779
 780 bool BookmarkManagerPrivateRedoFunction::RunOnReady() {
 781   BookmarkUndoServiceFactory::GetForProfile(GetProfile())->undo_manager()->
 782       Redo();
 783   return true;
 784 }
 785
 786 bool BookmarkManagerPrivateGetUndoInfoFunction::RunOnReady() {
 787   UndoManager* undo_manager =
 788       BookmarkUndoServiceFactory::GetForProfile(GetProfile())->undo_manager();
 789
 790   UndoInfo::Results::Result result;
 791   result.enabled = undo_manager->undo_count() > 0;
 792   result.label = base::UTF16ToUTF8(undo_manager->GetUndoLabel());
 793
 794   results_ = UndoInfo::Results::Create(result);
 795   return true;
 796 }
 797
 798 bool BookmarkManagerPrivateGetRedoInfoFunction::RunOnReady() {
 799   UndoManager* undo_manager =
 800       BookmarkUndoServiceFactory::GetForProfile(GetProfile())->undo_manager();
 801
 802   RedoInfo::Results::Result result;
 803   result.enabled = undo_manager->redo_count() > 0;
 804   result.label = base::UTF16ToUTF8(undo_manager->GetRedoLabel());
 805
 806   results_ = RedoInfo::Results::Create(result);
 807   return true;
 808 }
 809
 810 }  // namespace extensions