Move BookmarkManagerAPI to c/b/e/api

chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_api.cc

 // Copyright (c) 2012 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_manager_extension_api.h"
+#include "chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_api.h"
 
 #include <vector>
 
 #include "base/json/json_writer.h"
 #include "base/prefs/public/pref_service_base.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/bookmark_node_data.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
-// TODO (rdevlin.cronin): Move BookmarkManagerAPI to
-// chrome/browser/extensions/api so these two aren't interdependent.
+#include "chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_api_constants.h"
 #include "chrome/browser/extensions/api/bookmarks/bookmark_api_constants.h"
 #include "chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.h"
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_web_ui.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/chrome_url_data_manager.h"
 #include "chrome/browser/view_type_utils.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_WIN)
 #include "win8/util/win8_util.h"
 #endif  // OS_WIN
 
-namespace keys = extensions::bookmark_api_constants;
+namespace extensions {
+
+namespace bookmark_keys = bookmark_api_constants;
+namespace manager_keys = bookmark_manager_api_constants;
 
 using content::WebContents;
 
 namespace {
 
 // Returns a single bookmark node from the argument ID.
 // This returns NULL in case of failure.
 const BookmarkNode* GetNodeFromArguments(BookmarkModel* model,
     const ListValue* args) {
   std::string id_string;
@@ skipping 36 matching lines @@
 
 // Recursively adds a node to a list. This is by used |BookmarkNodeDataToJSON|
 // when the data comes from the current profile. In this case we have a
 // BookmarkNode since we got the data from the current profile.
 void AddNodeToList(ListValue* list, const BookmarkNode& node) {
   DictionaryValue* dict = new DictionaryValue();
 
   // Add id and parentId so we can associate the data with existing nodes on the
   // client side.
   std::string id_string = base::Int64ToString(node.id());
-  dict->SetString(keys::kIdKey, id_string);
+  dict->SetString(bookmark_keys::kIdKey, id_string);
 
   std::string parent_id_string = base::Int64ToString(node.parent()->id());
-  dict->SetString(keys::kParentIdKey, parent_id_string);
+  dict->SetString(bookmark_keys::kParentIdKey, parent_id_string);
 
   if (node.is_url())
-    dict->SetString(keys::kUrlKey, node.url().spec());
+    dict->SetString(bookmark_keys::kUrlKey, node.url().spec());
 
-  dict->SetString(keys::kTitleKey, node.GetTitle());
+  dict->SetString(bookmark_keys::kTitleKey, node.GetTitle());
 
   ListValue* children = new ListValue();
   for (int i = 0; i < node.child_count(); ++i)
     AddNodeToList(children, *node.GetChild(i));
-  dict->Set(keys::kChildrenKey, children);
+  dict->Set(bookmark_keys::kChildrenKey, children);
 
   list->Append(dict);
 }
 
 // Recursively adds an element to a list. This is used by
 // |BookmarkNodeDataToJSON| when the data comes from a different profile. When
 // the data comes from a different profile we do not have any IDs or parent IDs.
 void AddElementToList(ListValue* list,
                       const BookmarkNodeData::Element& element) {
   DictionaryValue* dict = new DictionaryValue();
 
   if (element.is_url)
-    dict->SetString(keys::kUrlKey, element.url.spec());
+    dict->SetString(bookmark_keys::kUrlKey, element.url.spec());
 
-  dict->SetString(keys::kTitleKey, element.title);
+  dict->SetString(bookmark_keys::kTitleKey, element.title);
 
   ListValue* children = new ListValue();
   for (size_t i = 0; i < element.children.size(); ++i)
     AddElementToList(children, element.children[i]);
-  dict->Set(keys::kChildrenKey, children);
+  dict->Set(bookmark_keys::kChildrenKey, children);
 
   list->Append(dict);
 }
 
 // Builds the JSON structure based on the BookmarksDragData.
 void BookmarkNodeDataToJSON(Profile* profile, const BookmarkNodeData& data,
                             ListValue* args) {
   bool same_profile = data.IsFromProfile(profile);
   DictionaryValue* value = new DictionaryValue();
-  value->SetBoolean(keys::kSameProfileKey, same_profile);
+  value->SetBoolean(manager_keys::kSameProfileKey, same_profile);
 
   ListValue* list = new ListValue();
   if (same_profile) {
     std::vector<const BookmarkNode*> nodes = data.GetNodes(profile);
     for (size_t i = 0; i < nodes.size(); ++i)
       AddNodeToList(list, *nodes[i]);
   } else {
     // We do not have an node IDs when the data comes from a different profile.
     std::vector<BookmarkNodeData::Element> elements = data.elements;
     for (size_t i = 0; i < elements.size(); ++i)
       AddElementToList(list, elements[i]);
   }
-  value->Set(keys::kElementsKey, list);
+  value->Set(manager_keys::kElementsKey, list);
 
   args->Append(value);
 }
 
 }  // namespace
 
-BookmarkManagerExtensionEventRouter::BookmarkManagerExtensionEventRouter(
+BookmarkManagerPrivateEventRouter::BookmarkManagerPrivateEventRouter(
     Profile* profile,
     content::WebContents* web_contents)
     : profile_(profile),
       web_contents_(web_contents) {
   BookmarkTabHelper* bookmark_tab_helper =
       BookmarkTabHelper::FromWebContents(web_contents_);
   bookmark_tab_helper->set_bookmark_drag_delegate(this);
 }
 
-BookmarkManagerExtensionEventRouter::~BookmarkManagerExtensionEventRouter() {
+BookmarkManagerPrivateEventRouter::~BookmarkManagerPrivateEventRouter() {
   BookmarkTabHelper* bookmark_tab_helper =
       BookmarkTabHelper::FromWebContents(web_contents_);
   if (bookmark_tab_helper->bookmark_drag_delegate() == this)
     bookmark_tab_helper->set_bookmark_drag_delegate(NULL);
 }
 
-void BookmarkManagerExtensionEventRouter::DispatchEvent(
+void BookmarkManagerPrivateEventRouter::DispatchEvent(
     const char* event_name,
     scoped_ptr<ListValue> args) {
-  if (!extensions::ExtensionSystem::Get(profile_)->event_router())
+  if (!ExtensionSystem::Get(profile_)->event_router())
     return;
 
-  scoped_ptr<extensions::Event> event(new extensions::Event(
-      event_name, args.Pass()));
-  extensions::ExtensionSystem::Get(profile_)->event_router()->
-      BroadcastEvent(event.Pass());
+  scoped_ptr<Event> event(new Event(event_name, args.Pass()));
+  ExtensionSystem::Get(profile_)->event_router()->BroadcastEvent(event.Pass());
 }
 
-void BookmarkManagerExtensionEventRouter::DispatchDragEvent(
+void BookmarkManagerPrivateEventRouter::DispatchDragEvent(
     const BookmarkNodeData& data,
     const char* event_name) {
   if (data.size() == 0)
     return;
 
   scoped_ptr<ListValue> args(new ListValue());
   BookmarkNodeDataToJSON(profile_, data, args.get());
   DispatchEvent(event_name, args.Pass());
 }
 
-void BookmarkManagerExtensionEventRouter::OnDragEnter(
+void BookmarkManagerPrivateEventRouter::OnDragEnter(
     const BookmarkNodeData& data) {
-  DispatchDragEvent(data, keys::kOnBookmarkDragEnter);
+  DispatchDragEvent(data, manager_keys::kOnBookmarkDragEnter);
 }
 
-void BookmarkManagerExtensionEventRouter::OnDragOver(
+void BookmarkManagerPrivateEventRouter::OnDragOver(
     const BookmarkNodeData& data) {
   // Intentionally empty since these events happens too often and floods the
   // message queue. We do not need this event for the bookmark manager anyway.
 }
 
-void BookmarkManagerExtensionEventRouter::OnDragLeave(
+void BookmarkManagerPrivateEventRouter::OnDragLeave(
     const BookmarkNodeData& data) {
-  DispatchDragEvent(data, keys::kOnBookmarkDragLeave);
+  DispatchDragEvent(data, manager_keys::kOnBookmarkDragLeave);
 }
 
-void BookmarkManagerExtensionEventRouter::OnDrop(
-    const BookmarkNodeData& data) {
-  DispatchDragEvent(data, keys::kOnBookmarkDrop);
+void BookmarkManagerPrivateEventRouter::OnDrop(const BookmarkNodeData& data) {
+  DispatchDragEvent(data, manager_keys::kOnBookmarkDrop);
 
   // Make a copy that is owned by this instance.
   ClearBookmarkNodeData();
   bookmark_drag_data_ = data;
 }
 
 const BookmarkNodeData*
-BookmarkManagerExtensionEventRouter::GetBookmarkNodeData() {
+BookmarkManagerPrivateEventRouter::GetBookmarkNodeData() {
   if (bookmark_drag_data_.is_valid())
     return &bookmark_drag_data_;
   return NULL;
 }
 
-void BookmarkManagerExtensionEventRouter::ClearBookmarkNodeData() {
+void BookmarkManagerPrivateEventRouter::ClearBookmarkNodeData() {
   bookmark_drag_data_.Clear();
 }
 
 bool ClipboardBookmarkManagerFunction::CopyOrCut(bool cut) {
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   std::vector<const BookmarkNode*> nodes;
   EXTENSION_FUNCTION_VALIDATE(GetNodesFromArguments(model, args_.get(),
                                                     0, &nodes));
   bookmark_utils::CopyToClipboard(model, nodes, cut);
   return true;
 }
 
 bool CopyBookmarkManagerFunction::RunImpl() {
   return CopyOrCut(false);
 }
 
 bool CutBookmarkManagerFunction::RunImpl() {
   if (!EditBookmarksEnabled())
     return false;
   return CopyOrCut(true);
 }
 
 bool PasteBookmarkManagerFunction::RunImpl() {
   if (!EditBookmarksEnabled())
     return false;
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   const BookmarkNode* parent_node = GetNodeFromArguments(model, args_.get());
   if (!parent_node) {
-    error_ = keys::kNoParentError;
+    error_ = bookmark_keys::kNoParentError;
     return false;
   }
   bool can_paste = bookmark_utils::CanPasteFromClipboard(parent_node);
   if (!can_paste)
     return false;
 
   // We want to use the highest index of the selected nodes as a destination.
   std::vector<const BookmarkNode*> nodes;
   // No need to test return value, if we got an empty list, we insert at end.
   GetNodesFromArguments(model, args_.get(), 1, &nodes);
   int highest_index = -1;  // -1 means insert at end of list.
   for (size_t node = 0; node < nodes.size(); ++node) {
     // + 1 so that we insert after the selection.
     int this_node_index = parent_node->GetIndexOf(nodes[node]) + 1;
     if (this_node_index > highest_index)
       highest_index = this_node_index;
   }
 
   bookmark_utils::PasteFromClipboard(model, parent_node, highest_index);
   return true;
 }
 
 bool CanPasteBookmarkManagerFunction::RunImpl() {
   if (!EditBookmarksEnabled())
     return false;
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   const BookmarkNode* parent_node = GetNodeFromArguments(model, args_.get());
   if (!parent_node) {
-    error_ = keys::kNoParentError;
+    error_ = bookmark_keys::kNoParentError;
     return false;
   }
   bool can_paste = bookmark_utils::CanPasteFromClipboard(parent_node);
   SetResult(new base::FundamentalValue(can_paste));
   return true;
 }
 
 bool SortChildrenBookmarkManagerFunction::RunImpl() {
   if (!EditBookmarksEnabled())
     return false;
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   const BookmarkNode* parent_node = GetNodeFromArguments(model, args_.get());
   if (!parent_node) {
-    error_ = keys::kNoParentError;
+    error_ = bookmark_keys::kNoParentError;
     return false;
   }
   model->SortChildren(parent_node);
   return true;
 }
 
 bool BookmarkManagerGetStringsFunction::RunImpl() {
   DictionaryValue* localized_strings = new DictionaryValue();
 
   localized_strings->SetString("title",
@@ skipping 104 matching lines @@
   if (!EditBookmarksEnabled())
     return false;
 
   BookmarkModel* model =BookmarkModelFactory::GetForProfile(profile());
 
   int64 id;
   std::string id_string;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &id_string));
 
   if (!base::StringToInt64(id_string, &id)) {
-    error_ = keys::kInvalidIdError;
+    error_ = bookmark_keys::kInvalidIdError;
     return false;
   }
 
   const BookmarkNode* drop_parent = model->GetNodeByID(id);
   if (!drop_parent) {
-    error_ = keys::kNoParentError;
+    error_ = bookmark_keys::kNoParentError;
     return false;
   }
 
   int drop_index;
   if (HasOptionalArgument(1))
     EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(1, &drop_index));
   else
     drop_index = drop_parent->child_count();
 
   WebContents* web_contents =
       WebContents::FromRenderViewHost(render_view_host_);
   if (chrome::GetViewType(web_contents) == chrome::VIEW_TYPE_TAB_CONTENTS) {
     WebContents* web_contents =
         dispatcher()->delegate()->GetAssociatedWebContents();
     CHECK(web_contents);
     ExtensionWebUI* web_ui =
         static_cast<ExtensionWebUI*>(web_contents->GetWebUI()->GetController());
     CHECK(web_ui);
-    BookmarkManagerExtensionEventRouter* router =
-        web_ui->bookmark_manager_extension_event_router();
+    BookmarkManagerPrivateEventRouter* router =
+        web_ui->bookmark_manager_private_event_router();
 
     DCHECK(router);
     const BookmarkNodeData* drag_data = router->GetBookmarkNodeData();
     if (drag_data == NULL) {
       NOTREACHED() <<"Somehow we're dropping null bookmark data";
       return false;
     }
     bookmark_utils::PerformBookmarkDrop(profile(),
                                         *drag_data,
                                         drop_parent, drop_index);
@@ skipping 11 matching lines @@
   const BookmarkNode* node;
   int64 id;
   std::string id_string;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &id_string));
   bool folders_only;
   EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(1, &folders_only));
   if (id_string == "") {
     node = model->root_node();
   } else {
      if (!base::StringToInt64(id_string, &id)) {
-      error_ = keys::kInvalidIdError;
+      error_ = bookmark_keys::kInvalidIdError;
       return false;
     }
     node = model->GetNodeByID(id);
   }
   if (!node) {
-    error_ = keys::kNoNodeError;
+    error_ = bookmark_keys::kNoNodeError;
     return false;
   }
   scoped_ptr<ListValue> json(new ListValue());
-  if (folders_only) {
-    extensions::bookmark_api_helpers::AddNodeFoldersOnly(node,
-                                                   json.get(),
-                                                   true);
-  } else {
-    extensions::bookmark_api_helpers::AddNode(node, json.get(), true);
-  }
+  if (folders_only)
+    bookmark_api_helpers::AddNodeFoldersOnly(node, json.get(), true);
+  else
+    bookmark_api_helpers::AddNode(node, json.get(), true);
   SetResult(json.release());
   return true;
 }
 
 bool CanEditBookmarkManagerFunction::RunImpl() {
   PrefServiceBase* prefs = PrefServiceBase::FromBrowserContext(profile_);
   SetResult(new base::FundamentalValue(
       prefs->GetBoolean(prefs::kEditBookmarksEnabled)));
   return true;
 }
 
 bool RecordLaunchBookmarkFunction::RunImpl() {
   bookmark_utils::RecordBookmarkLaunch(bookmark_utils::LAUNCH_MANAGER);
   return true;
 }
 
 bool CanOpenNewWindowsBookmarkFunction::RunImpl() {
   bool can_open_new_windows = true;
 
 #if defined(OS_WIN)
   if (win8::IsSingleWindowMetroMode())
     can_open_new_windows = false;
 #endif  // OS_WIN
 
   SetResult(new base::FundamentalValue(can_open_new_windows));
   return true;
 }
+
+}  // namespace extensions